patate/ezfrags
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Initial commit of project structure, IDA database, the Tools, readme and license

Browse Source
This commit is contained in:
ALittlePatate
2021-12-18 13:02:24 +01:00
commit 0968b31444
40 changed files with 1232 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Ezfrags/AimAssist.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "Settings.hpp"
#include "AimAssist.h"
void aim_assist_thread() {
cheat_thread_state::aim_assist_thread_status = 1;
}

3
Ezfrags/AimAssist.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void aim_assist_thread();

6
Ezfrags/Aimlock.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "Settings.hpp"
#include "Aimlock.h"
void aimlock_thread() {
cheat_thread_state::aimlock_thread_status = 1;
}

3
Ezfrags/Aimlock.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void aimlock_thread();

40
Ezfrags/BunnyHop.cpp Normal file
View File

@@ -0,0 +1,40 @@
#include "Settings.hpp"
#include "MemManager.h"
#include "Signatures.h"
#include "BunnyHop.h"
#include "Signatures.h"
#include <iostream>
#include <Windows.h>
//This function is about 80% decompiled
void bunnyhop_thread() {
cheat_thread_state::bunnyhop_thread_status = 1;
while (1) {
while (!settings::bunnyhop_bool || !Mem::csgo_found || !Mem::client_dll_found) {
Sleep(5u);
}
//Mem::RPM<int>(Mem::client + get_sigs::dwLocalPlayer)
bool player_alive = true;
if (player_alive && GetAsyncKeyState(32) < 0)// If we're alive and we're pressing space
{
Mem::WPM<int>(Mem::client + Signatures::dwForceJump, 5);// force jump
Sleep(10u);
Mem::WPM<int>(Mem::client + Signatures::dwForceJump, 4);// unjump
}
Sleep(1u);
/*
while ( !bunnyhop_bool || !csgo_module || !client_module_found || !byte_4FBF0C || LocalPlayer_notsure == 1 )
Sleep(5u);
if ( ReadProcessMemory_2(player, v2, v3, v4, v5) && GetAsyncKeyState(32) < 0 )// If we're alive and we're pressing space
{
write_memory((LPVOID)(client + dwForceJump), 5);// force jump
Sleep(10u);
write_memory((LPVOID)(client + dwForceJump), 4);// unjump
}
Sleep(1u);
*/
}
}

3
Ezfrags/BunnyHop.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void bunnyhop_thread();

140
Ezfrags/Ezfrags.cpp Normal file
View File

