Simple BHOP External

[Hacker Fail]

Hi guys, I will share a simple method to do Bunny Hop externally for CSGO
The address and offsets are updated !

memw.h

#include <Windows.h>
#include <TlHelp32.h>
#include <iostream>

class CHackProcess
{
public:
 
	PROCESSENTRY32 __gameProcess;
	HANDLE __HandleProcess;
	HWND __HWNDCss; 
	DWORD __dwordClient;
	DWORD __dwordEngine;
	DWORD __dwordOverlay;
	DWORD __dwordVGui;
	DWORD __dwordLibCef;
	DWORD __dwordSteam; 
	DWORD 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 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 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 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);
}
};

main.cpp

#include "memw.h"

using namespace std;

CHackProcess fProcess; 

// Address CSGO

#define LocalPlayer          0x00A31504
#define dwForceJump          0x04EE1EF0

// OffSets

#define m_Flags              0x100

class cLocalPlayer
{
public:

	int Local, pFlags;

	void Read(HANDLE hProc, DWORD dwClient)
	{
		ReadProcessMemory(hProc, (LPVOID)(dwClient + LocalPlayer), &Local, sizeof(DWORD), 0);
		ReadProcessMemory(hProc, (LPVOID)(Local + m_Flags), &pFlags, sizeof(int), 0);
	}
};

int main()
{
	int valueon = 5;
	int valueoff = 4;

	HANDLE hProc;

	HWND hWND = FindWindow(0,"Counter-Strike: Global Offensive");

	if(hWND == 0)
	{
		cout << "Cannot found the window !\n\n" << endl;
	} else {
		cout << "We found the window !";

		DWORD pId;
		GetWindowThreadProcessId(hWND, &pId);
		hProc = OpenProcess(PROCESS_ALL_ACCESS, false, pId);

		DWORD dwClient = fProcess.GetModuleNamePointer("client.dll", pId);

		cLocalPlayer *pLocal = new cLocalPlayer();
		pLocal->Read(hProc, dwClient);

		if(!hProc)
		{
			cout << "\n\nFail to get the process.";
		} else {

			cout << "\n\nWe got the process, now we will read and modify.\n\n";

			for(;;)
			{
				if(GetAsyncKeyState(0x20) && pLocal->pFlags == 257)
				{
					WriteProcessMemory(hProc, (LPVOID)(dwClient + dwForceJump), &valueon, sizeof(valueon), 0);
				} else {
					WriteProcessMemory(hProc, (LPVOID)(dwClient + dwForceJump), &valueoff, sizeof(valueoff), 0);
				}
			}

			CloseHandle(hProc);
		}
	}

	system("pause");

	return 0;
}

Credits to Fleep, Y3t1y3t, gtaplayer2 ( I learned a lot things reading your bases! ) and me