Starting to hack (For dumbos)
I'm tired of the "how to hack game man" threads so I'm making this simple, easy-comprehendo guide.
I will be doing this in Counter-Strike: Source. If you don't have the game, pirate it. This will apply to CS:GO, you'll just have to change stuff. If you need a auditory explanation, you can add my skype. I'm always happy to help. [SPOILER]Sighmaniac[/SPOILER]
TOOLS REQUIRED:
- Visual Studio (Latest version; whatever's free)
- Cheat Engine
- OllyDbg (Not fully required, but useful)
- An indepth knawledge of the language (C++ used in this tutorial)
- Know how to paraphrase code; C+P makes you dead to me
- An understanding of the hack you want to make
In this tutorial, it'll be a BHOP since that's the easiest by far.
Step 1: The playerbase
The address in memory of your player. If you know this, you can find other addresses. In our case, we will need an address that holds whether or not the player is touching the ground. Every game is different, so you may have to research what values this could be in different games. For the counter-strike series, touching the ground is 257; air is 256. Once you know this information for your game, you can begin finding the base.
Step 2: Addresses of your game
Open your game of choice, and start an offline match that will give you infinite time. In CS, please launch your game in -insecure in the launch options to prevent a VAC while you have CE open. Once you are in, launch Cheat Engine and attach it to the game. Start with finding your health address, searching for 100, taking damage, search for new health. Repeat until you find your health. If after a while you only have ~5 addresses left that won't narrow, find out an offset that is very close in memory to the health. In terms of CS:S, the team offset is 8 bytes away. Start ctrl+b'ing your addresses, and if you see your team number 8 bytes from your health, then you have the right address. It WILL be different in other games, so be wary. CS:GO's team offset is behind the health. After finding your health, right click and do a pointer scan with max level 1. A few things pop up, but put in all of the ones with the same number at the left. In terms of CS:S, the first one is your player, the second is the entity list. Another way to verify it is clicking on the address of your player base, copying the part that will be like "something.exe/dll + 8A6658C", and then adding it as a pointer with the offset as the number you saw in the pointer scan a lot. For those following in CS:S, that number should be 0x94, the health offset. You know have your player base. Now, just search for the "in air" variable. CS:S is 257 on ground, 256 in air. Don't crouch while searching; crouching changes the variable. Another way to do it is to disect the memory of your playerbase, and then try jumping and seeing what values change as you are in air and then touch the ground. This is easier if you don't know what value it is for your game. Once you find it through searching, subtract the address of your player from the in air variable. This will be the offset. CS:S will be 0x350. Now you have your player and the offsets. The health isn't necessary for the tutorial.
Part 3: Modules
You will now need to know what part of the game your hack must have access to. In our case, it should just be that "something.exe/dll" from our player, or in CS:S, the client.dll. Everybody has different methods of attaching to modules. For my sake, I'm not pasting my code in. So, just work on writing the backend work of attaching to client.dll. You can use ollydbg to find out what other modules your game includes.
Part 4: Writing the code
Now, I could be good and actually include a pattern scanner, but since CS:S is hardly updated you won't need it. Big games like CS:GO will have to need pattern scanning because the offsets update all the time. Anyway, begin by writing your DWORD's and defining your toggle keys. Here, you will need two DWORD variables: Player_Base, which equals the 0x8A6658C from earlier, and dw_jumpOffset, which equals 0x350 in our case. Next, just make your function for Bunnyhopping and your main function, and also your Player's struct. In your struct, add a function that reads the game's memory to find the playerbase (client + 0x8A6658C), and then the jump offset (client + 0x8A6658C + 0x350). In BunnyHop(), do while(GetAsyncKeyState(0x20)) and then write your code. Basically, if jump offset == 257, send a global space press. Else, return. In the main function, you need to call the function that checks if the game is open. Then, while (!GetAsyncKeyState(whatever key you want to close the app)), you call the function to read the player's info, then check if you press your BHOP toggle key, which if you do you change the state of your bhop bool, and then call BunnyHop();. As you add more functions, I recommend adding them to a thread so they can be run at one time.
Part 5: Tidying and adding your own functions
If you want to implement this in another game, just comment all the code so you know, "what the fuck does this code do." You can add whatever you want as long as you know what you're doing. If you stray from copying other people's source code, you'll soon have a nice private hack that won't be detected as long as you're smart with it. In standing, this code at it's core will be detected.
I'm sorry this doesn't have the exact specifics of every game, but if you use a little common sense and google, you can transform the code. If you ever see someone asking "HOW DO I HACKK???" please link them this article. And also this link:
https://lmgtfy.com/?q=how+to+hackk+game%3F%3F