@@ -0,0 +1,140 @@
#include <iostream>
#include <Windows.h>
#include "MemManager.cpp"
#include "Signatures.cpp"
#include "ShowFeatures.cpp"
#include "WaitForKeys.cpp"
#include "AimAssist.cpp"
#include "Aimlock.cpp"
#include "BunnyHop.cpp"
#include "GlowESP.cpp"
#include "KillMessage.cpp"
#include "NoFlash.cpp"
#include "Radar.cpp"
#include "Triggerbot.cpp"
#include "Settings.hpp"
#include "Ezfrags.h"
time_t TimeUpdate;
int main()
{
SetConsoleTitleA("EZfrags CS:GO multihack v9.65 public [www.EZfrags.co.uk]"); //Ezfrag premium ++ spinbout edition
std::cout << "EZfrags CS:GO multihack v9.65 public [www.EZfrags.co.uk]" << "\n";
time(&TimeUpdate);
if (TimeUpdate - 1591304279 > 864000) // If our version is older than 10 days
{
std::cout << '\n' << "!!! WARNING !!!: This version is more than 10 days old.";
std::cout << '\n' << "You should go and download a new build from www.EZfrags.co.uk" << std::endl;
}
std::cout << '\n' << "The hack will start loading once CS:GO is started." << std::endl;
std::cout << "\n" << "Loading csgo.exe";
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Mem::get_csgo, 0, 0, 0);
bool instant_csgo = true;
while (!Mem::csgo_found)
{
Sleep(250);
if (Mem::csgo_found)
{
break;
}
std::cout << ".";
instant_csgo = false;
}
if (instant_csgo) {
std::cout << "....";
}
std::cout << std::endl;
std::cout << "Loading client.dll";
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Mem::get_client_base_address, 0, 0, 0);
bool instant_client = true;
while (!Mem::client_dll_found)
{
Sleep(250);
if (Mem::client_dll_found)
{
break;
}
std::cout << ".";
instant_client = false;
}
if (instant_client) {
std::cout << "....";
}
std::cout << std::endl;
std::cout << "Loading engine.dll";
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Mem::get_engine_base_address, 0, 0, 0);
bool instant_engine = true;
while (!Mem::engine_dll_found)
{
Sleep(250);
if (Mem::engine_dll_found)
{
break;
}
std::cout << ".";
instant_engine = false;
}
if (instant_engine) {
std::cout << "....";
}
std::cout << std::endl;
std::cout << "\n" << "Scanning for offsets...";
get_sigs::start();
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)radar_thread, 0, 0, 0);// radar_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)aim_assist_thread, 0, 0, 0);// aim_assist_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)no_flash_thread, 0, 0, 0);// no_flash_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)bunnyhop_thread, 0, 0, 0);// bunnyhop_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)aimlock_thread, 0, 0, 0);// aimlock_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)glow_esp_thread, 0, 0, 0);// glow_esp_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)kill_message_thread, 0, 0, 0);// kill_message_thread
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)trigger_thread, 0, 0, 0);// trigger_thread
while (!cheat_thread_state::aim_assist_thread_status
|| !cheat_thread_state::aimlock_thread_status
|| !cheat_thread_state::no_flash_thread_status
|| !cheat_thread_state::glow_esp_thread_status
|| !cheat_thread_state::radar_thread_status
|| !cheat_thread_state::bunnyhop_thread_status
|| !cheat_thread_state::trigger_thread_status
|| !cheat_thread_state::kill_message_thread_status)
Sleep(100u);
update();
while (WaitForSingleObject(Mem::process_handle, 0)) {
wait_for_keys();
}
CloseHandle(Mem::process_handle);
exit(0);
}

3
Ezfrags/Ezfrags.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
int main();

179
Ezfrags/Ezfrags.vcxproj Normal file
View File

@@ -0,0 +1,179 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{a5502949-41d2-47bc-9ad3-0bdf34e83300}</ProjectGuid>
<RootNamespace>Ezfrags</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>Default</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="Ezfrags.cpp" />
<ClCompile Include="Get.cpp" />
<ClCompile Include="netvars.h" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="AimAssist.cpp" />
<ClInclude Include="AimAssist.h" />
<ClInclude Include="Aimlock.h" />
<ClInclude Include="Aimlock.cpp" />
<ClInclude Include="BunnyHop.cpp" />
<ClInclude Include="BunnyHop.h" />
<ClInclude Include="Ezfrags.h" />
<ClInclude Include="Get.h" />
<ClInclude Include="GlowESP.cpp" />
<ClInclude Include="GlowESP.h" />
<ClInclude Include="KillMessage.h" />
<ClInclude Include="KillMessage.cpp" />
<ClInclude Include="MemManager.h" />
<ClInclude Include="MemManager.cpp" />
<ClInclude Include="NoFlash.cpp" />
<ClInclude Include="NoFlash.h" />
<ClInclude Include="Radar.cpp" />
<ClInclude Include="Radar.h" />
<ClInclude Include="Settings.hpp" />
<ClInclude Include="ShowFeatures.cpp" />
<ClInclude Include="ShowFeatures.h" />
<ClInclude Include="Signatures.h" />
<ClInclude Include="Signatures.cpp" />
<ClInclude Include="Triggerbot.cpp" />
<ClInclude Include="Triggerbot.h" />
<ClInclude Include="WaitForKeys.h" />
<ClInclude Include="WaitForKeys.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

120
Ezfrags/Ezfrags.vcxproj.filters Normal file
View File

