csh/main.py

from json import loads
from time import sleep

from pymem import Pymem
from requests import get
from win32api import GetAsyncKeyState


class Hack():
    def __init__(self) -> None:
        # Loading offsets
        self.offsets = self._find_offsets()

        self.pm = self._find_process(True)

    def _find_offsets(self) -> dict[str, int]:
        hazedumper_data = get(
            "https://raw.githubusercontent.com/frk1/hazedumper/master/csgo.min.json")
        serial_data = loads(hazedumper_data.text)
        return serial_data["signatures"] | serial_data["netvars"]

    def _find_process(self, verbose: bool = False) -> Pymem:
        """Find game process"""
        process_found = False
        print("Looking for process...") if verbose else None

        pm = None
        while not process_found:
            try:
                pm = Pymem("csgo.exe")
            except:
                # Timeout
                sleep(.5)
            else:
                print("Process found!") if verbose else None
                process_found = True

        if pm:
            return pm
        exit(1)

    def find_module(self, module: str):
        found = None
        for internal_module in list(self.pm.list_modules()):
            if internal_module.name == module + ".dll":
                found = internal_module.lpBaseOfDll

        if found:
            return found
        else:
            raise MemoryError


class Cheat(Hack):
    def __init__(self) -> None:
        super().__init__()

        self.wait_time = 0.01
        self.timeout = self.wait_time * 50

        self.cheats_list = [func for func in dir(self)
                            # Function
                            if callable(getattr(self, func))
                            # User defined
                            if not func.startswith("_")
                            # Utils
                            if not func.startswith("find_")]

    def find_local_player(self, client) -> int:
        local_player = None
        while not local_player:
            local_player = self.pm.read_uint(
                client + self.offsets["dwLocalPlayer"])
            sleep(self.timeout)

        return local_player

    def bhop(self) -> None:
        # Aliases
        mem = self.pm
        offset = self.offsets

        # Get module address
        client = self.find_module("client")

        # Get local player
        local_player = self.find_local_player(client)

        # Hack loop
        while True:
            # Reduce CPU usage
            sleep(self.wait_time)

            # Space bar detection
            if not GetAsyncKeyState(ord(" ")):
                continue

            # Check if player is alive
            if not mem.read_int(local_player + offset["m_iHealth"]):
                continue

            # Check if player on ground
            if mem.read_uint(local_player + offset["m_fFlags"]) & (1 << 0):
                mem.write_uint(client + offset["dwForceJump"], 5)
                sleep(0.01)  # maybe reduce ban rate?
                mem.write_uint(client + offset["dwForceJump"], 4)


if __name__ == "__main__":
    # Cheat
    c = Cheat()

    # Cheat list
    print("Enter 0 to exit.")
    print("Available cheats:")
    for idx, cheat in enumerate(c.cheats_list):
        print(f"#{idx + 1} - {cheat}")

    # Select cheat
    c_id = None
    while c_id == None:
        try:
            match int(input("Enter ID: #")):
                case 0:
                    exit(0)
                case i if i > len(c.cheats_list):
                    raise IndexError
                case _ as i:
                    c_id = i - 1
        except:
            print("Invalid ID.")
            pass

    # Run cheat
    getattr(c, c.cheats_list[c_id])()