CS:GO Base v3

 
#include <Macosx>
#include <iostream>
#include <stdio.h>
#include <TlHelp32.h>
using std::cout;
using std::cin;
#include <limits>
using std::numeric_limits;
using std::streamsize;
using namespace std;
#include <cstdlib>
 
 
 
 
 
HANDLE hProcess;
 
DWORD GetModuleBase(const DWORD dwProcessId, const char *szModuleName);
 
 
 
void WriteProcessMemory()
{
 
    DWORD pID;
    HANDLE hHandle;
    HWND hWindow;
    SetConsoleTitle( "SpaceHack by Sandaasu" );//titeltext
 
    hWindow = FindWindow(0, "Counter-Strike: Global Offensive");//finde Fenster mit diesem namen
    GetWindowThreadProcessId( hWindow, &pID);//get PID
    hHandle = OpenProcess( PROCESS_ALL_ACCESS, 0, pID);
    if(hWindow == 0)
    {
 
    system("color 80");//color
cout << "\t\t\t +++++++++++++++++++++++++++++++++" << endl;
cout << "\t\t\t ++++++###+++++++++++++##+++##++++" << endl;
cout << "\t\t\t +++++###++++++++++++++##+++##++++" << endl;
cout << "\t\t\t ++++###+++++++++++++++##+++##++++" << endl;
cout << "\t\t\t ++###+++++++++++++++++#######++++" << endl;
cout << "\t\t\t ++###+++++++++####++++#######++++" << endl;
cout << "\t\t\t +++++###++++++++++++++##+++##++++" << endl;
cout << "\t\t\t +++###++++++++++++++++##+++##++++" << endl;
cout << "\t\t\t ++###+++++++++++++++++##+++##++++" << endl;
cout << "\t\t\t +++++++++++++++++++++++++++++++++" << endl;
cout << "\t\t\t +++++ SpaceHack by Sandaasu  ++++" << endl;
cout << "\t\t\t +++++++++++++++++++++++++++++++++" << "\n " << endl;
        cout << "Cannot find game.. Closing now.." << endl;
        Sleep(3000);
        exit(1);
    }
 
}
void appTitle()
{
 
    WriteProcessMemory();
}
 