@@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Fichiers sources">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Fichiers d%27en-tête">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="Fichiers de ressources">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Memory">
<UniqueIdentifier>{22c8e2bf-5511-4a73-baf5-ff24109b3af1}</UniqueIdentifier>
</Filter>
<Filter Include="Hacks">
<UniqueIdentifier>{252e8f23-1acb-462d-b403-e33b980580de}</UniqueIdentifier>
</Filter>
<Filter Include="Console">
<UniqueIdentifier>{93ecdca2-1ebf-408b-b23c-89a0bdb5cbc1}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Ezfrags.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="netvars.h">
<Filter>Memory</Filter>
</ClCompile>
<ClCompile Include="Get.cpp">
<Filter>Memory</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="MemManager.cpp">
<Filter>Memory</Filter>
</ClInclude>
<ClInclude Include="Signatures.cpp">
<Filter>Memory</Filter>
</ClInclude>
<ClInclude Include="ShowFeatures.cpp">
<Filter>Console</Filter>
</ClInclude>
<ClInclude Include="Settings.hpp">
<Filter>Fichiers sources</Filter>
</ClInclude>
<ClInclude Include="WaitForKeys.cpp">
<Filter>Console</Filter>
</ClInclude>
<ClInclude Include="Radar.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="AimAssist.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="NoFlash.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="BunnyHop.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="Aimlock.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="GlowESP.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="KillMessage.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="Triggerbot.cpp">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="ShowFeatures.h">
<Filter>Console</Filter>
</ClInclude>
<ClInclude Include="WaitForKeys.h">
<Filter>Console</Filter>
</ClInclude>
<ClInclude Include="MemManager.h">
<Filter>Memory</Filter>
</ClInclude>
<ClInclude Include="Signatures.h">
<Filter>Memory</Filter>
</ClInclude>
<ClInclude Include="AimAssist.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="Aimlock.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="BunnyHop.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="GlowESP.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="KillMessage.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="NoFlash.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="Radar.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="Triggerbot.h">
<Filter>Hacks</Filter>
</ClInclude>
<ClInclude Include="Ezfrags.h">
<Filter>Fichiers sources</Filter>
</ClInclude>
<ClInclude Include="Get.h">
<Filter>Memory</Filter>
</ClInclude>
</ItemGroup>
</Project>

4
Ezfrags/Ezfrags.vcxproj.user Normal file
View File

@@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

9
Ezfrags/Get.cpp Normal file
View File

@@ -0,0 +1,9 @@
#include "MemManager.h"
#include "Signatures.h"
#include "Get.h"
namespace Get {
INT32 LocalPlayer() {
return Mem::RPM<INT32>(Mem::client + Signatures::dwLocalPlayer);
}
}

6
Ezfrags/Get.h Normal file
View File

@@ -0,0 +1,6 @@
#pragma once
#include <Windows.h>
namespace Get {
INT32 LocalPlayer();
}

6
Ezfrags/GlowESP.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "Settings.hpp"
#include "GlowESP.h"
void glow_esp_thread() {
cheat_thread_state::glow_esp_thread_status = 1;
}

3
Ezfrags/GlowESP.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void glow_esp_thread();

6
Ezfrags/KillMessage.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "Settings.hpp"
#include "KillMessage.h"
void kill_message_thread() {
cheat_thread_state::kill_message_thread_status = 1;
}

3
Ezfrags/KillMessage.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void kill_message_thread();

165
Ezfrags/MemManager.cpp Normal file
View File

