diff --git a/utils/Offsets.py b/utils/Offsets.py new file mode 100644 index 0000000..3739d2b --- /dev/null +++ b/utils/Offsets.py @@ -0,0 +1,155 @@ +import requests, json, sys + +n = open("classes/netvars.json", "r") + +response = json.load(n) + +m_totalHitsOnServer = int(response["DT_CSPlayer"]["m_totalHitsOnServer"]) + +url = 'https://raw.githubusercontent.com/frk1/hazedumper/master/csgo.json' +response = requests.get(url).json() + +cs_gamerules_data = int(response["netvars"]["cs_gamerules_data"]) + +m_ArmorValue = int(response["netvars"]["m_ArmorValue"]) +m_Collision = int(response["netvars"]["m_Collision"]) +m_CollisionGroup = int(response["netvars"]["m_CollisionGroup"]) +m_Local = int(response["netvars"]["m_Local"]) +m_MoveType = int(response["netvars"]["m_MoveType"]) +m_OriginalOwnerXuidHigh = int(response["netvars"]["m_OriginalOwnerXuidHigh"]) +m_OriginalOwnerXuidLow = int(response["netvars"]["m_OriginalOwnerXuidLow"]) +m_SurvivalGameRuleDecisionTypes = int(response["netvars"]["m_SurvivalGameRuleDecisionTypes"]) +m_SurvivalRules = int(response["netvars"]["m_SurvivalRules"]) +m_aimPunchAngleVel = int(response["netvars"]["m_aimPunchAngleVel"]) +m_aimPunchAngle = int(response["netvars"]["m_aimPunchAngle"]) +m_angEyeAnglesX = int(response["netvars"]["m_angEyeAnglesX"]) +m_angEyeAnglesY = int(response["netvars"]["m_angEyeAnglesY"]) +m_bBombPlanted = int(response["netvars"]["m_bBombPlanted"]) +m_bFreezePeriod = int(response["netvars"]["m_bFreezePeriod"]) +m_bGunGameImmunity = int(response["netvars"]["m_bGunGameImmunity"]) +m_bHasDefuser = int(response["netvars"]["m_bHasDefuser"]) +m_bHasHelmet = int(response["netvars"]["m_bHasHelmet"]) +m_bInReload = int(response["netvars"]["m_bInReload"]) +m_bIsDefusing = int(response["netvars"]["m_bIsDefusing"]) +m_bIsQueuedMatchmaking = int(response["netvars"]["m_bIsQueuedMatchmaking"]) +m_bIsScoped = int(response["netvars"]["m_bIsScoped"]) +m_bIsValveDS = int(response["netvars"]["m_bIsValveDS"]) +m_bSpotted = int(response["netvars"]["m_bSpotted"]) +m_bSpottedByMask = int(response["netvars"]["m_bSpottedByMask"]) +m_bStartedArming = int(response["netvars"]["m_bStartedArming"]) +m_bUseCustomAutoExposureMax = int(response["netvars"]["m_bUseCustomAutoExposureMax"]) +m_bUseCustomAutoExposureMin = int(response["netvars"]["m_bUseCustomAutoExposureMin"]) +m_bUseCustomBloomScale = int(response["netvars"]["m_bUseCustomBloomScale"]) +m_clrRender = int(response["netvars"]["m_clrRender"]) +m_dwBoneMatrix = int(response["netvars"]["m_dwBoneMatrix"]) +m_fAccuracyPenalty = int(response["netvars"]["m_fAccuracyPenalty"]) +m_fFlags = int(response["netvars"]["m_fFlags"]) +m_flC4Blow = int(response["netvars"]["m_flC4Blow"]) +m_flCustomAutoExposureMax = int(response["netvars"]["m_flCustomAutoExposureMax"]) +m_flCustomAutoExposureMin = int(response["netvars"]["m_flCustomAutoExposureMin"]) +m_flCustomBloomScale = int(response["netvars"]["m_flCustomBloomScale"]) +m_flDefuseCountDown = int(response["netvars"]["m_flDefuseCountDown"]) +m_flDefuseLength = int(response["netvars"]["m_flDefuseLength"]) +m_flFallbackWear = int(response["netvars"]["m_flFallbackWear"]) +m_flFlashDuration = int(response["netvars"]["m_flFlashDuration"]) +m_flFlashMaxAlpha = int(response["netvars"]["m_flFlashMaxAlpha"]) +m_flLastBoneSetupTime = int(response["netvars"]["m_flLastBoneSetupTime"]) +m_flLowerBodyYawTarget = int(response["netvars"]["m_flLowerBodyYawTarget"]) +m_flNextAttack = int(response["netvars"]["m_flNextAttack"]) +m_flNextPrimaryAttack = int(response["netvars"]["m_flNextPrimaryAttack"]) +m_flSimulationTime = int(response["netvars"]["m_flSimulationTime"]) +m_flTimerLength = int(response["netvars"]["m_flTimerLength"]) +m_hActiveWeapon = int(response["netvars"]["m_hActiveWeapon"]) +m_hMyWeapons = int(response["netvars"]["m_hMyWeapons"]) +m_hObserverTarget = int(response["netvars"]["m_hObserverTarget"]) +m_hOwner = int(response["netvars"]["m_hOwner"]) +m_hOwnerEntity = int(response["netvars"]["m_hOwnerEntity"]) +m_iAccountID = int(response["netvars"]["m_iAccountID"]) +m_iClip1 = int(response["netvars"]["m_iClip1"]) +m_iCompetitiveRanking = int(response["netvars"]["m_iCompetitiveRanking"]) +m_iCompetitiveWins = int(response["netvars"]["m_iCompetitiveWins"]) +m_iCrosshairId = int(response["netvars"]["m_iCrosshairId"]) +m_iEntityQuality = int(response["netvars"]["m_iEntityQuality"]) +m_iFOV = int(response["netvars"]["m_iDefaultFOV"]) +m_iFOVStart = int(response["netvars"]["m_iFOVStart"]) +m_iGlowIndex = int(response["netvars"]["m_iGlowIndex"]) +m_iHealth = int(response["netvars"]["m_iHealth"]) +m_iItemDefinitionIndex = int(response["netvars"]["m_iItemDefinitionIndex"]) +m_iItemIDHigh = int(response["netvars"]["m_iItemIDHigh"]) +m_iMostRecentModelBoneCounter = int(response["netvars"]["m_iMostRecentModelBoneCounter"]) +m_iObserverMode = int(response["netvars"]["m_iObserverMode"]) +m_iShotsFired = int(response["netvars"]["m_iShotsFired"]) +m_iState = int(response["netvars"]["m_iState"]) +m_iTeamNum = int(response["netvars"]["m_iTeamNum"]) +m_lifeState = int(response["netvars"]["m_lifeState"]) +m_nFallbackPaintKit = int(response["netvars"]["m_nFallbackPaintKit"]) +m_nFallbackSeed = int(response["netvars"]["m_nFallbackSeed"]) +m_nFallbackStatTrak = int(response["netvars"]["m_nFallbackStatTrak"]) +m_nForceBone = int(response["netvars"]["m_nForceBone"]) +m_nTickBase = int(response["netvars"]["m_nTickBase"]) +m_rgflCoordinateFrame = int(response["netvars"]["m_rgflCoordinateFrame"]) +m_szCustomName = int(response["netvars"]["m_szCustomName"]) +m_szLastPlaceName = int(response["netvars"]["m_szLastPlaceName"]) +m_thirdPersonViewAngles = int(response["netvars"]["m_thirdPersonViewAngles"]) +m_vecOrigin = int(response["netvars"]["m_vecOrigin"]) +m_vecVelocity = int(response["netvars"]["m_vecVelocity"]) +m_vecViewOffset = int(response["netvars"]["m_vecViewOffset"]) +m_viewPunchAngle = int(response["netvars"]["m_viewPunchAngle"]) + +anim_overlays = int(response["signatures"]["anim_overlays"]) +clientstate_choked_commands = int(response["signatures"]["clientstate_choked_commands"]) +clientstate_delta_ticks = int(response["signatures"]["clientstate_delta_ticks"]) +clientstate_last_outgoing_command = int(response["signatures"]["clientstate_last_outgoing_command"]) +clientstate_net_channel = int(response["signatures"]["clientstate_net_channel"]) +convar_name_hash_table = int(response["signatures"]["convar_name_hash_table"]) +dwLocalPlayer = int(response["signatures"]["dwLocalPlayer"]) +dwClientState = int(response["signatures"]["dwClientState"]) +dwClientState_GetLocalPlayer = int(response["signatures"]["dwClientState_GetLocalPlayer"]) +dwClientState_IsHLTV = int(response["signatures"]["dwClientState_IsHLTV"]) +dwClientState_Map = int(response["signatures"]["dwClientState_Map"]) +dwClientState_MapDirectory = int(response["signatures"]["dwClientState_MapDirectory"]) +dwClientState_MaxPlayer = int(response["signatures"]["dwClientState_MaxPlayer"]) +dwClientState_PlayerInfo = int(response["signatures"]["dwClientState_PlayerInfo"]) +dwClientState_State = int(response["signatures"]["dwClientState_State"]) +dwClientState_ViewAngles = int(response["signatures"]["dwClientState_ViewAngles"]) +dwEntityList = int(response["signatures"]["dwEntityList"]) +dwForceAttack = int(response["signatures"]["dwForceAttack"]) +dwForceAttack2 = int(response["signatures"]["dwForceAttack2"]) +dwForceBackward = int(response["signatures"]["dwForceBackward"]) +dwForceForward = int(response["signatures"]["dwForceForward"]) +dwForceJump = int(response["signatures"]["dwForceJump"]) +dwForceLeft = int(response["signatures"]["dwForceLeft"]) +dwForceRight = int(response["signatures"]["dwForceRight"]) +dwGameDir = int(response["signatures"]["dwGameDir"]) +dwGameRulesProxy = int(response["signatures"]["dwGameRulesProxy"]) +dwGetAllClasses = int(response["signatures"]["dwGetAllClasses"]) +dwGlobalVars = int(response["signatures"]["dwGlobalVars"]) +dwGlowObjectManager = int(response["signatures"]["dwGlowObjectManager"]) +dwInput = int(response["signatures"]["dwInput"]) +dwInterfaceLinkList = int(response["signatures"]["dwInterfaceLinkList"]) +dwMouseEnable = int(response["signatures"]["dwMouseEnable"]) +dwMouseEnablePtr = int(response["signatures"]["dwMouseEnablePtr"]) +dwPlayerResource = int(response["signatures"]["dwPlayerResource"]) +dwSensitivity = int(response["signatures"]["dwSensitivity"]) +dwSensitivityPtr = int(response["signatures"]["dwSensitivityPtr"]) +dwRadarBase = int(response["signatures"]["dwRadarBase"]) +dwSetClanTag = int(response["signatures"]["dwSetClanTag"]) +dwViewMatrix = int(response["signatures"]["dwViewMatrix"]) +dwWeaponTable = int(response["signatures"]["dwWeaponTable"]) +dwWeaponTableIndex = int(response["signatures"]["dwWeaponTableIndex"]) +dwYawPtr = int(response["signatures"]["dwYawPtr"]) +dwZoomSensitivityRatioPtr = int(response["signatures"]["dwZoomSensitivityRatioPtr"]) +dwbSendPackets = int(response["signatures"]["dwbSendPackets"]) +dwppDirect3DDevice9 = int(response["signatures"]["dwppDirect3DDevice9"]) +find_hud_element = int(response["signatures"]["find_hud_element"]) +force_update_spectator_glow = int(response["signatures"]["force_update_spectator_glow"]) +interface_engine_cvar = int(response["signatures"]["interface_engine_cvar"]) +is_c4_owner = int(response["signatures"]["is_c4_owner"]) +m_bDormant = int(response["signatures"]["m_bDormant"]) +m_flSpawnTime = int(response["signatures"]["m_flSpawnTime"]) +m_pStudioHdr = int(response["signatures"]["m_pStudioHdr"]) +m_pitchClassPtr = int(response["signatures"]["m_pitchClassPtr"]) +m_yawClassPtr = int(response["signatures"]["m_yawClassPtr"]) +model_ambient_min = int(response["signatures"]["model_ambient_min"]) +set_abs_angles = int(response["signatures"]["set_abs_angles"]) +set_abs_origin = int(response["signatures"]["set_abs_origin"]) \ No newline at end of file diff --git a/utils/aimbot.py b/utils/aimbot.py new file mode 100644 index 0000000..33b4ea4 --- /dev/null +++ b/utils/aimbot.py @@ -0,0 +1,255 @@ +import pymem +import pymem.process +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +from math import * +import features_check +import keyboard +import win32api + + +class aimbot() : + def __init__(self): + try : + self.pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + self.client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll + self.engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll + self.enginepointer = self.pm.read_int(self.engine + dwClientState) + + read("aim") + + while features_check.check.aimbot : + + read("aim") + + key = self.get_key() + time.sleep(0.002) + + try : + while key : + key = self.get_key() + + aimlocalplayer = self.pm.read_int(self.client + dwLocalPlayer) + aimflag = self.pm.read_int(aimlocalplayer + m_fFlags) + aimteam = self.pm.read_int(aimlocalplayer + m_iTeamNum) + + for y in range(1): + + if self.pm.read_int(self.client + dwEntityList + y * 0x10): + aimplayer = self.GetBestTarget(aimlocalplayer) + aimplayerbone = self.pm.read_int(aimplayer + m_dwBoneMatrix) + gungameimmunity = self.pm.read_int(aimplayer + m_bGunGameImmunity) + aimplayerteam = self.pm.read_int(aimplayer + m_iTeamNum) + aimplayerhealth = self.pm.read_int(aimplayer + m_iHealth) + if aimplayerteam != aimteam and aimplayerhealth > 0 and gungameimmunity != 1: + localpos1 = self.pm.read_float(aimlocalplayer + m_vecOrigin) + localpos2 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 4) + if aimflag == 263: + localpos3 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 8) + 45 + elif aimflag == 257: + localpos3 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 8) + 62 + elif aimflag == 256: + localpos3 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 8) + 64 + + bone = 8 #head + enemypos1 = self.pm.read_float(aimplayerbone + 0x30 * bone + 0xC) + enemypos2 = self.pm.read_float(aimplayerbone + 0x30 * bone + 0x1C) + enemypos3 = self.pm.read_float(aimplayerbone + 0x30 * bone + 0x2C) + + targetline1 = enemypos1 - localpos1 + targetline2 = enemypos2 - localpos2 + targetline3 = enemypos3 - localpos3 + + viewanglex = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles) + viewangley = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles + 0x4) + + if targetline2 == 0 and targetline1 == 0: + yaw = 0 + if targetline3 > 0: + pitch = 270 + else: + pitch = 90 + else: + yaw = (atan2(targetline2, targetline1) * 180 / pi) + if yaw < 0: + yaw += 360 + hypo = sqrt( + (targetline1 * targetline1) + (targetline2 * targetline2) + (targetline3 * targetline3)) + pitch = (atan2(-targetline3, hypo) * 180 / pi) + + if pitch < 0: + pitch += 360 + + pitch, yaw = self.normalizeAngles(pitch, yaw) + if self.checkangles(pitch, yaw): + + distance_x, distance_y = self.calc_distance(viewanglex, viewangley, pitch, yaw) + + if distance_x < 900 and distance_y < 900: + + if self.nanchecker(pitch, yaw): + key = self.get_key() + if key : + + self.pm.write_float(self.enginepointer + dwClientState_ViewAngles, pitch) + self.pm.write_float(self.enginepointer + dwClientState_ViewAngles + 0x4, yaw) + except : + pass + + self.pm.close_process() + + def get_key(self) : + if "Button.right" in features_check.check.aimbot_key : + key = win32api.GetKeyState(0x02) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.left" in features_check.check.aimbot_key : + key = win32api.GetKeyState(0x01) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.middle" in features_check.check.aimbot_key : + key = win32api.GetKeyState(0x04) + if key == -127 or key == -128 : + key = True + else : + key = False + + else : + excpected_key = features_check.check.aimbot_key + excpected_key = excpected_key.replace("Key.", "") + key = keyboard.is_pressed(excpected_key) + + return key + + def checkindex(self) : + localplayer = self.pm.read_int(self.client + dwLocalPlayer) + for y in range(64): + if self.pm.read_int(self.client + dwEntityList + y * 0x10): + entity = self.pm.read_int(self.client + dwEntityList + y * 0x10) + if localplayer == entity and y: + return y + + def nanchecker(self, first, second): + if isnan(first) or isnan(second): + return False + else: + return True + + + def calc_distance(self, current_x, current_y, new_x, new_y): + distancex = new_x - current_x + if distancex < -89: + distancex += 360 + elif distancex > 89: + distancex -= 360 + if distancex < 0.0: + distancex = -distancex + + distancey = new_y - current_y + if distancey < -180: + distancey += 360 + elif distancey > 180: + distancey -= 360 + if distancey < 0.0: + distancey = -distancey + return distancex, distancey + + + def checkangles(self, x, y): + if x > 89: + return False + elif x < -89: + return False + elif y > 360: + return False + elif y < -360: + return False + else: + return True + + + def normalizeAngles(self, viewAngleX, viewAngleY): + if viewAngleX > 89: + viewAngleX -= 360 + if viewAngleX < -89: + viewAngleX += 360 + if viewAngleY > 180: + viewAngleY -= 360 + if viewAngleY < -180: + viewAngleY += 360 + return viewAngleX, viewAngleY + + + def Magnitude(self, vec_x, vec_y, vec_z): + return sqrt(vec_x * vec_x + vec_y * vec_y + vec_z * vec_z) + + + def Subtract(self, src_x, src_y, src_z, dst_x, dst_y, dst_z): + diff_x = src_x - dst_x + diff_y = src_y - dst_y + diff_z = src_z - dst_z + return (diff_x, diff_y, diff_z) + + + def Distance(self, src_x, src_y, src_z, dst_x, dst_y, dst_z): + diff_x, diff_y, diff_z = self.Subtract(src_x, src_y, src_z, dst_x, dst_y, dst_z) + src_x += diff_x + src_y += diff_y + return self.Magnitude(diff_x, diff_y, diff_z) + + + def calcangle(self, src_x, src_y, src_z, dst_x, dst_y, dst_z): + x = -atan2(dst_x - src_x, dst_y - src_y) / pi * 180.0 + 180.0 + y = asin((dst_z - src_z) / self.Distance(src_x, src_y, src_z, dst_x, dst_y, dst_z)) * 180.0 / pi + return x, y + + + def GetBestTarget(self, local): + while True: + olddist = 1.7976931348623157e+308 + newdist = None + target = None + if local : + localplayer_team = self.pm.read_int(local + m_iTeamNum) + for x in range(1): + entity_id = self.pm.read_int(local + m_iCrosshairId) + entity = self.pm.read_int(self.client + dwEntityList + (entity_id - 1) * 0x10) + if self.pm.read_int(self.client + dwEntityList + x * 0x10): + spotted = self.pm.read_int(entity + m_bSpottedByMask) + index = self.checkindex() + entity_health = self.pm.read_int(entity + m_iHealth) + entity_team = self.pm.read_int(entity + m_iTeamNum) + if localplayer_team != entity_team and entity_health > 0 :# and spotted == 1 << index: + entity_bones = self.pm.read_int(entity + m_dwBoneMatrix) + localpos_x = self.pm.read_float(local + m_vecOrigin) + localpos_y = self.pm.read_float(local + m_vecOrigin + 4) + localpos_z = self.pm.read_float(local + m_vecOrigin + 8) + + localpos_x_angles = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles) + localpos_y_angles = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles + 0x4) + localpos_z_angles = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles + 0x8) + + bone = 8 #head + entitypos_x = self.pm.read_float(entity_bones + 0x30 * bone + 0xC) + entitypos_y = self.pm.read_float(entity_bones + 0x30 * bone + 0x1C) + entitypos_z = self.pm.read_float(entity_bones + 0x30 * bone + 0x2C) + 64 + + X, Y = self.calcangle(entitypos_x, entitypos_y, entitypos_z, localpos_x, localpos_y, localpos_z) + newdist = self.Distance(localpos_x_angles, localpos_y_angles, localpos_z_angles, entitypos_x, + entitypos_y, entitypos_z) + olddist = newdist + target = entity + if target: + return target \ No newline at end of file diff --git a/utils/bhop_legit.py b/utils/bhop_legit.py new file mode 100644 index 0000000..d89e9ee --- /dev/null +++ b/utils/bhop_legit.py @@ -0,0 +1,50 @@ +import keyboard +import pymem +import pymem.process +import time +import ctypes, sys +from random import * +from Offsets import * +from win32gui import GetWindowText, GetForegroundWindow +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class bhop_legit() : + def __init__(self): + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + + read("misc") + while features_check.check.bhop_legit: + + try : + read("misc") + + if not GetWindowText(GetForegroundWindow()) == "Counter-Strike: Global Offensive": + continue + + if keyboard.is_pressed("space"): + force_jump = client + dwForceJump + player = pm.read_int(client + dwLocalPlayer) + if player: + on_ground = pm.read_int(player + m_fFlags) + if on_ground and on_ground == 257: + a = randint(0,5) + time.sleep(a/100) + pm.write_int(force_jump, 5) + time.sleep(0.08) + pm.write_int(force_jump, 4) + + time.sleep(0.002) + + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/bhop_rage.py b/utils/bhop_rage.py new file mode 100644 index 0000000..57e947d --- /dev/null +++ b/utils/bhop_rage.py @@ -0,0 +1,47 @@ +import keyboard +import pymem +import pymem.process +import time +import ctypes, sys +from Offsets import * +from win32gui import GetWindowText, GetForegroundWindow +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class bhop_rage() : + def __init__(self): + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + + read("misc") + while features_check.check.bhop_rage: + try : + + read("misc") + + if not GetWindowText(GetForegroundWindow()) == "Counter-Strike: Global Offensive": + continue + + if keyboard.is_pressed("space"): + force_jump = client + dwForceJump + player = pm.read_int(client + dwLocalPlayer) + if player: + on_ground = pm.read_int(player + m_fFlags) + if on_ground and on_ground == 257: + pm.write_int(force_jump, 5) + time.sleep(0.08) + pm.write_int(force_jump, 4) + + time.sleep(0.002) + + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/chams.py b/utils/chams.py new file mode 100644 index 0000000..7ae3938 --- /dev/null +++ b/utils/chams.py @@ -0,0 +1,124 @@ +import pymem +import pymem.process +import keyboard +import time +import re, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class chams() : + def __init__(self) : + self.pm = pymem.Pymem("csgo.exe") + self.base_client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll + self.base_engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll + self.dye_em() + + def get_class_id(self, entity): + buffer = self.pm.read_int(entity + 8) + buffer = self.pm.read_int(buffer + 2 * 4) + buffer = self.pm.read_int(buffer + 1) + return self.pm.read_int(buffer + 20) + + def get_entity_team(self, entity): + return self.pm.read_int(entity + m_iTeamNum) + + def dye_em(self): + glowmax = self.pm.read_int(self.base_client + dwGlowObjectManager + 4) + glow_object = self.pm.read_int(self.base_client + dwGlowObjectManager) + local_player = self.pm.read_int(self.base_client + dwLocalPlayer) + + read("chams") + first = True + + while features_check.check.chams_active : + read("chams") + + local_player_team = self.get_entity_team(local_player) + allies_color_rgba = self.rgba(features_check.check.allies_chams_color) + ennemies_color_rgba = self.rgba(features_check.check.ennemies_chams_color) + + for i in range(glowmax): + try: + entity = self.pm.read_int(glow_object + 56 * i) + if entity != 0 : + if self.get_class_id(entity) == 40: + entity_team = self.get_entity_team(entity) + entity_hp = self.pm.read_int(entity + m_iHealth) + + if features_check.check.chams_health_based : + + if entity_hp == 100 : + allies_color_rgba = self.rgba("[0, 1, 0, 1]") + ennemies_color_rgba = self.rgba("[0, 1, 0, 1]") + if entity_hp < 100 : + if entity_hp > 75: + ennemies_color_rgba = self.rgba("[0.30, 1, 0, 1]") + allies_color_rgba = self.rgba("[0.30, 1, 0, 1]") + if entity_hp < 75: + ennemies_color_rgba = self.rgba("[0.70, 0.30, 0, 1]") + allies_color_rgba = self.rgba("[0.70, 0.30, 0, 1]") + if entity_hp < 50 : + ennemies_color_rgba = self.rgba("[1, 0.10, 0, 1]") + allies_color_rgba = self.rgba("[1, 0.10, 0, 1]") + if entity_hp < 25 : + ennemies_color_rgba = self.rgba("[1, 0, 0, 1]") + allies_color_rgba = self.rgba("[1, 0, 0, 1]") + if entity_hp == 1 : + ennemies_color_rgba = self.rgba("[1, 1, 1, 1]") + allies_color_rgba = self.rgba("[1, 1, 1, 1]") + + if features_check.check.chams_allies : + if entity_team == local_player_team and entity_team != 0 and entity != local_player: + + self.pm.write_uchar(entity + 112, allies_color_rgba[0]) + self.pm.write_uchar(entity + 113, allies_color_rgba[1]) + self.pm.write_uchar(entity + 114, allies_color_rgba[2]) + + if not features_check.check.chams_allies : + if entity_team == local_player_team and entity_team != 0 and entity != local_player: + self.pm.write_uchar(entity + 112, 255) + self.pm.write_uchar(entity + 113, 255) + self.pm.write_uchar(entity + 114, 255) + + if features_check.check.chams_ennemies : + + if entity_team != local_player_team and entity_team != 0 and entity != local_player: + + self.pm.write_uchar(entity + 112, ennemies_color_rgba[0]) + self.pm.write_uchar(entity + 113, ennemies_color_rgba[1]) + self.pm.write_uchar(entity + 114, ennemies_color_rgba[2]) + + if not features_check.check.chams_ennemies : + if entity_team != local_player_team and entity_team != 0 and entity != local_player: + self.pm.write_uchar(entity + 112, 255) + self.pm.write_uchar(entity + 113, 255) + self.pm.write_uchar(entity + 114, 255) + + + if first == True : + b = 1084227584 + + pointer = self.pm.read_int(self.base_engine + model_ambient_min - 44) + xored = b ^ pointer + self.pm.write_int(self.base_engine + model_ambient_min, xored) + first = False + + time.sleep(0.002) + + except Exception as e : + pass + + self.pm.close_process() + + + def rgba(self, string) : + string = str(string) + string = string.strip('][').split(', ') + + string[0] = int(round((float(string[0])*255.0)/1.0, 0)) + string[1] = int(round((float(string[1])*255.0)/1.0, 0)) + string[2] = int(round((float(string[2])*255.0)/1.0, 0)) + + return string \ No newline at end of file diff --git a/utils/chams_reset.py b/utils/chams_reset.py new file mode 100644 index 0000000..8c00121 --- /dev/null +++ b/utils/chams_reset.py @@ -0,0 +1,61 @@ +import pymem +import pymem.process +import keyboard +import time +import re, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class chams_reset() : + def __init__(self) : + self.pm = pymem.Pymem("csgo.exe") + self.base_client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll + self.base_engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll + self.dye_em() + + def get_class_id(self, entity): + buffer = self.pm.read_int(entity + 8) + buffer = self.pm.read_int(buffer + 2 * 4) + buffer = self.pm.read_int(buffer + 1) + return self.pm.read_int(buffer + 20) + + def get_entity_team(self, entity): + return self.pm.read_int(entity + m_iTeamNum) + + def dye_em(self): + glowmax = self.pm.read_int(self.base_client + dwGlowObjectManager + 4) + glow_object = self.pm.read_int(self.base_client + dwGlowObjectManager) + local_player = self.pm.read_int(self.base_client + dwLocalPlayer) + + read("chams") + + while not features_check.check.chams_active : + + read("chams") + + for i in range(glowmax): + try: + entity = self.pm.read_int(glow_object + 56 * i) + if self.get_class_id(entity) == 40: + entity_team = self.get_entity_team(entity) + + if entity_team != 0 and entity != local_player: + + self.pm.write_uchar(entity + 112, 255) + self.pm.write_uchar(entity + 113, 255) + self.pm.write_uchar(entity + 114, 255) + + + b = 0 + pointer = self.pm.read_int(self.base_engine + model_ambient_min - 44) + xored = b ^ pointer + self.pm.write_int(self.base_engine + model_ambient_min, xored) + + except : + pass + + return + + self.pm.close_process() \ No newline at end of file diff --git a/utils/crosshair_hack.py b/utils/crosshair_hack.py new file mode 100644 index 0000000..733b932 --- /dev/null +++ b/utils/crosshair_hack.py @@ -0,0 +1,82 @@ +import sys +from PyQt5 import QtCore, QtGui, QtWidgets +import ctypes +import pymem +import pymem.process +import time +sys.path.insert(1, "classes/") +from features_reads import read +from Offsets import * +import features_check + +class Crosshair(QtWidgets.QWidget): + def __init__(self, parent=None, windowSize=24, penWidth=2): + QtWidgets.QWidget.__init__(self, parent) + self.ws = windowSize + self.resize(windowSize+1, windowSize+1) + self.pen = QtGui.QPen(QtGui.QColor(0,255,0,255)) + self.pen.setWidth(penWidth) + self.setWindowFlags(QtCore.Qt.FramelessWindowHint | QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.WindowTransparentForInput) + self.setAttribute(QtCore.Qt.WA_TranslucentBackground) + self.move(QtWidgets.QApplication.desktop().screen().rect().center() - self.rect().center() + QtCore.QPoint(1,1)) + + + def paintEvent(self, event): + ws = self.ws + d = 6 + painter = QtGui.QPainter(self) + painter.setPen(self.pen) + # painter.drawLine( x1,y1, x2,y2 ) + painter.drawLine( ws/2, 0, ws/2, ws/2 - ws/d ) # Top + painter.drawLine( ws/2, ws/2 + ws/d, ws/2, ws ) # Bottom + painter.drawLine( 0, ws/2, ws/2 - ws/d, ws/2 ) # Left + painter.drawLine( ws/2 + ws/d, ws/2, ws, ws/2 ) # Right + +class crosshair_hack() : + def __init__(self) : + app = QtWidgets.QApplication(sys.argv) + + widget = Crosshair(windowSize=24, penWidth=1) + widget.show() + + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + + awp = 9 + ssg = 40 + scar = 38 + g3sg1 = 11 + snipers = [awp, ssg, scar, g3sg1] + + read("aim") + + while features_check.check.crosshair : + try : + read("aim") + app.processEvents() + + player = pm.read_int(client + dwLocalPlayer) + scoped = pm.read_int(player + m_bIsScoped) + + weapon = pm.read_int(player + m_hActiveWeapon) + weapon_entity = pm.read_int(client + dwEntityList + ((weapon & 0xFFF) - 1) * 0x10) + + weapon_id = str(pm.read_short(weapon_entity + m_iItemDefinitionIndex)) + + if weapon: + if int(weapon_id) in snipers and scoped == 0 : + widget.show() + else : + widget.hide() + + time.sleep(0.2) + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/fake_lag.py b/utils/fake_lag.py new file mode 100644 index 0000000..5b6b07f --- /dev/null +++ b/utils/fake_lag.py @@ -0,0 +1,32 @@ +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +import pymem +import pymem.process +from features_reads import read +import features_check + +class fake_lag() : + + def __init__(self) : + + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + engine = pymem.process.module_from_name(pm.process_handle, "engine.dll").lpBaseOfDll + read("misc") + + while features_check.check.fake_lag : + try : + read("misc") + + pm.write_float(engine + 0x38E6AC4, features_check.check.fake_lag_value/2) + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/fov.py b/utils/fov.py new file mode 100644 index 0000000..ee31514 --- /dev/null +++ b/utils/fov.py @@ -0,0 +1,33 @@ +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +import pymem +import pymem.process +from features_reads import read +import features_check + +class fov() : + def __init__(self) : + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + read("misc") + + inputFOV = int(round(features_check.check.fov_value, 0)) + + player = pm.read_int(client + dwLocalPlayer) + + while features_check.check.fov : + read("misc") + inputFOV = int(round(features_check.check.fov_value, 0)) + + fov = player + m_iFOV + pm.write_int(fov, inputFOV) + + pm.close_process() \ No newline at end of file diff --git a/utils/fov_reset.py b/utils/fov_reset.py new file mode 100644 index 0000000..a7a5066 --- /dev/null +++ b/utils/fov_reset.py @@ -0,0 +1,22 @@ +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +import pymem +import pymem.process + +class fov_reset() : + def __init__(self) : + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + + player = pm.read_int(client + dwLocalPlayer) + fov = player + m_iFOV + + pm.write_int(fov, 90) + pm.close_process() \ No newline at end of file diff --git a/utils/glow.py b/utils/glow.py new file mode 100644 index 0000000..f5a1ee3 --- /dev/null +++ b/utils/glow.py @@ -0,0 +1,96 @@ +import pymem +import pymem.process +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class glow() : + + def __init__(self): + + try : + pm = pymem.Pymem("csgo.exe") + except Exception as e: + print(e) + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + glow_manager = pm.read_int(client + dwGlowObjectManager) + read("glow") + + while features_check.check.glow_active : + + try : + read("glow") + + for i in range(1, 32): # Entities 1-32 are reserved for players. + entity = pm.read_int(client + dwEntityList + i * 0x10) + + if entity: + entity_team_id = pm.read_int(entity + m_iTeamNum) + player = pm.read_int(client + dwLocalPlayer) + player_team = pm.read_int(player + m_iTeamNum) + entity_hp = pm.read_int(entity + m_iHealth) + entity_glow = pm.read_int(entity + m_iGlowIndex) + + if features_check.check.glow_health_based : + + if entity_hp == 100 : + ennemies_color = [0, 1, 0, 1] + allies_color = [0, 1, 0, 1] + if entity_hp < 100 : + if entity_hp > 75: + ennemies_color = [0.30, 1, 0, 1] + allies_color = [0.30, 1, 0, 1] + if entity_hp < 75: + ennemies_color = [0.70, 0.30, 0, 1] + allies_color = [0.70, 0.30, 0, 1] + if entity_hp < 50 : + ennemies_color = [1, 0.10, 0, 1] + allies_color = [1, 0.10, 0, 1] + if entity_hp < 25 : + ennemies_color = [1, 0, 0, 1] + allies_color = [1, 0, 0, 1] + if entity_hp == 1 : + ennemies_color = [1, 1, 1, 1] + allies_color = [1, 1, 1, 1] + + if not features_check.check.glow_health_based : + ennemies_color = self.rgba(features_check.check.ennemies_glow_color) + allies_color = self.rgba(features_check.check.allies_glow_color) + + + if features_check.check.glow_allies : + + if entity_team_id == player_team: # Terrorist + pm.write_float(glow_manager + entity_glow * 0x38 + 0x4, float(allies_color[0])) # R + pm.write_float(glow_manager + entity_glow * 0x38 + 0x8, float(allies_color[1])) # G + pm.write_float(glow_manager + entity_glow * 0x38 + 0xC, float(allies_color[2])) # B + pm.write_float(glow_manager + entity_glow * 0x38 + 0x10, float(allies_color[3])) # Alpha + pm.write_int(glow_manager + entity_glow * 0x38 + 0x24, 1) # Enable glow + + if features_check.check.glow_ennemies : + + if entity_team_id != player_team: # Counter-terrorist + pm.write_float(glow_manager + entity_glow * 0x38 + 0x4, float(ennemies_color[0])) # R + pm.write_float(glow_manager + entity_glow * 0x38 + 0x8, float(ennemies_color[1])) # G + pm.write_float(glow_manager + entity_glow * 0x38 + 0xC, float(ennemies_color[2])) # B + pm.write_float(glow_manager + entity_glow * 0x38 + 0x10, float(ennemies_color[3])) # Alpha + pm.write_int(glow_manager + entity_glow * 0x38 + 0x24, 1) # Enable glow + + time.sleep(0.002) + + except : + pass + + pm.close_process() + + def rgba(self, string) : + string = str(string) + + return string.strip('][').split(', ') \ No newline at end of file diff --git a/utils/hitsound.py b/utils/hitsound.py new file mode 100644 index 0000000..a58bbf7 --- /dev/null +++ b/utils/hitsound.py @@ -0,0 +1,42 @@ +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +import features_check +import pymem +import pymem.process +import winsound + +class hitsound() : + def __init__(self) : + + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + + read("misc") + + while features_check.check.hitsound : + try : + read("misc") + + player = pm.read_int(client + dwLocalPlayer) + + hitsound = pm.read_int(player + m_totalHitsOnServer) + + if hitsound > 0: + pm.write_int(player + m_totalHitsOnServer, 0) + + winsound.PlaySound("sounds/"+features_check.check.sound, winsound.SND_FILENAME) + + time.sleep(0.1) + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/money.py b/utils/money.py new file mode 100644 index 0000000..387fe62 --- /dev/null +++ b/utils/money.py @@ -0,0 +1,29 @@ +import pymem +import pymem.process +import re +import time +import ctypes, sys +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class money() : + def __init__(self) : + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + + client = pymem.process.module_from_name(pm.process_handle, + 'client.dll') + + clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage) + address = client.lpBaseOfDll + re.search(rb'.\x0C\x5B\x5F\xB8\xFB\xFF\xFF\xFF', + clientModule).start() + + + pm.write_uchar(address, 0xEB) + pm.close_process() \ No newline at end of file diff --git a/utils/money_reset.py b/utils/money_reset.py new file mode 100644 index 0000000..0ff7260 --- /dev/null +++ b/utils/money_reset.py @@ -0,0 +1,29 @@ +import pymem +import pymem.process +import re +import time +import ctypes, sys +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class money_reset() : + def __init__(self) : + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + + client = pymem.process.module_from_name(pm.process_handle, + 'client.dll') + + clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage) + address = client.lpBaseOfDll + re.search(rb'.\x0C\x5B\x5F\xB8\xFB\xFF\xFF\xFF', + clientModule).start() + + + pm.write_uchar(address, 0x75) + pm.close_process() \ No newline at end of file diff --git a/utils/noflash.py b/utils/noflash.py new file mode 100644 index 0000000..463bd27 --- /dev/null +++ b/utils/noflash.py @@ -0,0 +1,35 @@ +import pymem +import pymem.process +import time +import ctypes, sys +import warnings +warnings.simplefilter("ignore") +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class noflash() : + def __init__(self): + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + player = pm.read_int(client + dwLocalPlayer) + flash_value = player + m_flFlashMaxAlpha + + read("misc") + + while features_check.check.no_flash : + try : + read("misc") + pm.write_float(flash_value, float(0)) + time.sleep(0.2) + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/noflash_reset.py b/utils/noflash_reset.py new file mode 100644 index 0000000..3daab6d --- /dev/null +++ b/utils/noflash_reset.py @@ -0,0 +1,35 @@ +import pymem +import pymem.process +import time +import ctypes, sys +import warnings +warnings.simplefilter("ignore") +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class noflash_reset() : + def __init__(self): + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + player = pm.read_int(client + dwLocalPlayer) + flash_value = player + m_flFlashMaxAlpha + + read("misc") + + while not features_check.check.no_flash : + try : + read("misc") + pm.write_float(flash_value, float(255)) + time.sleep(0.2) + except : + pass + + pm.close_process() \ No newline at end of file diff --git a/utils/radar.py b/utils/radar.py new file mode 100644 index 0000000..06ed24d --- /dev/null +++ b/utils/radar.py @@ -0,0 +1,26 @@ +import pymem +import pymem.process +import re +import ctypes, sys +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class radar() : + def __init__(self) : + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, + 'client.dll') + + clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage) + address = client.lpBaseOfDll + re.search(rb'\x80\xB9.{5}\x74\x12\x8B\x41\x08', + clientModule).start() + 6 + + pm.write_uchar(address, 2) + pm.close_process() \ No newline at end of file diff --git a/utils/radar_reset.py b/utils/radar_reset.py new file mode 100644 index 0000000..e29ef0b --- /dev/null +++ b/utils/radar_reset.py @@ -0,0 +1,26 @@ +import pymem +import pymem.process +import re +import ctypes, sys +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class radar_reset() : + def __init__(self) : + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, + 'client.dll') + + clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage) + address = client.lpBaseOfDll + re.search(rb'\x80\xB9.{5}\x74\x12\x8B\x41\x08', + clientModule).start() + 6 + + pm.write_uchar(address, 0) + pm.close_process() \ No newline at end of file diff --git a/utils/rank_reveal.py b/utils/rank_reveal.py new file mode 100644 index 0000000..dcb6f43 --- /dev/null +++ b/utils/rank_reveal.py @@ -0,0 +1,79 @@ +import pymem +import pymem.process +import time +import ctypes +from tkinter import * +from Offsets import * + +class rank_reveal() : + def __init__(self): + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + top = Tk() + w = 320 + h = 300 + ws = top.winfo_screenwidth() + hs = top.winfo_screenheight() + x = (ws/2) - (w/2) + y = (hs/2) - (h/2) + top.geometry('%dx%d+%d+%d' % (w, h, x, y)) + top.title('Rank Reveal') + top.iconbitmap("images/re.ico") + top.config(background='#f0f0f0') + scrollbar = Scrollbar(top) + scrollbar.pack(side=RIGHT, fill=Y) + listbox = Listbox(top) + listbox.pack(expand=1, fill=BOTH) + listbox.config(yscrollcommand=scrollbar.set) + scrollbar.config(command=listbox.yview) + + client = pymem.process.module_from_name(pm.process_handle, "client.dll") + engine = pymem.process.module_from_name(pm.process_handle, "engine.dll") + + ranks = ["Unranked" , + "Silver I", + "Silver II", + "Silver III", + "Silver IV", + "Silver Elite", + "Silver Elite Master", + "Gold Nova I", + "Gold Nova II", + "Gold Nova III", + "Gold Nova Master", + "Master Guardian I", + "Master Guardian II", + "Master Guardian Elite", + "Distinguished Master Guardian", + "Legendary Eagle", + "Legendary Eagle Master", + "Supreme Master First Class", + "The Global Elite"] + for i in range(0, 32): + entity = pm.read_int(client.lpBaseOfDll + dwEntityList + i * 0x10) + + if entity: + entity_team_id = pm.read_int(entity + m_iTeamNum) + entity_i = pm.read_int(client.lpBaseOfDll + dwLocalPlayer) + if entity_team_id != pm.read_int(entity_i + m_iTeamNum): + player_info = pm.read_int( + (pm.read_int(engine.lpBaseOfDll + dwClientState)) + dwClientState_PlayerInfo) + player_info_items = pm.read_int(pm.read_int(player_info + 0x40) + 0xC) + info = pm.read_int(player_info_items + 0x28 + (i * 0x34)) + playerres = pm.read_int(client.lpBaseOfDll + dwPlayerResource) + rank = pm.read_int(playerres + m_iCompetitiveRanking + i * 4) + + if pm.read_string(info + 0x10) != 'GOTV': + + try : + listbox.insert(END, pm.read_string(info + 0x10) + " --> " + ranks[rank]) + except : + listbox.insert(END, pm.read_string(info + 0x10).encode('iso-8859-1').decode() + " --> " + ranks[rank]) + + top.mainloop() + pm.close_process() \ No newline at end of file diff --git a/utils/rapidfire.py b/utils/rapidfire.py new file mode 100644 index 0000000..68b0fd6 --- /dev/null +++ b/utils/rapidfire.py @@ -0,0 +1,63 @@ +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +import pymem +import pymem.process +from features_reads import read +import features_check +import keyboard +import win32api + +class rapidfire(): + + def __init__(self) : + + read("rapid fire") + key = self.get_key() + + while features_check.check.rapid_fire : + try : + read("rapid fire") + key = self.get_key() + + if key : + + while True : + ctypes.windll.user32.mouse_event(0x0002, 0, 0, 0, 0) + time.sleep(0.01) + ctypes.windll.user32.mouse_event(0x0004, 0, 0, 0, 0) + time.sleep(0.01) + + key = self.get_key() + if not key : + break + except : + pass + + def get_key(self) : + if "Button.right" in features_check.check.rapid_fire_key : + key = win32api.GetKeyState(0x02) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.left" in features_check.check.rapid_fire_key : + key = win32api.GetKeyState(0x01) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.middle" in features_check.check.rapid_fire_key : + key = win32api.GetKeyState(0x04) + if key == -127 or key == -128 : + key = True + else : + key = False + + else : + excpected_key = features_check.check.rapid_fire_key + excpected_key = excpected_key.replace("Key.", "") + key = keyboard.is_pressed(excpected_key) + + return key \ No newline at end of file diff --git a/utils/rcs.py b/utils/rcs.py new file mode 100644 index 0000000..d2b1c89 --- /dev/null +++ b/utils/rcs.py @@ -0,0 +1,94 @@ +import pymem +import pymem.process +import time +import ctypes, sys, time +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +from math import * +import math +import features_check + +class rcs() : + def __init__(self): + try : + self.pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + self.client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll + self.engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll + + read("rcs") + + perfect_percentage = features_check.check.rcs_perfect + + oldpunchx = 0.0 + oldpunchy = 0.0 + + + while features_check.check.rcs : + read("rcs") + perfect_percentage = features_check.check.rcs_perfect + + try : + time.sleep(0.01) + + rcslocalplayer = self.pm.read_int(self.client + dwLocalPlayer) + rcsengine = self.pm.read_int(self.engine + dwClientState) + + if self.pm.read_int(rcslocalplayer + m_iShotsFired) > 2: + rcs_x = self.pm.read_float(rcsengine + dwClientState_ViewAngles) + rcs_y = self.pm.read_float(rcsengine + dwClientState_ViewAngles + 0x4) + punchx = self.pm.read_float(rcslocalplayer + m_aimPunchAngle) + punchy = self.pm.read_float(rcslocalplayer + m_aimPunchAngle + 0x4) + newrcsx = rcs_x - (punchx - oldpunchx) * (perfect_percentage * 0.02) + newrcsy = rcs_y - (punchy - oldpunchy) * (perfect_percentage * 0.02) + newrcs, newrcy = self.normalizeAngles(newrcsx, newrcsy) + oldpunchx = punchx + oldpunchy = punchy + if self.nanchecker(newrcsx, newrcsy) and self.checkangles(newrcsx, newrcsy): + self.pm.write_float(rcsengine + dwClientState_ViewAngles, newrcsx) + self.pm.write_float(rcsengine + dwClientState_ViewAngles + 0x4, newrcsy) + else: + oldpunchx = 0.0 + oldpunchy = 0.0 + newrcsx = 0.0 + newrcsy = 0.0 + except : + pass + + self.pm.close_process() + + def normalizeAngles(self, viewAngleX, viewAngleY): + if viewAngleX > 89: + viewAngleX -= 360 + if viewAngleX < -89: + viewAngleX += 360 + if viewAngleY > 180: + viewAngleY -= 360 + if viewAngleY < -180: + viewAngleY += 360 + return viewAngleX, viewAngleY + + + def checkangles(self, x, y): + if x > 89: + return False + elif x < -89: + return False + elif y > 360: + return False + elif y < -360: + return False + else: + return True + + + def nanchecker(self, first, second): + if math.isnan(first) or math.isnan(second): + return False + else: + return True diff --git a/utils/silent.py b/utils/silent.py new file mode 100644 index 0000000..5a2c061 --- /dev/null +++ b/utils/silent.py @@ -0,0 +1,207 @@ +import pymem +import pymem.process +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +from math import * +import features_check +import keyboard +import win32api + +class silent() : + def __init__(self): + try : + self.pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + self.client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll + self.engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll + self.engine_pointer = self.pm.read_int(self.engine + dwClientState) + + read("aim") + + while features_check.check.silent_aim : + + read("aim") + key = self.get_key() + + while key : + + try : + key = self.get_key() + + target = None + olddistx = 111111111111 + olddisty = 111111111111 + + if self.client and self.engine and self.pm: + try: + player = self.pm.read_int(self.client + dwLocalPlayer) + localTeam = self.pm.read_int(player + m_iTeamNum) + except : + continue + + for i in range(1,32): + key = self.get_key() + + entity = self.pm.read_int(self.client + dwEntityList + i * 0x10) + + if entity: + try: + entity_team_id = self.pm.read_int(entity + m_iTeamNum) + entity_hp = self.pm.read_int(entity + m_iHealth) + entity_dormant = self.pm.read_int(entity + m_bDormant) + except : + continue + + if localTeam != entity_team_id and entity_hp > 0: + entity_bones = self.pm.read_int(entity + m_dwBoneMatrix) + localpos_x_angles = self.pm.read_float(self.engine_pointer + dwClientState_ViewAngles) + localpos_y_angles = self.pm.read_float(self.engine_pointer + dwClientState_ViewAngles + 0x4) + localpos1 = self.pm.read_float(player + m_vecOrigin) + localpos2 = self.pm.read_float(player + m_vecOrigin + 4) + localpos_z_angles = self.pm.read_float(player + m_vecViewOffset + 0x8) + localpos3 = self.pm.read_float(player + m_vecOrigin + 8) + localpos_z_angles + try: + entitypos_x = self.pm.read_float(entity_bones + 0x30 * 8 + 0xC) + entitypos_y = self.pm.read_float(entity_bones + 0x30 * 8 + 0x1C) + entitypos_z = self.pm.read_float(entity_bones + 0x30 * 8 + 0x2C) + except: + continue + try : + X, Y = self.calcangle(localpos1, localpos2, localpos3, entitypos_x, entitypos_y, entitypos_z) + except : + pass + newdist_x, newdist_y = self.calc_distance(localpos_x_angles, localpos_y_angles, X, Y) + if newdist_x < olddistx and newdist_y < olddisty and newdist_x <= 90 and newdist_y <= 90: + olddistx, olddisty = newdist_x, newdist_y + target, target_hp, target_dormant = entity, entity_hp, entity_dormant + target_x, target_y, target_z = entitypos_x, entitypos_y, entitypos_z + if key and player: + if target and target_hp > 0 and not target_dormant: + x, y = self.calcangle(localpos1, localpos2, localpos3, target_x, target_y, target_z) + normalize_x, normalize_y = self.normalizeAngles(x, y) + + if key : + #print(dwbSendPackets) #1993604684 #880218 + self.pm.write_uchar(self.engine + dwbSendPackets, 0) + Commands = self.pm.read_int(self.client + dwInput + 0xF4) + VerifedCommands = self.pm.read_int(self.client + dwInput + 0xF8) + Desired = self.pm.read_int(self.engine_pointer + clientstate_last_outgoing_command) + 2 + OldUser = Commands + ((Desired - 1) % 150) * 100 + VerifedOldUser = VerifedCommands + ((Desired - 1) % 150) * 0x68 + m_buttons = self.pm.read_int(OldUser + 0x30) + Net_Channel = self.pm.read_uint(self.engine_pointer + clientstate_net_channel) + if self.pm.read_int(Net_Channel + 0x18) >= Desired: + self.pm.write_float(OldUser + 0x0C, normalize_x) + self.pm.write_float(OldUser + 0x10, normalize_y) + self.pm.write_int(OldUser + 0x30, m_buttons | (1 << 0)) + self.pm.write_float(VerifedOldUser + 0x0C, normalize_x) + self.pm.write_float(VerifedOldUser + 0x10, normalize_y) + self.pm.write_int(VerifedOldUser + 0x30, m_buttons | (1 << 0)) + self.pm.write_uchar(self.engine + dwbSendPackets, 1) + else : + self.pm.write_uchar(self.engine + dwbSendPackets, 1) + else: + self.pm.write_float(self.engine_pointer + dwClientState_ViewAngles, normalize_x) + self.pm.write_float(self.engine_pointer + dwClientState_ViewAngles + 0x4, normalize_y) + + time.sleep(0.2) + except : + pass + + self.pm.close_process() + + def get_key(self) : + if "Button.right" in features_check.check.silent_aim_key : + key = win32api.GetKeyState(0x02) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.left" in features_check.check.silent_aim_key : + key = win32api.GetKeyState(0x01) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.middle" in features_check.check.silent_aim_key : + key = win32api.GetKeyState(0x04) + if key == -127 or key == -128 : + key = True + else : + key = False + + else : + excpected_key = features_check.check.silent_aim_key + excpected_key = excpected_key.replace("Key.", "") + key = keyboard.is_pressed(excpected_key) + + return key + + def normalizeAngles(self, viewAngleX, viewAngleY): + if viewAngleX > 89: + viewAngleX -= 360 + if viewAngleX < -89: + viewAngleX += 360 + if viewAngleY > 180: + viewAngleY -= 360 + if viewAngleY < -180: + viewAngleY += 360 + return viewAngleX, viewAngleY + + def checkangles(self, x, y): + if x > 89: + return False + elif x < -89: + return False + elif y > 360: + return False + elif y < -360: + return False + else: + return True + + def nanchecker(self, first, second): + if math.isnan(first) or math.isnan(second): + return False + else: + return True + + def calc_distance(self, current_x, current_y, new_x, new_y): + distancex = new_x - current_x + if distancex < -89: + distancex += 360 + elif distancex > 89: + distancex -= 360 + if distancex < 0.0: + distancex = -distancex + + distancey = new_y - current_y + if distancey < -180: + distancey += 360 + elif distancey > 180: + distancey -= 360 + if distancey < 0.0: + distancey = -distancey + return distancex, distancey + + def calcangle(self, localpos1, localpos2, localpos3, enemypos1, enemypos2, enemypos3): + try: + delta_x = localpos1 - enemypos1 + delta_y = localpos2 - enemypos2 + delta_z = localpos3 - enemypos3 + hyp = sqrt(delta_x * delta_x + delta_y * delta_y + delta_z * delta_z) + x = atan(delta_z / hyp) * 180 / pi + y = atan(delta_y / delta_x) * 180 / pi + if delta_x >= 0.0: + y += 180.0 + return x, y + except Exception as e: + print(e) + pass \ No newline at end of file diff --git a/utils/soundesp.py b/utils/soundesp.py new file mode 100644 index 0000000..dfb16d5 --- /dev/null +++ b/utils/soundesp.py @@ -0,0 +1,71 @@ +from Offsets import * +from ctypes import * +import ctypes +import pymem +import pymem.process +import time +import win32api +import random +import win32gui +import math +import winsound +sys.path.insert(1, "classes/") +from features_reads import read +import features_check + +class sound_esp() : + def __init__(self): + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + engine = pymem.process.module_from_name(pm.process_handle, "engine.dll").lpBaseOfDll + + localPlayer = pm.read_int(client + dwLocalPlayer) # Get localPlayer pointer + maxSoundESPDistance = 780 # Default: 780, decent distance tbh + + read("misc") + + while features_check.check.sound_esp : + + try : + read("misc") + closestPlayer = 99999.0 + + for i in range(0, 32): + read("misc") + ent = pm.read_int(client + dwEntityList + i * 0x10) # Get current entity based on for-loop variable i + + if ent is 0x0: + break + + entDormant = pm.read_int(ent + m_bDormant) # Get boolean that states whether glowCurrentPlayer entity is dormant or not + + myTeamID = pm.read_int(localPlayer + m_iTeamNum) # Get the team ID of the localPlayer + entityBaseTeamID = pm.read_int(ent + m_iTeamNum) # Get the team ID of the ent entity- + + localPlayerX = pm.read_float(localPlayer + m_vecOrigin) # Get the X coordinate of the vecOrigin of the localPlayer + localPlayerY = pm.read_float(localPlayer + m_vecOrigin + 0x4) # Get the Y coordinate of the vecOrigin of the localPlayer + localPlayerZ = pm.read_float(localPlayer + m_vecOrigin + 0x8) # Get the Z coordinate of the vecOrigin of the localPlayer + + entityX = pm.read_float(ent + m_vecOrigin) # Get the X coordinate of the vecOrigin of the ent + entityY = pm.read_float(ent + m_vecOrigin + 0x4) # Get the Y coordinate of the vecOrigin of the ent + entityZ = pm.read_float(ent + m_vecOrigin + 0x8) # Get the Z coordinate of the vecOrigin of the ent + + distance = math.sqrt((pow((entityX - localPlayerX), 2) + pow((entityY - localPlayerY), 2) + pow((entityZ - localPlayerZ), 2))) # Get the distance between localPlayer and ent + + if myTeamID != entityBaseTeamID and closestPlayer > distance: # If not on localPlayer team and team is either 2 or 3 and distance isnt 0 and distance is less than closestPlayer + closestPlayer = distance + + if closestPlayer < maxSoundESPDistance: # If closestPlayer isnt default value and closestPlayer is closer than maxSoundESPDistance + durMath = 1.000/maxSoundESPDistance # Generate baseline mathematical thingy - use ur brain + #winsound.Beep(2500, 2) + winsound.Beep(500, int((durMath * closestPlayer) * 1000)) + except : + pass + + pm.close_process() diff --git a/utils/thirdperson.py b/utils/thirdperson.py new file mode 100644 index 0000000..35c5e39 --- /dev/null +++ b/utils/thirdperson.py @@ -0,0 +1,80 @@ +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +import pymem +import pymem.process +from features_reads import read +import features_check +import keyboard +import win32api + +class thirdperson() : + def __init__(self): + try : + pm_memory = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm_memory.process_handle, "client.dll").lpBaseOfDll + lcbase = pm_memory.read_int(client + dwLocalPlayer) + fov = lcbase + m_iFOV + + read("misc") + key = self.get_key() + third_toggle = False + + while features_check.check.third_person : + read("misc") + key = self.get_key() + + if key : + try : + + if not third_toggle : + pm_memory.write_int(lcbase + m_iObserverMode, 1) + pm_memory.write_int(fov, 130) + + third_toggle = True + + elif third_toggle : + pm_memory.write_int(lcbase + m_iObserverMode, 0) + pm_memory.write_int(fov, 90) + + third_toggle = False + + time.sleep(0.2) + + except : + pass + + pm.close_process() + + def get_key(self) : + if "Button.right" in features_check.check.thirdperson_key : + key = win32api.GetKeyState(0x02) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.left" in features_check.check.thirdperson_key : + key = win32api.GetKeyState(0x01) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.middle" in features_check.check.thirdperson_key : + key = win32api.GetKeyState(0x04) + if key == -127 or key == -128 : + key = True + else : + key = False + + else : + excpected_key = features_check.check.thirdperson_key + excpected_key = excpected_key.replace("Key.", "") + key = keyboard.is_pressed(excpected_key) + + return key \ No newline at end of file diff --git a/utils/triggerbot.py b/utils/triggerbot.py new file mode 100644 index 0000000..e05f0ac --- /dev/null +++ b/utils/triggerbot.py @@ -0,0 +1,91 @@ +import pymem +import pymem.process +import time +import ctypes, sys +from Offsets import * +sys.path.insert(1, "classes/") +from features_reads import read +from math import * +import features_check +import keyboard +import win32api +from win32gui import GetWindowText, GetForegroundWindow + +class triggerbot() : + def __init__(self): + + try : + pm = pymem.Pymem("csgo.exe") + except : + MessageBox = ctypes.windll.user32.MessageBoxW + MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16) + return + + client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll + engine = pymem.process.module_from_name(pm.process_handle, "engine.dll").lpBaseOfDll + + + read("triggerbot") + delay = features_check.check.t_delay + key = self.get_key() + + while features_check.check.triggerbot : + + read("triggerbot") + delay = features_check.check.t_delay + key = self.get_key() + + if not GetWindowText(GetForegroundWindow()) == "Counter-Strike: Global Offensive": + continue + + if key : + + try : + key = self.get_key() + + player = pm.read_int(client + dwLocalPlayer) + entity_id = pm.read_int(player + m_iCrosshairId) + entity = pm.read_int(client + dwEntityList + (entity_id - 1) * 0x10) + + entity_team = pm.read_int(entity + m_iTeamNum) + player_team = pm.read_int(player + m_iTeamNum) + + if entity_id > 0 and entity_id <= 64 and player_team != entity_team: + if delay == 0 : + time.sleep(0) + else : + time.sleep(delay/1000) + pm.write_int(client + dwForceAttack, 6) + + time.sleep(0.006) + except : + pass + + pm.close_process() + + def get_key(self) : + if "Button.right" in features_check.check.triggerbot_key : + key = win32api.GetKeyState(0x02) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.left" in features_check.check.triggerbot_key : + key = win32api.GetKeyState(0x01) + if key == -127 or key == -128 : + key = True + else : + key = False + elif "Button.middle" in features_check.check.triggerbot_key : + key = win32api.GetKeyState(0x04) + if key == -127 or key == -128 : + key = True + else : + key = False + + else : + excpected_key = features_check.check.triggerbot_key + excpected_key = excpected_key.replace("Key.", "") + key = keyboard.is_pressed(excpected_key) + + return key \ No newline at end of file