This repository has been archived on 2023-09-02. You can view files and clone it, but cannot push or open issues or pull requests.
csh/main.py
2023-03-30 23:01:18 +02:00

424 lines
13 KiB
Python

from json import loads
from threading import Thread
from time import sleep
from pymem import Pymem
from requests import get
from win32api import GetAsyncKeyState
from win32con import EM_LINEINDEX, VK_SPACE
class Hack():
def __init__(self) -> None:
# Loading offsets
self.offsets = self._find_offsets()
self.pm = self._find_process(True)
self.wait_time = 0.01
self.timeout = self.wait_time * 50
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"] | {
"entity_size": 0x10,
"glow_obj_size": 0x38,
"glow_R": 0x8,
"glow_G": 0xC,
"glow_B": 0x10,
"glow_A": 0x14,
"GOM_wall": 0x27,
"GOM_visible": 0x28
}
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):
"""Find module address"""
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
def find_uint(self, base, offset: int) -> int:
"""Find integer in memory for sure"""
local_element = None
while not local_element:
local_element = self.pm.read_uint(base + offset)
sleep(self.timeout)
return local_element
def hack_loop(self, method):
"""Run the hack loop"""
while True:
# Reduce CPU usage
sleep(self.wait_time)
# Cheat
method()
class Cheat(Hack):
def __init__(self) -> None:
super().__init__()
self.cheats_list = [func for func in dir(self)
# Function
if callable(getattr(self, func))
# User defined
if not func.startswith("_")
# Hack loop
if not func == "hack_loop"
# Utils
if not func.startswith("find_")]
def bhop(self) -> None:
# Aliases
mem = self.pm
offset = self.offsets
# Get client
client = self.find_module("client")
# Get player
local_player = self.find_uint(client, offset["dwLocalPlayer"])
def cheat():
# Pressing space bar
if not GetAsyncKeyState(VK_SPACE):
return
# Check if player is alive
if not mem.read_uint(local_player + offset["m_iHealth"]):
return
# 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)
mem.write_uint(client + offset["dwForceJump"], 4)
self.hack_loop(cheat)
def radar_hack(self) -> None:
# Aliases
mem = self.pm
offset = self.offsets
# Get module address
client = self.find_module("client")
# Get local player
local_player = self.find_uint(client, offset["dwLocalPlayer"])
# Get local team
local_team = self.find_uint(local_player, offset["m_iTeamNum"])
def cheat():
# Loop all entities
for i in range(1, 64): # 0 is world
entity = mem.read_uint(
client + offset["dwEntityList"] + i * offset["entity_size"])
# Ignore if entity doesn't exist
if not entity:
continue
# Ignore allies
if mem.read_uint(entity + offset["m_iTeamNum"]) == local_team:
continue
# Check if ennemy is alive
if not mem.read_uint(entity + offset["m_iHealth"]):
continue
mem.write_bool(entity + offset["m_bSpotted"], True)
self.hack_loop(cheat)
def glow(self) -> None:
# Aliases
mem = self.pm
offset = self.offsets
# Get module address
client = self.find_module("client")
# Get local player
local_player = self.find_uint(client, offset["dwLocalPlayer"])
# Get local team
local_team = self.find_uint(local_player, offset["m_iTeamNum"])
# Get glow object manager
glow_obj_manager = self.find_uint(
client, offset["dwGlowObjectManager"])
def cheat():
# Loop all entities
for i in range(1, 64): # 0 is world
entity = mem.read_uint(
client + offset["dwEntityList"] + i * offset["entity_size"])
# Ignore if entity doesn't exist
if not entity:
continue
# Ignore allies
if mem.read_uint(entity + offset["m_iTeamNum"]) == local_team:
continue
# Check if ennemy is alive
if not mem.read_uint(entity + offset["m_iHealth"]):
continue
# Space between values
i = mem.read_int(
entity + offset["m_iGlowIndex"]) * offset["glow_obj_size"]
# TODO: Reduce write call
# Change color glow
mem.write_float(glow_obj_manager + i + offset["glow_R"], 1.)
mem.write_float(glow_obj_manager + i + offset["glow_G"], 0.)
mem.write_float(glow_obj_manager + i + offset["glow_B"], 0.)
mem.write_float(glow_obj_manager + i + offset["glow_A"], 1.)
# Render when not visible
mem.write_bool(glow_obj_manager + i + offset["GOM_wall"], True)
# Render when visible
mem.write_bool(glow_obj_manager + i +
offset["GOM_visible"], True)
self.hack_loop(cheat)
def trigger(self) -> None:
# Aliases
mem = self.pm
offset = self.offsets
# Get module address
client = self.find_module("client")
# Get local player
local_player = self.find_uint(client, offset["dwLocalPlayer"])
# Get local team
local_team = self.find_uint(local_player, offset["m_iTeamNum"])
def cheat():
# Pressing trigger key
if not GetAsyncKeyState(EM_LINEINDEX):
return
# Check if player is alive
if not mem.read_int(local_player + offset["m_iHealth"]):
return
# Get crosshair info about what we aiming at
crosshair_id = mem.read_int(
local_player + offset["m_iCrosshairId"])
# 0 is wall, +64 isn't a player
if (crosshair_id == 0) or (crosshair_id > 64):
return
# Get ennemy under crosshair
ennemy = mem.read_uint(
client + offset["dwEntityList"] + (crosshair_id - 1) * offset["entity_size"])
# Check if ennemy is alive
if not mem.read_int(ennemy + offset["m_iHealth"]):
return
# Ignore allies
if mem.read_int(ennemy + offset["m_iTeamNum"]) == local_team:
return
# Shoot
mem.write_uint(client + offset["dwForceAttack"], 6)
sleep(0.2)
mem.write_uint(client + offset["dwForceAttack"], 4)
self.hack_loop(cheat)
def no_recoil(self) -> None:
# Aliases
mem = self.pm
offset = self.offsets
# Get module addresses
client = self.find_module("client")
engine = self.find_module("engine")
# Get local player
local_player = self.find_uint(client, offset["dwLocalPlayer"])
# Float size
float_offset = 4
# Control variable
self.nr__old_punch_x = 0.
self.nr__old_punch_y = 0.
def cheat():
# TODO: Reduce read/write call
# Check if player is shooting
if mem.read_int(local_player + offset["m_iShotsFired"]):
client_state = mem.read_uint(engine + offset["dwClientState"])
# Where player is looking
view_angles_x = mem.read_float(
client_state + offset["dwClientState_ViewAngles"])
view_angles_y = mem.read_float(
client_state + offset["dwClientState_ViewAngles"] + float_offset)
# Server multiple punch by 2
server_mult = 2.
# How much the view is modified
aim_punch_x = mem.read_float(
local_player + offset["m_aimPunchAngle"]) * server_mult
aim_punch_y = mem.read_float(
local_player + offset["m_aimPunchAngle"] + float_offset) * server_mult
# New angles
new_angle_x = view_angles_x + self.nr__old_punch_x - aim_punch_x
new_angle_y = view_angles_y + self.nr__old_punch_y - aim_punch_y
# Limit of pitch in game is ]-89; 180[
if new_angle_x > 89.:
new_angle_x = 89.
if new_angle_x < -89.:
new_angle_x = -89
# Limit of yaw in game is ]-180; 360[
while (new_angle_y > 180.):
new_angle_y -= 360.
while (new_angle_y < -180.):
new_angle_y += 360.
# Cancel recoil
mem.write_float(
client_state + offset["dwClientState_ViewAngles"], new_angle_x)
mem.write_float(
client_state + offset["dwClientState_ViewAngles"] + float_offset, new_angle_y)
self.nr__old_punch_x = aim_punch_x
self.nr__old_punch_y = aim_punch_y
else:
# Not spraying
# TODO: Reset to middle?
self.nr__old_punch_x = 0.
self.nr__old_punch_y = 0.
self.hack_loop(cheat)
def aimbot(self) -> None:
def cheat():
print("WIP")
exit(2)
self.hack_loop(cheat)
def chams(self) -> None:
def cheat():
print("WIP")
exit(2)
self.hack_loop(cheat)
def noflash(self) -> None:
# Aliases
mem = self.pm
offset = self.offsets
# Get module addresses
client = self.find_module("client")
# Get local player
local_player = self.find_uint(client, offset["dwLocalPlayer"])
def cheat():
if (mem.read_int(local_player + offset["m_flFlashDuration"])):
print("rtatio")
mem.write_int(local_player + offset["m_flFlashDuration"], 0)
# Less chance to get flash again
sleep(1)
self.hack_loop(cheat)
if __name__ == "__main__":
# Cheat
c = Cheat()
# Cheat list
print("Enter 0 to exit.")
print("You can run multiples cheat at once, separate your choices with a space.")
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:
response = [int(i) for i in input("Enter ID: ").split(" ")]
c_id = []
for i in response:
match i:
case 0:
exit(0)
case j if j > len(c.cheats_list):
raise IndexError
case _:
c_id.append(i - 1)
except KeyboardInterrupt:
print("??\nBye.")
exit(1)
except:
print("Invalid ID.")
# Instanciate and run threads
for fn in [c.cheats_list[i] for i in c_id]:
print(f"Running {fn}...")
t = Thread(target=getattr(c, fn))
t.daemon = True
t.start()
# Don't close the main thread as cheats are daemons
while True:
sleep(1000000)