@@ -0,0 +1,165 @@
#include <iostream>
#include <thread>
#include <Windows.h>
#include <TlHelp32.h>
#include "MemManager.h"
namespace Mem {
inline MODULEENTRY32 get_module(const char* modName, DWORD proc_id) {
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, proc_id);
if (hSnap != INVALID_HANDLE_VALUE) {
MODULEENTRY32 modEntry;
modEntry.dwSize = sizeof(modEntry);
if (Module32First(hSnap, &modEntry)) {
do {
if (!strcmp(modEntry.szModule, modName)) {
CloseHandle(hSnap);
return modEntry;
}
} while (Module32Next(hSnap, &modEntry));
}
}
MODULEENTRY32 module = { (DWORD)-1 };
return module;
}
inline void get_csgo() {
while (1) {
//Get a window handle to csgo
HWND hw_csgo = FindWindowA(NULL, "Counter-Strike: Global Offensive - Direct3D 9");
if (hw_csgo) {
csgo_found = true;
//Get csgo's process ID using the handle (No need to make some big function for procid like every other paster does)
GetWindowThreadProcessId(hw_csgo, &dw_process_id);
Mem::process_handle = OpenProcess(PROCESS_VM_READ | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, false, dw_process_id);
break;
}
}
}
inline void get_client_base_address() {
while (1) {
Mem::dw_client_address = get_module("client.dll", dw_process_id);
Mem::client_bytes = new uint8_t[Mem::dw_client_address.modBaseSize]; //making a variable size of the module
Mem::client = (uintptr_t)dw_client_address.modBaseAddr;
if (Mem::client_bytes) {
client_dll_found = true;
break;
}
DWORD bytes_read;
ReadProcessMemory(process_handle, Mem::dw_client_address.modBaseAddr, Mem::client_bytes, Mem::dw_client_address.modBaseSize, &bytes_read); //reading the module and storing as bytes_read
if (bytes_read != Mem::dw_client_address.modBaseSize) throw; //checking that the size of bytes read is = to size of bytes in the module
delete[] Mem::client_bytes;
}
}
inline void get_engine_base_address() {
while (1) {
MODULEENTRY32 dw_engine_address = get_module("engine.dll", dw_process_id);
engine_bytes = new uint8_t[dw_engine_address.modBaseSize]; //making a variable size of the module
Mem::engine = (uintptr_t)dw_engine_address.modBaseAddr;
if (engine_bytes) {
engine_dll_found = true;
break;
}
DWORD bytes_read;
ReadProcessMemory(process_handle, dw_engine_address.modBaseAddr, engine_bytes, dw_engine_address.modBaseSize, &bytes_read); //reading the module and storing as bytes_read
if (bytes_read != dw_engine_address.modBaseSize) throw; //checking that the size of bytes read is = to size of bytes in the module
delete[] Mem::engine_bytes;
}
}
//https://github.com/Made0x0000000a/nyfox/blob/main/csgoCheat/patternscan.cpp
DWORD FindAddress(const wchar_t* moduleName, const char* pattern, const char* mask, const int offset=0, const int extra=0) {
const MODULEENTRY32 moduleEntry = Mem::dw_client_address;
const HANDLE hProcess = Mem::process_handle;
// No Module Entry found
if (!moduleEntry.th32ModuleID) {
return NULL;
}
// Module base address = scan starting point
uintptr_t base = (uintptr_t)moduleEntry.modBaseAddr;
// Size of Module = scan end point
uintptr_t size = base + moduleEntry.modBaseSize;
uintptr_t curChunk = base;
SIZE_T bytesRead;
DWORD res;
int res_plus_offset = 0;
while (curChunk < size) {
// Area to scan
char buffer[4096];
// Change read protection, raed memory and change read protection back to the original
DWORD oProtect;
VirtualProtectEx(hProcess, (LPVOID)curChunk, sizeof(buffer), PAGE_EXECUTE_READWRITE, &oProtect);
ReadProcessMemory(hProcess, (LPVOID)curChunk, &buffer, sizeof(buffer), &bytesRead);
VirtualProtectEx(hProcess, (LPVOID)curChunk, sizeof(buffer), oProtect, &oProtect);
// No bytes read
if (bytesRead == 0) {
return NULL;
}
DWORD internalAddr = Mem::FindPattern((char*)&buffer, bytesRead, pattern, mask);
if (internalAddr != NULL) {
// Calculate real address
uintptr_t offsetFromBuffer = (uintptr_t)internalAddr - (uintptr_t)&buffer;
res = (DWORD)(curChunk + offsetFromBuffer);
res_plus_offset = Mem::RPM<int>(res + offset); //Adding the offset
return res_plus_offset - (DWORD)Mem::dw_client_address.modBaseAddr + extra; //adding the extra
}
else {
// Next chunk
curChunk += bytesRead;
}
}
return NULL;
}
// Find matching pattern
DWORD FindPattern(char* base, size_t size, const char* pattern, const char* mask) {
size_t patternLen = strlen(mask);
for (DWORD i = 0; i < size - patternLen; i++) {
bool found = true;
for (DWORD j = 0; j < patternLen; j++) {
if (mask[j] != '?' && pattern[j] != *(base + i + j)) {
found = false;
break;
}
}
if (found) {
return (DWORD)(base + i);
}
}
return NULL;
}
template<typename T> T RPM(SIZE_T address) {
T buffer;
ReadProcessMemory(process_handle, (LPCVOID)address, &buffer, sizeof(T), NULL);
return buffer;
}
template<typename T> void WPM(SIZE_T address, T buffer) {
WriteProcessMemory(process_handle, (LPVOID)address, &buffer, sizeof(buffer), NULL);
}
}