void Features()
{
 
    system("color 80");//color
 
 
    cout << "\t\t\t +++++++++++++++++++++++++++++++++" << endl;
    cout << "\t\t\t ++++++###+++++++++++++##+++##++++" << endl;
    cout << "\t\t\t +++++###++++++++++++++##+++##++++" << endl;
    cout << "\t\t\t ++++###+++++++++++++++##+++##++++" << endl;
    cout << "\t\t\t ++###+++++++++++++++++#######++++" << endl;
    cout << "\t\t\t ++###+++++++++####++++#######++++" << endl;
    cout << "\t\t\t +++++###++++++++++++++##+++##++++" << endl;
    cout << "\t\t\t +++###++++++++++++++++##+++##++++" << endl;
    cout << "\t\t\t ++###+++++++++++++++++##+++##++++" << endl;
    cout << "\t\t\t +++++++++++++++++++++++++++++++++" << "\n " << endl;
    cout << "Created by : Sandaasu" << endl;                    
    cout << "Version : 3.2 Beta" << endl;                    
    Sleep(5000);
    system("cls");
 
    cout << "========================================"  << endl;
 
    cout << "[ HOTKEYS ]" << endl << endl;                    
    cout << "\t    NumPad1 = SV bypass Activate" << endl;
    cout << "\t    NumPad2 = Wallhack ON" << endl;
    cout << "\t    NumPad3 = Wallhack OFF" << endl;
    cout << "\t    NumPad4 = ESP ON " << endl;
    cout << "\t    NumPad5 = ESP OFF" << endl;
    cout << "\t    NumPad6 = FPS Active" << endl;
    cout << "\t    NumPad7 = Glasswalls Active" << endl;
    cout << "\t    NumPad8 = Remove Smoke" << endl;
    cout << "\t    F1 = PANIC Key" << endl;
    cout << "========================================"  << endl;
    cout << "\tEsc: Close" << endl << endl << endl;
}
 
 
void appHotkeys()
{
 
 
    WriteProcessMemory();
 
    DWORD pID;
    HANDLE hHandle;
    HWND hWnd;
    SetConsoleTitle( "Space Hack by Sandaasu" );//titeltext
    hWnd = FindWindow(0, "Counter-Strike: Global Offensive");//finde Fenster mit diesem namen
    GetWindowThreadProcessId( hWnd, &pID);//get PID
    hHandle = OpenProcess( PROCESS_ALL_ACCESS, 0, pID);
 
 
 
 
    while(true)
    {
        if(GetAsyncKeyState(VK_ESCAPE))
        {
            /*cout << "Bai Bai :) <3" << endl;
            Sleep(5000);
            exit(1);
            */
        }
 
 
 
        if(GetAsyncKeyState(VK_NUMPAD1))
        {//SV_bypass
            DWORD EngineDll;
            EngineDll = GetModuleBase( pID, "engine.dll");
            int bypass_value = 1;
            /////////////////////////////
            int offset = 0x6F8940;
            /////////////////////////////
            DWORD ibypass_value = sizeof(bypass_value);
            WriteProcessMemory( hHandle, (LPVOID)( EngineDll + offset), &bypass_value, ibypass_value, 0);
            cout << "sv bypass activated. " << endl;
 
        }
 
 
        if(GetAsyncKeyState(VK_NUMPAD2))
        {// WH ON
 
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            int wh_value = 1;
            /////////////////////////////client.dll+8D0348
            int offset = 0x8D0348;
            /////////////////////////////
            DWORD iwh_value = sizeof(wh_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + offset), &wh_value, iwh_value, 0);
            cout << "Wallhack ON . " << endl;
 
        }
        if(GetAsyncKeyState(VK_NUMPAD3))
        {//WH OFF
 
 
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            int wh_value = 0;
            /////////////////////////////
            int offset = 0x8D0348;
            /////////////////////////////
            DWORD iwh_value = sizeof(wh_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + offset), &wh_value, iwh_value, 0);//8D0610
            cout << "Wallhack OFF. " << endl;
 
 
        }
 
        if(GetAsyncKeyState(VK_NUMPAD4))
        {//ESP ON
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            int esp_value = 1;
            /////////////////////////////
            int offset = 0x8D37B0;
            /////////////////////////////
            DWORD iesp_value = sizeof(esp_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + offset), &esp_value, iesp_value, 0);
            cout << "ESP ON. " << endl;
 
 
        }
        if(GetAsyncKeyState(VK_NUMPAD5))
        {//ESP OFF
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            int esp_value = 0;
            /////////////////////////////
            int offset = 0x8D37B0;
            /////////////////////////////
            DWORD iesp_value = sizeof(esp_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + offset), &esp_value, iesp_value, 0);
            cout << "ESP OFF. " << endl;
 
 
        }
        if(GetAsyncKeyState(VK_NUMPAD6))
        {//FPS ON
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            int fps_value = 2;
            /////////////////////////////
            int offset = 0x933EC8;
            /////////////////////////////
            DWORD ifps_value = sizeof(fps_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + offset), &fps_value, ifps_value, 0);
            cout << "FPS Active. " << endl;
 
        }
        if(GetAsyncKeyState(VK_NUMPAD7))
        {//Glasswalls
            DWORD materialsystemDll;
            materialsystemDll = GetModuleBase( pID, "materialsystem.dll");
            int walls_value = 2;
            /////////////////////////////
            int offset = 0x33A408;
            /////////////////////////////
            DWORD iwalls_value = sizeof(walls_value);
            WriteProcessMemory( hHandle, (LPVOID)( materialsystemDll + offset), &walls_value, iwalls_value, 0);
            Sleep(3000);
            int walls2_value = 1;
            DWORD iwalls2_value = sizeof(walls2_value);
            WriteProcessMemory( hHandle, (LPVOID)( materialsystemDll + offset), &walls2_value, iwalls2_value, 0);
            cout << "Glasswalls Active. " << endl;
        }
 
        if(GetAsyncKeyState(VK_NUMPAD8))
        {//NoSmoke
 
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            int smoke_value = 0;
            /////////////////////////////
            int offset = 0x92E5B8;
            /////////////////////////////
            DWORD ismoke_value = sizeof(smoke_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + offset), &smoke_value, ismoke_value, 0);
            cout << "No Smoke Active. " << endl;
 
 
        }
        if(GetAsyncKeyState(VK_F1))
        {//PANIC
 
 
 
 
            DWORD EngineDll;
            EngineDll = GetModuleBase( pID, "engine.dll");
            DWORD ClientDll;
            ClientDll = GetModuleBase( pID, "client.dll");
            DWORD materialsystemDll;
            materialsystemDll = GetModuleBase( pID, "materialsystem.dll");
            //////
            int smoke_value = 1;
            DWORD ismoke_value = sizeof(smoke_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x92E5B8), &smoke_value, ismoke_value, 0);
            int walls_value = 0;
            DWORD iwalls_value = sizeof(walls_value);
            WriteProcessMemory( hHandle, (LPVOID)( materialsystemDll + 0x33A408), &walls_value, iwalls_value, 0);
            int fps_value = 0;
            DWORD ifps_value = sizeof(fps_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x933EC8), &fps_value, ifps_value, 0);
            int esp_value = 0;
            DWORD iesp_value = sizeof(esp_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x8D37B0), &esp_value, iesp_value, 0);
            int wh_value = 1;
            DWORD iwh_value = sizeof(wh_value);
            WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x8D0348), &wh_value, iwh_value, 0);
            int bypass_value = 1;
            DWORD ibypass_value = sizeof(bypass_value);
            WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x6F8940), &bypass_value, ibypass_value, 0);
            //system("exit");
 
        }
 
    }
}
 
 
 
 
 
int main()
{    
    appTitle();
    appFeatures();
    appHotkeys();
}
 
DWORD GetModuleBase(const DWORD dwProcessId, const char *szModuleName)
{
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessId);
    if (!hSnap)
    {
        return 0;
    }
    MODULEENTRY32 me
    me.dwSize = sizeof(MODULEENTRY32);
    DWORD dwReturn = 0
    if (Module32First(hSnap, &me)
    {
        while (Module32Next(hSnap, &me)
        {
            if (lstrcmpi(me.szModule, szModuleName) == 0)
            {
                dwReturn = (DWORD)me.modBaseAddr;
                break;
            }
        }
    }
    CloseHandle(hSnap);
    return dwReturn;
}