29
Ezfrags/MemManager.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include <iostream>
#include <thread>
#include <Windows.h>
#include <TlHelp32.h>
namespace Mem {
static bool csgo_found = false;
static bool client_dll_found = false;
static bool engine_dll_found = false;
static uintptr_t client;
static uintptr_t engine;
static DWORD dw_process_id;
static MODULEENTRY32 dw_client_address;
static MODULEENTRY32 dw_engine_address;
static HANDLE process_handle;
static uint8_t* client_bytes;
static uint8_t* engine_bytes;
inline MODULEENTRY32 get_module(const char* modName, DWORD proc_id);
inline void get_csgo();
inline void get_client_base_address();
inline void get_engine_base_address();
DWORD FindAddress(const wchar_t* moduleName, const char* pattern, const char* mask, const int offset, const int extra);
DWORD FindPattern(char* base, size_t size, const char* pattern, const char* mask);
template<typename T> T RPM(SIZE_T address);
template<typename T> void WPM(SIZE_T address, T buffer);
}

49
Ezfrags/NoFlash.cpp Normal file
View File

@@ -0,0 +1,49 @@
#include "Settings.hpp"
#include "MemManager.h"
#include "Signatures.h"
#include "Get.h"
#include "NoFlash.h"
//This function has been 100% decompiled !
//Not actually, still remains :
/*
while ( !csgo_module || !client_module_found || !byte_4FBF0C )
Sleep(5u);
*/
//But i simplified it here
//No idea what byte_4FBF0C is, seems used in the GetEngine function of Ezfrags, it's yet to be decompiled
void no_flash_thread() {
cheat_thread_state::no_flash_thread_status = 1;
while (1)
{
while (!Mem::csgo_found || !Mem::client_dll_found)
Sleep(5u);
if (settings::no_flash_bool)
{
/*
if (ReadProcessMemory_0((char*)player + m_flFlashMaxAlpha) > 0.0)// If flash value is > 0
WriteProcessMemory_0((char*)player + m_flFlashMaxAlpha, (float)0.0);// We put anti flash
*/
if (Mem::RPM<float>(Get::LocalPlayer() + Netvars::m_flFlashMaxAlpha) > 0.0f)
Mem::WPM<float>(Get::LocalPlayer() + Netvars::m_flFlashMaxAlpha, 0.0f);
}
/*
else if (0.0 == ReadProcessMemory_0((char*)player + m_flFlashMaxAlpha))// We need to reset the flash value to 255
{
WriteProcessMemory_0((char*)player + m_flFlashMaxAlpha, (float)255.0);// Yop
}
*/
else if (Mem::RPM<float>(Get::LocalPlayer() + Netvars::m_flFlashMaxAlpha) == 0.0f) {
Mem::WPM<float>(Get::LocalPlayer() + Netvars::m_flFlashMaxAlpha, 255.0f);
}
//std::cout << Mem::RPM<float>(Signatures::dwLocalPlayer + Netvars::m_flFlashMaxAlpha) << std::endl;
//Sleep(300);
Sleep(1u);
}
}

3
Ezfrags/NoFlash.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void no_flash_thread();

6
Ezfrags/Radar.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "Settings.hpp"
#include "Radar.h"
void radar_thread() {
cheat_thread_state::radar_thread_status = 1;
}

3
Ezfrags/Radar.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void radar_thread();

28
Ezfrags/Settings.hpp Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
namespace settings {
bool glow_esp_bool = 1;
int trigger_mode_switch_1 = 0;
int trigger_mode_switch_2 = 0;
int trigger_delay = 30;
bool aimlock_bool = 1;
int aimlock_bone = 6; //8 : chest, 6 : head
bool radar_bool = 1;
bool aim_assist_bool = 1;
int aim_assist_bone = 6; //8 : chest, 6 : head
float aim_fov = 25.0;
bool bunnyhop_bool = 1;
bool kill_message_bool = 1;
bool no_flash_bool = 1;
};
namespace cheat_thread_state {
bool aim_assist_thread_status = 0;
bool aimlock_thread_status = 0;
bool no_flash_thread_status = 0;
bool glow_esp_thread_status = 0;
bool radar_thread_status = 0;
bool bunnyhop_thread_status = 0;
bool trigger_thread_status = 0;
bool kill_message_thread_status = 0;
}

65
Ezfrags/ShowFeatures.cpp Normal file
View File

@@ -0,0 +1,65 @@
#include <iostream>
#include <Windows.h>
#include "ShowFeatures.h"
#include "Settings.hpp"
time_t Time;
void update() {
system("cls");
std::cout << "EZfrags CS:GO multihack v9.65 public [www.EZfrags.co.uk]" << "\n";
time(&Time);
if (Time - 1591304279 > 864000) // If our version is older than 10 days
{
std::cout << '\n' << "!!! WARNING !!!: This version is more than 10 days old.";
std::cout << '\n' << "You should go and download a new build from www.EZfrags.co.uk" << std::endl;
}
std::cout << '\n' << "The hack has been loaded. Have fun!" << std::endl;
std::cout << "\n" << "TRIGGERBOT ";
if (settings::trigger_mode_switch_2 && settings::trigger_mode_switch_1 != 1)
{
std::cout << "AUTO";
}
else if (settings::trigger_mode_switch_2 != 1 && settings::trigger_mode_switch_1)
{
std::cout << "HOLD";
}
else if (settings::trigger_mode_switch_2 != 1 && settings::trigger_mode_switch_1 != 1)
{
std::cout << "OFF";
}
std::cout << " @ " << settings::trigger_delay << " MS";
std::cout << std::endl;
std::cout << "AIM ASSIST " << settings::aim_assist_bool << " @ ";
if (settings::aim_assist_bone == 8) {
std::cout << "CHEST" << std::endl;
}
else {
std::cout << "HEAD" << std::endl;
}
std::cout << "AIMLOCK " << settings::aimlock_bool << " @ ";
if (settings::aimlock_bone == 8) {
std::cout << "CHEST" << std::endl;
}
else {
std::cout << "HEAD" << std::endl;
}
std::cout << "GLOW ESP " << settings::glow_esp_bool << std::endl;
std::cout << "RADAR HACK " << settings::radar_bool << std::endl;
std::cout << "NO FLASH HACK " << settings::no_flash_bool << std::endl;
std::cout << "BUNNY HOP " << settings::bunnyhop_bool << std::endl;
std::cout << "KILL MESSAGE " << settings::kill_message_bool;
}

3
Ezfrags/ShowFeatures.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void update();

24
Ezfrags/Signatures.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include "MemManager.h"
#include "netvars.h"
#include "Signatures.h"
#include <stdio.h>
#include <iostream>
namespace get_sigs {
//https://github.com/HeathHowren/Pattern-Scanning/blob/master/patternscanexternal/Source.cpp
void start() {
//Netvars
DWORD dwGetAllClasses = Mem::FindAddress(L"client.dll", "\xA1\x00\x00\x00\x00\xC3\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xA1\x00\x00\x00\x00\xB9","x????xxxxxxxxxxxx????x", 1, 0) + (uintptr_t)Mem::dw_client_address.modBaseAddr;
DWORD dwGetAllClasses_deref = Mem::RPM<DWORD>(dwGetAllClasses);
DWORD dwGetAllClasses_offset = dwGetAllClasses_deref - (uintptr_t)Mem::dw_client_address.modBaseAddr;
std::unique_ptr<NetvarsClass> NetvarManager(new NetvarsClass((uintptr_t)Mem::dw_client_address.modBaseAddr + dwGetAllClasses_offset));
Netvars::m_fFlags = NetvarManager->NETVAR("DT_CSPlayer", "m_fFlags");
Netvars::m_flFlashMaxAlpha = NetvarManager->NETVAR("DT_CSPlayer", "m_flFlashMaxAlpha");
//Signatures
Signatures::dwLocalPlayer = Mem::FindAddress(L"client.dll", "\x8D\x34\x85\x00\x00\x00\x00\x89\x15\x00\x00\x00\x00\x8B\x41\x08\x8B\x48\x04\x83\xF9\xFF", "xxx????xx????xxxxxxxxx", 3, 4);
Signatures::dwForceJump = Mem::FindAddress(L"client.dll", "\x8B\x0D\x00\x00\x00\x00\x8B\xD6\x8B\xC1\x83\xCA\x02", "xx????xxxxxxx", 2, 0);
}
}

16
Ezfrags/Signatures.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
#include <stdio.h>
namespace get_sigs {
void start();
}
namespace Signatures {
static DWORD dwForceJump;
static DWORD dwLocalPlayer;
}
namespace Netvars {
static int m_fFlags;
static int m_flFlashMaxAlpha;
}

6
Ezfrags/Triggerbot.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "Settings.hpp"
#include "Triggerbot.h"
void trigger_thread() {
cheat_thread_state::trigger_thread_status = 1;
}

3
Ezfrags/Triggerbot.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void trigger_thread();

135
Ezfrags/WaitForKeys.cpp Normal file
View File

@@ -0,0 +1,135 @@
#include <iostream>
#include <Windows.h>
#include "WaitForKeys.h"
#include "ShowFeatures.h"
#include "Settings.hpp"
void wait_for_keys()
{
if (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(117) < 0)//
// F6 - cycle through triggerbot modes (autofire, hold key, disabled - default)
// SHIFT+F6 - cycle through triggerbot delays (10, 30 - default, 50, 80, 110, 140)
{
while (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(117) < 0)
Sleep(75u);
if (settings::trigger_mode_switch_2 && settings::trigger_mode_switch_1 != 1)// mode switching (f6)
{
settings::trigger_mode_switch_2 = 0;
settings::trigger_mode_switch_1 = 1;
}
else if (settings::trigger_mode_switch_2 != 1 && settings::trigger_mode_switch_1)
{
settings::trigger_mode_switch_2 = 0;
settings::trigger_mode_switch_1 = 0;
}
else if (settings::trigger_mode_switch_2 != 1 && settings::trigger_mode_switch_1 != 1)
{
settings::trigger_mode_switch_2 = 1;
settings::trigger_mode_switch_1 = 0;
}
update();
}
if (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(117) < 0)
{
while (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(117) < 0)
Sleep(75u);
if (settings::trigger_delay == 140) // Delay switching (shift + f6)
{
settings::trigger_delay = 10;
}
else if (settings::trigger_delay == 10 || settings::trigger_delay == 30)
{
settings::trigger_delay += 20;
}
else
{
settings::trigger_delay += 30;
}
update();
}
if (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(118) < 0)//
// F7 - toggle aim assist
// SHIFT+F7 - toggle aim assist mode (rage/legit)
{
while (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(118) < 0)
Sleep(75u);
settings::aim_assist_bool = settings::aim_assist_bool == 0;
update();
}
if (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(118) < 0)
{
while (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(118) < 0)
Sleep(75u);
if (settings::aim_assist_bone == 8) // mode switching (shift + f7)
{
settings::aim_assist_bone = 6; // switching between bones, head and chest
settings::aim_fov = 25.0; // switching between 25.0 and 100.0 fov
}
else
{
settings::aim_assist_bone = 8;
settings::aim_fov = 100.0;
}
update();
}
if (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(119) < 0)//
// F8 - toggle aimlock 119
// SHIFT+F8 - toggle aimlock target (head/chest)
{
while (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(119) < 0)
Sleep(75u);
settings::aimlock_bool = settings::aimlock_bool == 0;
update();
}
if (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(119) < 0)
{
while (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(119) < 0)
Sleep(75u);
if (settings::aimlock_bone == 8) // switching between bones, head and chest
settings::aimlock_bone = 6;
else
settings::aimlock_bone = 8;
update();
}
if (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(120) < 0)//
// F9 - toggle GlowESP 120
// SHIFT+F9 - toggle radar hack
{
while (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(120) < 0)
Sleep(75u);
settings::glow_esp_bool = settings::glow_esp_bool == 0;
update();
}
if (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(120) < 0)
{
while (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(120) < 0)
Sleep(75u);
settings::radar_bool = settings::radar_bool == 0;
update();
}
if (GetAsyncKeyState(121) < 0) //
// F10 - toggle no flash hack
{
while (GetAsyncKeyState(121) < 0)
Sleep(75u);
settings::no_flash_bool = settings::no_flash_bool == 0;
update();
}
if (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(122) < 0)//
// F11 - toggle bunny hop 122
// SHIFT+F11 - toggle kill message
{
while (GetAsyncKeyState(16) >= 0 && GetAsyncKeyState(122) < 0)
Sleep(75u);
settings::bunnyhop_bool = settings::bunnyhop_bool == 0;
update();
}
if (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(122) < 0)
{
while (GetAsyncKeyState(16) < 0 && GetAsyncKeyState(122) < 0)
Sleep(75u);
settings::kill_message_bool = settings::kill_message_bool == 0;
update();
}
Sleep(25u);
}

3
Ezfrags/WaitForKeys.h Normal file
View File

@@ -0,0 +1,3 @@
#pragma once
void wait_for_keys();

72
Ezfrags/netvars.h Normal file
View File

@@ -0,0 +1,72 @@
#pragma once
#include <Windows.h>
#include <iostream>
#include <string>
#include "MemManager.h"
class NetvarsClass {
private:
class RecvTable {
public:
std::string GetTableName() {
DWORD offset = Mem::RPM<DWORD>((DWORD)this + 0xC);
char tableName[128];
ReadProcessMemory(Mem::process_handle, (LPCVOID)offset, &tableName, sizeof(tableName), 0);
return std::string(tableName);
}
void* GetProperty(int i) { // RecvProp*
return (void*)(Mem::RPM<DWORD>((DWORD)this) + 0x3C * i);
}
int GetMaxProp() {
return Mem::RPM<int>((DWORD)this + 0x4);
}
};
class ClientClass {
public:
void* GetTable() { // RecvTable*
return Mem::RPM<void*>((DWORD)this + 0xC);
}
void* GetNextClass() { // ClientClass*
return Mem::RPM<void*>((DWORD)this + 0x10);
}
};
class RecvProp {
public:
std::string GetVarName() {
DWORD offset = Mem::RPM<DWORD>((DWORD)this);
char vName[128];
ReadProcessMemory(Mem::process_handle, (LPCVOID)offset, &vName, sizeof(vName), 0);
return std::string(vName);
}
int GetOffset() {
return Mem::RPM<int>((DWORD)this + 0x2C);
}
void* GetDataTable() { // RecvTable*
return Mem::RPM<void*>((DWORD)this + 0x28);
}
};
DWORD CheckProps(RecvTable* DataTable, std::string NetVarName) {
for (int i = 0; i < DataTable->GetMaxProp(); i++) {
auto pRecvProp = reinterpret_cast<RecvProp*>(DataTable->GetProperty(i));
auto VarName = pRecvProp->GetVarName();
if (isdigit(VarName[0])) continue;
if (NetVarName.compare(VarName) == 0) return pRecvProp->GetOffset();
if (auto DataTable2 = reinterpret_cast<RecvTable*>(pRecvProp->GetDataTable()))
if (auto Offset = CheckProps(DataTable2, NetVarName)) return Offset;
}
return NULL;
}
DWORD dwGetAllClasses;
public:
NetvarsClass(DWORD Base) : dwGetAllClasses(Base) {}
DWORD NETVAR(std::string ClassName, std::string NetVarName) {
if (auto pClass = reinterpret_cast<ClientClass*>(dwGetAllClasses))
for (; pClass != NULL; pClass = reinterpret_cast<ClientClass*>(pClass->GetNextClass()))
if (auto Table = reinterpret_cast<RecvTable*>(pClass->GetTable()))
if (Table->GetTableName().compare(ClassName) == 0)
if (auto Offset = CheckProps(Table, NetVarName)) return Offset;
return NULL;
}
};