├── README.md ├── External-CSGO ├── Structs │ ├── CharCodes.cs │ ├── matrix3x4.cs │ ├── mstudiobbox_t.cs │ ├── Color.cs │ ├── GlowObjectDefinition_t.cs │ ├── player_info_s.cs │ ├── ConVar.cs │ ├── UserCmd.cs │ ├── trace_t.cs │ ├── Vector.cs │ └── ClassId.cs ├── Globals.cs ├── Util │ ├── RandomHelper.cs │ └── MathUtil.cs ├── SDK │ ├── Misc │ │ ├── CWeaponTable.cs │ │ ├── CConVarManager.cs │ │ └── CCHitboxManager.cs │ ├── MiscClasses │ │ ├── Definitions.cs │ │ ├── CCSWeaponInfo.cs │ │ ├── CGlobalVarsBase.cs │ │ ├── CUserCmdList.cs │ │ ├── CVerifiedUserCmdList.cs │ │ └── ConVar.cs │ ├── Interfaces │ │ ├── CInputSystem.cs │ │ ├── CInput.cs │ │ ├── IClientEntityList.cs │ │ ├── INetworkStringTable.cs │ │ ├── CGlowObjectManager.cs │ │ └── CClientState.cs │ └── Entity │ │ ├── CLocalPlayer.cs │ │ ├── IClientEntity.cs │ │ ├── CBasePlayer.cs │ │ └── CBaseWeapon.cs ├── CodeInjection │ ├── ClientCmd.cs │ ├── UTILS_GAME.cs │ ├── RevealRank.cs │ ├── SendClantag.cs │ └── LineGoesThroughSmoke.cs ├── API │ ├── SmartAllocator.cs │ ├── MemoryAPI.cs │ └── WinAPI.cs ├── ExternalCSGO.sln ├── Properties │ └── AssemblyInfo.cs ├── Program.cs ├── Memory │ └── PatternScanner.cs ├── Settings │ └── Config.cs ├── ExternalCSGO.csproj ├── CSGOProcess.cs ├── Offsets │ ├── NetVarManager.cs │ └── Signatures.cs └── MainThread.cs └── .gitignore /README.md: -------------------------------------------------------------------------------- 1 | # ExternalCSGO -------------------------------------------------------------------------------- /External-CSGO/Structs/CharCodes.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct CharCodes 11 | { 12 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 255)] 13 | public int[] tab; 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /External-CSGO/Globals.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Offsets; 3 | using SimpleExternalCheatCSGO.SDK; 4 | using System; 5 | using System.Collections.Generic; 6 | using System.Linq; 7 | using System.Text; 8 | 9 | namespace SimpleExternalCheatCSGO 10 | { 11 | public static class Globals 12 | { 13 | public static CSGOProcess _csgo = new CSGOProcess(); 14 | public static NetVarManager _netvar = new NetVarManager(); 15 | public static Signatures _signatures = new Signatures(); 16 | public static SmartAllocator _alloc = new SmartAllocator(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /External-CSGO/Structs/matrix3x4.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct float_4 11 | { 12 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] 13 | public float[] second; 14 | } 15 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 16 | public struct matrix3x4 17 | { 18 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] 19 | public float_4[] first; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /External-CSGO/Structs/mstudiobbox_t.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct mstudiobbox_t 11 | { 12 | public int bone; 13 | public int group; 14 | public struct_Vector bbmin; 15 | public struct_Vector bbmax; 16 | public int szhitboxnameindex; 17 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)] 18 | public char[] m_iPad01; 19 | public float m_flRadius; 20 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 21 | public int[] m_iPad02; 22 | }; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /External-CSGO/Util/RandomHelper.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Text; 5 | 6 | namespace SimpleExternalCheatCSGO.Util 7 | { 8 | public static class RandomHelper 9 | { 10 | public static int RandomInt(int min,int max) 11 | { 12 | Random rand = new Random(Environment.TickCount); 13 | return rand.Next(min, max); 14 | } 15 | 16 | public static string RandomString(int length) 17 | { 18 | Random rand = new Random(Environment.TickCount); 19 | const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; 20 | return new string(Enumerable.Repeat(chars, length) 21 | .Select(s => s[rand.Next(s.Length)]).ToArray()); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Misc/CWeaponTable.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.SDK.MiscClasses; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CWeaponTable 11 | { 12 | public IntPtr pThis; 13 | 14 | public void Update() 15 | { 16 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_WeaponTable); 17 | } 18 | 19 | public CCSWeaponInfo GetWeaponInfo(int nTableIndex) 20 | { 21 | return new CCSWeaponInfo(MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0xC + (0x10 * nTableIndex))); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /External-CSGO/SDK/MiscClasses/Definitions.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Text; 5 | 6 | namespace SimpleExternalCheatCSGO.SDK 7 | { 8 | public enum Team 9 | { 10 | NONE = 0, 11 | SPEC, 12 | TT, 13 | CT 14 | }; 15 | enum HitboxList 16 | { 17 | HITBOX_HEAD = 0, 18 | HITBOX_NECK, 19 | HITBOX_LOWER_NECK, 20 | HITBOX_PELVIS, 21 | HITBOX_BODY, 22 | HITBOX_THORAX, 23 | HITBOX_CHEST, 24 | HITBOX_UPPER_CHEST, 25 | HITBOX_R_THIGH, 26 | HITBOX_L_THIGH, 27 | HITBOX_R_CALF, 28 | HITBOX_L_CALF, 29 | HITBOX_R_FOOT, 30 | HITBOX_L_FOOT, 31 | HITBOX_R_HAND, 32 | HITBOX_L_HAND, 33 | HITBOX_R_UPPER_ARM, 34 | HITBOX_R_FOREARM, 35 | HITBOX_L_UPPER_ARM, 36 | HITBOX_L_FOREARM, 37 | HITBOX_MAX 38 | }; 39 | } 40 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Interfaces/CInputSystem.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.SDK 8 | { 9 | public class CInputSystem 10 | { 11 | public IntPtr pThis; 12 | public CInputSystem() 13 | { 14 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["inputsystem"].BaseAddress + Globals._signatures.dw_inputsystem); 15 | } 16 | 17 | public bool GetInputState() 18 | { 19 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_inputenabled); 20 | } 21 | 22 | public void SetInputState(bool enabled) 23 | { 24 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_inputenabled, enabled); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /External-CSGO/Structs/Color.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Text; 5 | 6 | namespace SimpleExternalCheatCSGO.Structs 7 | { 8 | public class Color 9 | { 10 | public float R; 11 | public float G; 12 | public float B; 13 | public float A; 14 | 15 | public Color() 16 | { 17 | R = 0; 18 | G = 0; 19 | B = 0; 20 | A = 255; 21 | } 22 | public Color(float r, float g, float b) 23 | { 24 | R = r; 25 | G = g; 26 | B = b; 27 | A = 255; 28 | } 29 | public Color(float r, float g, float b, float a) 30 | { 31 | R = r; 32 | G = g; 33 | B = b; 34 | A = a; 35 | } 36 | public override string ToString() 37 | { 38 | return string.Format("{0},{1},{2},{3}", (int)R, (int)G, (int)B, (int)A); 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Interfaces/CInput.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.SDK 8 | { 9 | public class CInput 10 | { 11 | public IntPtr pThis; 12 | public CVerifiedUserCmdList pCVerifiedUserCmdList = new CVerifiedUserCmdList(); 13 | public CUserCmdList pCUserCmdList = new CUserCmdList(); 14 | public CInput() 15 | { 16 | pThis = Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_pInput; 17 | } 18 | public void Update() 19 | { 20 | pCUserCmdList.Update(pThis); 21 | pCVerifiedUserCmdList.Update(pThis); 22 | } 23 | 24 | public CVerifiedUserCmdList GetVerifiedUserCmd() 25 | { 26 | return pCVerifiedUserCmdList; 27 | } 28 | 29 | public CUserCmdList GetUserCmd() 30 | { 31 | return pCUserCmdList; 32 | } 33 | 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /External-CSGO/Structs/GlowObjectDefinition_t.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct GlowObjectDefinition_t 11 | { 12 | public int dwEntity; // 0x0 13 | public float fR; // 0x4 14 | public float fG; // 0x8 15 | public float fB; // 0xC 16 | public float fAlpha; // 0x10 17 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 18 | public char[] cJunk; // 0x14 19 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 20 | public bool bRenderWhenOccluded; // 0x24 21 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 22 | public bool bRenderWhenUnoccluded; // 0x25 23 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 24 | public bool bFullBloomRender; // 0x26 25 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] 26 | public char[] junk2; // 0x26 27 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 28 | public bool m_bInnerGlow; // 0x2C 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /External-CSGO/SDK/MiscClasses/CCSWeaponInfo.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.SDK.MiscClasses 8 | { 9 | public enum WeaponType 10 | { 11 | WEAPONTYPE_KNIFE = 0, 12 | WEAPONTYPE_PISTOL, 13 | WEAPONTYPE_SUBMACHINEGUN, 14 | WEAPONTYPE_RIFLE, 15 | WEAPONTYPE_SHOTGUN, 16 | WEAPONTYPE_SNIPER_RIFLE, 17 | WEAPONTYPE_MACHINEGUN, 18 | WEAPONTYPE_C4, 19 | WEAPONTYPE_PLACEHOLDER, 20 | WEAPONTYPE_GRENADE, 21 | WEAPONTYPE_UNKNOWN 22 | }; 23 | 24 | public class CCSWeaponInfo 25 | { 26 | public IntPtr pThis; 27 | public CCSWeaponInfo(IntPtr Pointer) 28 | { 29 | pThis = Pointer; 30 | } 31 | 32 | public WeaponType GetWeaponType() 33 | { 34 | return (WeaponType)MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x00C8); 35 | } 36 | 37 | public bool IsFullAuto() 38 | { 39 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x00E8); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /External-CSGO/Structs/player_info_s.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct player_info_s 11 | { 12 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] 13 | public char[] __pad0; 14 | public int m_nXuidLow; 15 | public int m_nXuidHigh; 16 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] 17 | public char[] m_szPlayerName; 18 | public int m_nUserID; 19 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 33)] 20 | public char[] m_szSteamID; 21 | public uint m_nSteam3ID; 22 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] 23 | public char[] m_szFriendsName; 24 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 25 | public bool m_bIsFakePlayer; 26 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 27 | public bool m_bIsHLTV; 28 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] 29 | public int[] m_dwCustomFiles; 30 | public char m_FilesDownloaded; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /External-CSGO/SDK/MiscClasses/CGlobalVarsBase.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Runtime.InteropServices; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 11 | public struct GlobalVarsBase 12 | { 13 | public float realtime; 14 | public int framecount; 15 | public float absoluteframetime; 16 | public float absoluteframestarttimestddev; 17 | public float curtime; 18 | public float frametime; 19 | public int maxClients; 20 | public int tickcount; 21 | public float interval_per_tick; 22 | public float interpolation_amount; 23 | }; 24 | public class CGlobalVarsBase 25 | { 26 | public GlobalVarsBase pGlobals; 27 | 28 | public void Update() 29 | { 30 | pGlobals = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["engine"].BaseAddress + Globals._signatures.dw_GlobalVars); 31 | } 32 | 33 | public GlobalVarsBase Get() 34 | { 35 | return pGlobals; 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /External-CSGO/Structs/ConVar.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct ConVar_struct 11 | { 12 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] 13 | public char[] pad_0x0000; //0x0000 14 | public IntPtr pNext; //0x0004 15 | public int bRegistered; //0x0008 16 | public IntPtr pszName; //0x000C 17 | public IntPtr pszHelpString; //0x0010 18 | public int nFlags; //0x0014 19 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] 20 | public char[] pad_0x0018; //0x0018 21 | public IntPtr pParent; //0x001C 22 | public IntPtr pszDefaultValue; //0x0020 23 | public IntPtr strString; //0x0024 24 | public int StringLength; //0x0028 25 | public float fValue; //0x002C 26 | public int nValue; //0x0030 27 | public int bHasMin; //0x0034 28 | public float fMinVal; //0x0038 29 | public int bHasMax; //0x003C 30 | public float fMaxVal; //0x0040 31 | public IntPtr fnChangeCallback; //0x0044 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /External-CSGO/SDK/MiscClasses/CUserCmdList.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CUserCmdList 11 | { 12 | public IntPtr pThis; 13 | 14 | public void Update(IntPtr pBase) 15 | { 16 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, IntPtr.Add(pBase, 0xEC)); 17 | } 18 | 19 | public CUserCmd GetUserCmdBySequence(int sequence_number) 20 | { 21 | return GetUserCmd(sequence_number % 150); 22 | } 23 | 24 | public CUserCmd GetUserCmd(int iIndex) 25 | { 26 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, IntPtr.Add(pThis, ((iIndex) * 0x64) + 0x4)); 27 | } 28 | 29 | public void SetUserCmdBySequence(int sequence_number, CUserCmd cmd) 30 | { 31 | SetUserCmd(sequence_number % 150, cmd); 32 | } 33 | 34 | public void SetUserCmd(int iIndex, CUserCmd cmd) 35 | { 36 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, IntPtr.Add(pThis, ((iIndex) * 0x64) + 0x4), cmd); 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /External-CSGO/Structs/UserCmd.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct CUserCmd 11 | { 12 | public int command_number; 13 | public int tick_count; 14 | public struct_Vector viewangles; 15 | public struct_Vector aimdirection; 16 | public float forwardmove; 17 | public float sidemove; 18 | public float upmove; 19 | public int buttons; 20 | public char impulse; 21 | public int weaponselect; 22 | public int weaponsubtype; 23 | public int random_seed; 24 | public short mousedx; 25 | public short mousedy; 26 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 27 | public bool hasbeenpredicted; 28 | public struct_Vector headangles; 29 | public struct_Vector headoffset; 30 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x2)] 31 | public char[] unkown; 32 | }; 33 | 34 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 35 | public struct CVerifiedUserCmd 36 | { 37 | public CUserCmd m_cmd; 38 | public uint m_crc; 39 | }; 40 | } 41 | -------------------------------------------------------------------------------- /External-CSGO/CodeInjection/ClientCmd.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.CodeInjection 8 | { 9 | public static class ClientCmd 10 | { 11 | 12 | public static int Size = 256; 13 | public static IntPtr Address; 14 | 15 | public static void Do(string szCmd) 16 | { 17 | if (Address == IntPtr.Zero) 18 | { 19 | Alloc(); 20 | if (Address == IntPtr.Zero) 21 | return; 22 | } 23 | if (szCmd.Length > 255) 24 | szCmd = szCmd.Substring(0, 255); 25 | 26 | var szCmd_bytes = Encoding.UTF8.GetBytes(szCmd + "\0"); 27 | 28 | WinAPI.WriteProcessMemory(Globals._csgo.ProcessHandle, Address, szCmd_bytes, szCmd_bytes.Length, 0); 29 | 30 | IntPtr Thread = WinAPI.CreateRemoteThread(Globals._csgo.ProcessHandle, (IntPtr)null, IntPtr.Zero, new IntPtr(Globals._signatures.dw_clientcmd), Address, 0, (IntPtr)null); 31 | 32 | WinAPI.CloseHandle(Thread); 33 | 34 | WinAPI.WaitForSingleObject(Thread, 0xFFFFFFFF); 35 | } 36 | 37 | public static void Alloc() 38 | { 39 | Address = Globals._alloc.SmartAlloc(Size); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /External-CSGO/SDK/MiscClasses/CVerifiedUserCmdList.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CVerifiedUserCmdList 11 | { 12 | public IntPtr pThis; 13 | 14 | public void Update(IntPtr pBase) 15 | { 16 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, IntPtr.Add(pBase, 0xF0)); 17 | } 18 | 19 | public CVerifiedUserCmd GetVerifiedUserCmdBySequence(int sequence_number) 20 | { 21 | return GetVerifiedUserCmd(sequence_number % 150); 22 | } 23 | 24 | public CVerifiedUserCmd GetVerifiedUserCmd(int iIndex) 25 | { 26 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, IntPtr.Add(pThis, ((iIndex) * 0x68) + 0x4)); 27 | } 28 | 29 | public void SetVerifiedUserCmdBySequence(int sequence_number, CVerifiedUserCmd cmd) 30 | { 31 | SetVerifiedUserCmd(sequence_number % 150, cmd); 32 | } 33 | 34 | public void SetVerifiedUserCmd(int iIndex, CVerifiedUserCmd cmd) 35 | { 36 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, IntPtr.Add(pThis, ((iIndex) * 0x68) + 0x4), cmd); 37 | } 38 | 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Interfaces/IClientEntityList.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.SDK 8 | { 9 | public class IClientEntityList 10 | { 11 | public IntPtr pThis; 12 | public List pPlayerList = new List(); 13 | public IClientEntityList() 14 | { 15 | pThis = Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_entitylist; 16 | } 17 | public void Update() 18 | { 19 | pPlayerList.Clear(); 20 | for (int i = 1; i <= MainThread.g_GlobalVars.Get().maxClients; ++i) 21 | { 22 | IntPtr pEntity = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + ((i - 1) * 0x10)); 23 | if (pEntity != IntPtr.Zero) 24 | pPlayerList.Add(pEntity); 25 | } 26 | } 27 | public IntPtr GetEntityByIndex(int iIndex) 28 | { 29 | IntPtr pEntity = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + ((iIndex - 1) * 0x10)); 30 | return pEntity; 31 | } 32 | 33 | public int GetHighestEntityIndex() 34 | { 35 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_HighestEntityIndex); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Interfaces/INetworkStringTable.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Runtime.InteropServices; 7 | using System.Text; 8 | 9 | namespace SimpleExternalCheatCSGO.SDK 10 | { 11 | public class ModelINetworkStringTable 12 | { 13 | public IntPtr pThis; 14 | public Dictionary Items = new Dictionary(); 15 | public string lastMap = ""; 16 | public ModelINetworkStringTable(IntPtr pThis) 17 | { 18 | this.pThis = pThis; 19 | } 20 | 21 | public void Update() 22 | { 23 | Items.Clear(); 24 | IntPtr startAddress = GetItems(); 25 | for (int i = 0; i < 1024; ++i) 26 | { 27 | IntPtr namePointer = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, startAddress + 0xC + (i * 0x34)); 28 | string model_name = MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, namePointer, -1); 29 | if (model_name.StartsWith("models")) 30 | Items.Add(model_name, i - 3); 31 | } 32 | } 33 | 34 | public IntPtr GetItems() 35 | { 36 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x3C) + 0xC); 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /External-CSGO/SDK/MiscClasses/ConVar.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.SDK.MiscClasses 8 | { 9 | public class ConVar 10 | { 11 | public IntPtr pThis; 12 | public ConVar(IntPtr Pointer) 13 | { 14 | pThis = Pointer; 15 | } 16 | public ConVar(string name) 17 | { 18 | pThis = MainThread.g_ConVar.GetConVarAddress(name); 19 | } 20 | 21 | public int GetInt() 22 | { 23 | int xor_value = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x30); 24 | 25 | xor_value ^= (int)pThis; 26 | 27 | return xor_value; 28 | } 29 | 30 | public void ClearCallbacks() 31 | { 32 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + 0x44 + 0xC, 0); 33 | } 34 | 35 | public bool GetBool() 36 | { 37 | return GetInt() != 0; 38 | } 39 | 40 | public float GetFloat() 41 | { 42 | byte[] xored = MemoryAPI.ReadMemory(Globals._csgo.ProcessHandle, pThis + 0x2C, 4); 43 | 44 | byte[] key = BitConverter.GetBytes((int)pThis); 45 | 46 | for (int i = 0; i < 4; ++i) 47 | xored[i] ^= key[i]; 48 | 49 | float value = BitConverter.ToSingle(xored, 0); 50 | 51 | return value; 52 | } 53 | 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /External-CSGO/API/SmartAllocator.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Text; 5 | 6 | namespace SimpleExternalCheatCSGO.API 7 | { 8 | public class SmartAllocator 9 | { 10 | public Dictionary AllocatedSize = new Dictionary(); 11 | 12 | public IntPtr AlloacNewPage(IntPtr size) 13 | { 14 | var Address = WinAPI.VirtualAllocEx(Globals._csgo.ProcessHandle, IntPtr.Zero, 4096, WinAPI.MEM_COMMIT | WinAPI.MEM_RESERVE, WinAPI.PAGE_READWRITE); 15 | 16 | AllocatedSize.Add(Address, size); 17 | 18 | return Address; 19 | } 20 | 21 | public void Free() 22 | { 23 | foreach (var key in AllocatedSize) 24 | WinAPI.VirtualFreeEx(Globals._csgo.ProcessHandle, key.Key, 4096, WinAPI.MEM_COMMIT | WinAPI.MEM_RESERVE); 25 | } 26 | 27 | public IntPtr SmartAlloc(int size) 28 | { 29 | for (int i = 0; i < AllocatedSize.Count; ++i) 30 | { 31 | var key = AllocatedSize.ElementAt(i).Key; 32 | int value = (int)AllocatedSize[key] + size; 33 | if (value < 4096) 34 | { 35 | IntPtr CurrentAddres = IntPtr.Add(key, (int)AllocatedSize[key]); 36 | AllocatedSize[key] = new IntPtr(value); 37 | return CurrentAddres; 38 | } 39 | } 40 | 41 | return AlloacNewPage(new IntPtr(size)); 42 | } 43 | 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /External-CSGO/ExternalCSGO.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.27130.2010 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExternalCSGO", "ExternalCSGO.csproj", "{909D494F-72FD-47B3-A5E8-B01650982BCC}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|Any CPU = Debug|Any CPU 11 | Debug|x86 = Debug|x86 12 | Release|Any CPU = Release|Any CPU 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU 17 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Debug|Any CPU.Build.0 = Debug|Any CPU 18 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Debug|x86.ActiveCfg = Debug|x86 19 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Debug|x86.Build.0 = Debug|x86 20 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Release|Any CPU.ActiveCfg = Release|Any CPU 21 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Release|Any CPU.Build.0 = Release|Any CPU 22 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Release|x86.ActiveCfg = Release|x86 23 | {909D494F-72FD-47B3-A5E8-B01650982BCC}.Release|x86.Build.0 = Release|x86 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {6D15E619-D5FB-48DB-9302-D0FCEDDDB06E} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /External-CSGO/CodeInjection/UTILS_GAME.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Diagnostics; 6 | using System.Linq; 7 | using System.Runtime.InteropServices; 8 | using System.Text; 9 | using System.Threading; 10 | 11 | namespace SimpleExternalCheatCSGO.CodeInjection 12 | { 13 | public static class UTILS_GAME 14 | { 15 | public static void AcceptMatch() 16 | { 17 | IntPtr Thread = WinAPI.CreateRemoteThread(Globals._csgo.ProcessHandle, (IntPtr)null, IntPtr.Zero, new IntPtr(Globals._signatures.dw_AcceptMatch), IntPtr.Zero, 0, (IntPtr)null); 18 | 19 | WinAPI.WaitForSingleObject(Thread, 0xFFFFFFFF); 20 | 21 | WinAPI.CloseHandle(Thread); 22 | } 23 | 24 | public static bool MatchFound() 25 | { 26 | IntPtr CLobbyScreen = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_CLobbyScreen); 27 | 28 | if (CLobbyScreen != IntPtr.Zero) 29 | { 30 | int iAccept = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, CLobbyScreen + Globals._signatures.dw_MatchAccepted); 31 | int iFound = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, CLobbyScreen + Globals._signatures.dw_MatchFound); 32 | 33 | return iAccept == 0 && iFound != 0; 34 | } 35 | else 36 | return false; 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /External-CSGO/Properties/AssemblyInfo.cs: -------------------------------------------------------------------------------- 1 | using System.Reflection; 2 | using System.Runtime.CompilerServices; 3 | using System.Runtime.InteropServices; 4 | 5 | // General Information about an assembly is controlled through the following 6 | // set of attributes. Change these attribute values to modify the information 7 | // associated with an assembly. 8 | [assembly: AssemblyTitle("SimpleExternalCheat")] 9 | [assembly: AssemblyDescription("")] 10 | [assembly: AssemblyConfiguration("")] 11 | [assembly: AssemblyCompany("SimpleExternalCheat")] 12 | [assembly: AssemblyProduct("SimpleExternalCheatl")] 13 | [assembly: AssemblyCopyright("Copyright © Microsoft 2017")] 14 | [assembly: AssemblyTrademark("")] 15 | [assembly: AssemblyCulture("")] 16 | 17 | // Setting ComVisible to false makes the types in this assembly not visible 18 | // to COM components. If you need to access a type in this assembly from 19 | // COM, set the ComVisible attribute to true on that type. 20 | [assembly: ComVisible(false)] 21 | 22 | // The following GUID is for the ID of the typelib if this project is exposed to COM 23 | [assembly: Guid("909d494f-72fd-47b3-a5e8-b01650982bcc")] 24 | 25 | // Version information for an assembly consists of the following four values: 26 | // 27 | // Major Version 28 | // Minor Version 29 | // Build Number 30 | // Revision 31 | // 32 | // You can specify all the values or you can default the Build and Revision Numbers 33 | // by using the '*' as shown below: 34 | // [assembly: AssemblyVersion("1.0.*")] 35 | [assembly: AssemblyVersion("1.0.0.0")] 36 | [assembly: AssemblyFileVersion("1.0.0.0")] 37 | -------------------------------------------------------------------------------- /External-CSGO/CodeInjection/RevealRank.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.CodeInjection 8 | { 9 | public static class RevealRank 10 | { 11 | public static byte[] Shellcode = { 12 | 0x68,0x78,0x56,0x34,0x12, 13 | 0xB8,0x78,0x56,0x34,0x12, 14 | 0xFF,0xD0, 15 | 0x83,0xC4,0x04, 16 | 0xC3, 17 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 18 | }; 19 | 20 | public static int Size = Shellcode.Length; 21 | public static IntPtr Address; 22 | 23 | public static void Do() 24 | { 25 | if (Address == IntPtr.Zero) 26 | { 27 | Alloc(); 28 | if (Address == IntPtr.Zero) 29 | return; 30 | Buffer.BlockCopy(BitConverter.GetBytes((int)Address + 16), 0, Shellcode, 1, 4); 31 | Buffer.BlockCopy(BitConverter.GetBytes(Globals._signatures.dw_RevealRankFn), 0, Shellcode, 6, 4); 32 | 33 | WinAPI.WriteProcessMemory(Globals._csgo.ProcessHandle, Address, Shellcode, Shellcode.Length, 0); 34 | } 35 | IntPtr Thread = WinAPI.CreateRemoteThread(Globals._csgo.ProcessHandle, (IntPtr)null, IntPtr.Zero, Address, IntPtr.Zero, 0, (IntPtr)null); 36 | 37 | WinAPI.WaitForSingleObject(Thread, 0xFFFFFFFF); 38 | 39 | WinAPI.CloseHandle(Thread); 40 | } 41 | 42 | public static void Alloc() 43 | { 44 | Address = Globals._alloc.SmartAlloc(Size); 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Entity/CLocalPlayer.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CLocalPlayer : CBasePlayer 11 | { 12 | public void Update() 13 | { 14 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_LocalPlayer); 15 | } 16 | 17 | public void ResetFov() 18 | { 19 | SetFov(GetDefaultFov()); 20 | } 21 | 22 | public int GetCrosshairID() 23 | { 24 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iCrosshairId); 25 | } 26 | 27 | public int GetFov() 28 | { 29 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iFOV); 30 | } 31 | 32 | public int GetDefaultFov() 33 | { 34 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iDefaultFOV); 35 | } 36 | 37 | public void SetFov(int iFov) 38 | { 39 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iFOV, iFov); 40 | } 41 | 42 | public Vector GetPunch() 43 | { 44 | return new Vector(MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_aimPunchAngle)); 45 | } 46 | 47 | public int GetShootsFired() 48 | { 49 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iShotsFired); 50 | } 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /External-CSGO/Structs/trace_t.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 10 | public struct cplane_t 11 | { 12 | struct_Vector normal; 13 | float dist; 14 | char type; 15 | char signbits; 16 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] 17 | char[] pad; 18 | }; 19 | 20 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 21 | public struct CBaseTrace 22 | { 23 | public struct_Vector startpos; 24 | public struct_Vector endpos; 25 | public cplane_t plane; 26 | public float fraction; 27 | public int contents; 28 | public ushort dispFlags; 29 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 30 | public bool allsolid; 31 | [MarshalAs(UnmanagedType.U1, SizeConst = 1)] 32 | public bool startsolid; 33 | }; 34 | 35 | [StructLayout(LayoutKind.Explicit)] 36 | public struct csurface_t 37 | { 38 | [FieldOffset(0x0)] 39 | public IntPtr name; 40 | [FieldOffset(0x4)] 41 | public short surfaceProps; 42 | [FieldOffset(0x6)] 43 | public ushort flags; 44 | }; 45 | 46 | [StructLayout(LayoutKind.Sequential, Pack = 1)] 47 | public struct trace_t 48 | { 49 | public CBaseTrace baseTrace; 50 | public float fractionleftsolid; 51 | public csurface_t surface; 52 | public int hitgroup; 53 | public short physicsbone; 54 | public ushort worldSurfaceIndex; 55 | public IntPtr m_pEnt; 56 | public int hitbox; 57 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x24)] 58 | public char[] shit; 59 | }; 60 | } 61 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Interfaces/CGlowObjectManager.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CGlowObjectManager 11 | { 12 | public IntPtr pThis; 13 | public void Update() 14 | { 15 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_GlowObjectManager); 16 | } 17 | public void RegisterGlowObject(IClientEntity pEntity, Color color, bool bInnerGlow, bool bFullRender = false) 18 | { 19 | RegisterGlowObject(pEntity.GetGlowIndex(), color.R, color.G, color.B, color.A, bInnerGlow, bFullRender); 20 | } 21 | 22 | public IClientEntity GetEntityByGlowIndex(int iGlowIndex) 23 | { 24 | GlowObjectDefinition_t glow = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + (iGlowIndex * 0x38)); 25 | return new IClientEntity(new IntPtr(glow.dwEntity)); 26 | } 27 | 28 | public int Size() 29 | { 30 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_GlowObjectManager + 0xC); 31 | } 32 | 33 | public void RegisterGlowObject(int iGlowIndex, float r, float g, float b, float a, bool bInnerGlow, bool bFullRender = false) 34 | { 35 | GlowObjectDefinition_t glow = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + (iGlowIndex * 0x38)); 36 | glow.fR = r / 255f; 37 | glow.fG = g / 255f; 38 | glow.fB = b / 255f; 39 | glow.fAlpha = a / 255f; 40 | glow.m_bInnerGlow = bInnerGlow; 41 | glow.bRenderWhenOccluded = true; 42 | glow.bRenderWhenUnoccluded = false; 43 | glow.bFullBloomRender = bFullRender; 44 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + (iGlowIndex * 0x38), glow); 45 | } 46 | 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /External-CSGO/Program.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.SDK; 3 | using SimpleExternalCheatCSGO.Structs; 4 | using SimpleExternalCheatCSGO.CodeInjection; 5 | using System; 6 | using System.Collections.Generic; 7 | using System.Diagnostics; 8 | using System.IO; 9 | using System.Security.Cryptography; 10 | using System.Linq; 11 | using System.Runtime.InteropServices; 12 | using System.Text; 13 | using System.Threading; 14 | using System.Windows.Forms; 15 | 16 | namespace SimpleExternalCheatCSGO 17 | { 18 | class Program 19 | { 20 | static void Main() 21 | { 22 | StartCheat(); 23 | } 24 | 25 | public static void StartCheat() 26 | { 27 | Stopwatch netvar_Watch = new Stopwatch(); 28 | 29 | Stopwatch cheat_Watch = new Stopwatch(); 30 | 31 | Stopwatch signatures_Watch = new Stopwatch(); 32 | 33 | cheat_Watch.Start(); 34 | 35 | Console.WriteLine("[Version 0.1] - Build Time " + new FileInfo(Application.ExecutablePath).LastWriteTime.ToString("yyyy-MM-dd - HH:mm:ss")); 36 | 37 | Console.WriteLine("Loading csgo process..."); 38 | 39 | if (!Globals._csgo.LoadCSGO()) 40 | { 41 | Console.WriteLine("Failed to load csgo process!"); 42 | Environment.Exit(0); 43 | } 44 | 45 | Globals._csgo.DumpInfo(); 46 | 47 | Console.WriteLine("Scanning netvars..."); 48 | 49 | netvar_Watch.Start(); 50 | 51 | Globals._netvar.Init(); 52 | 53 | netvar_Watch.Stop(); 54 | 55 | Console.WriteLine("NetVar scan completed in " + netvar_Watch.Elapsed.ToString("ss\\.ff") + "s"); 56 | 57 | Console.WriteLine("Scanning patterns..."); 58 | 59 | signatures_Watch.Start(); 60 | 61 | Globals._signatures.Init(); 62 | 63 | signatures_Watch.Stop(); 64 | 65 | Console.WriteLine("Signatures scan completed in " + signatures_Watch.Elapsed.ToString("ss\\.ff") + "s"); 66 | 67 | cheat_Watch.Stop(); 68 | 69 | Console.WriteLine("Cheat loaded in " + cheat_Watch.Elapsed.ToString("ss\\.ff") + "s"); 70 | 71 | MainThread.Start(); 72 | } 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Misc/CConVarManager.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CConVarManager 11 | { 12 | public IntPtr pThis; 13 | public CharCodes codes; 14 | public CConVarManager() 15 | { 16 | codes = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["vstdlib"].BaseAddress + Globals._signatures.dw_Convarchartable); 17 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["vstdlib"].BaseAddress + Globals._signatures.dw_enginecvar); 18 | } 19 | 20 | public IntPtr GetConVarAddress(string name) 21 | { 22 | var hash = GetStringHash(name); 23 | 24 | IntPtr Pointer = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x34) + ((byte)hash * 4)); 25 | while (Pointer != IntPtr.Zero) 26 | { 27 | if (MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Pointer) == hash) 28 | { 29 | IntPtr ConVarPointer = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Pointer + 0x4); 30 | 31 | if (MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, ConVarPointer + 0xC), -1) == name) 32 | return ConVarPointer; 33 | } 34 | Pointer = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Pointer + 0xC); 35 | } 36 | return IntPtr.Zero; 37 | } 38 | 39 | 40 | public int GetStringHash(string name) 41 | { 42 | int v2 = 0; 43 | int v3 = 0; 44 | for (int i = 0; i < name.Length; i += 2) 45 | { 46 | v3 = codes.tab[v2 ^ char.ToUpper(name[i])]; 47 | if (i + 1 == name.Length) 48 | break; 49 | v2 = codes.tab[v3 ^ char.ToUpper(name[i + 1])]; 50 | } 51 | return v2 | (v3 << 8); 52 | } 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /External-CSGO/CodeInjection/SendClantag.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.CodeInjection 8 | { 9 | public static class SendClantag 10 | { 11 | public static byte[] Shellcode = { 12 | 0xBA,0x67,0x45,0x23,0x01, 13 | 0xB9,0x67,0x45,0x23,0x01, 14 | 0xB8,0x67,0x45,0x23,0x01, 15 | 0xFF,0xD0, 16 | 0xC3, 17 | 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, 18 | 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12 19 | }; 20 | 21 | public static int Size = Shellcode.Length; 22 | public static IntPtr Address; 23 | 24 | public static void Do(string tag, string name) 25 | { 26 | if (Address == IntPtr.Zero) 27 | { 28 | Alloc(); 29 | if (Address == IntPtr.Zero) 30 | return; 31 | 32 | int tag_addr = (int)Address + 18; 33 | 34 | int name_addr = tag_addr + 16; 35 | 36 | Buffer.BlockCopy(BitConverter.GetBytes(name_addr), 0, Shellcode, 1, 4); 37 | Buffer.BlockCopy(BitConverter.GetBytes(tag_addr), 0, Shellcode, 6, 4); 38 | Buffer.BlockCopy(BitConverter.GetBytes(Globals._signatures.dw_ChangeClanTag), 0, Shellcode, 11, 4); 39 | } 40 | 41 | var tag_bytes = Encoding.UTF8.GetBytes(tag + "\0"); 42 | var name_bytes = Encoding.UTF8.GetBytes(name + "\0"); 43 | 44 | Buffer.BlockCopy(tag_bytes, 0, Shellcode, 18, tag_bytes.Length); 45 | Buffer.BlockCopy(name_bytes, 0, Shellcode, 34, name_bytes.Length); 46 | 47 | WinAPI.WriteProcessMemory(Globals._csgo.ProcessHandle, Address, Shellcode, Shellcode.Length, 0); 48 | 49 | IntPtr Thread = WinAPI.CreateRemoteThread(Globals._csgo.ProcessHandle, (IntPtr)null, IntPtr.Zero, Address, (IntPtr)null, 0, (IntPtr)null); 50 | 51 | WinAPI.WaitForSingleObject(Thread, 0xFFFFFFFF); 52 | 53 | WinAPI.CloseHandle(Thread); 54 | } 55 | 56 | public static void Alloc() 57 | { 58 | Address = Globals._alloc.SmartAlloc(Size); 59 | } 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Misc/CCHitboxManager.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | //https://www.unknowncheats.me/forum/counterstrike-global-offensive/158860-external-hitbox-manager-dymanically.html 11 | public static class CCHitboxManager 12 | { 13 | public static Dictionary> m_ModelHitboxes = new Dictionary>(); 14 | 15 | public static mstudiobbox_t GetHitBox(IClientEntity pEntity, string szModelName, int iIndex) 16 | { 17 | if (m_ModelHitboxes.ContainsKey(szModelName)) 18 | if (m_ModelHitboxes[szModelName].ContainsKey(iIndex)) 19 | return m_ModelHitboxes[szModelName][iIndex]; 20 | else 21 | return default(mstudiobbox_t); 22 | 23 | IntPtr pStudioHdr = pEntity.GetStudioHdr(); 24 | 25 | if (pStudioHdr == IntPtr.Zero) 26 | return default(mstudiobbox_t); 27 | 28 | int hitbox_set_index = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pStudioHdr + 0xB0); 29 | 30 | int studio_hitbox_set = (int)pStudioHdr + hitbox_set_index; 31 | 32 | int num_hitboxes = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, new IntPtr(studio_hitbox_set + 0x4)); 33 | 34 | int hitbox_index = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, new IntPtr(studio_hitbox_set + 0x8)); 35 | 36 | m_ModelHitboxes.Add(szModelName, new Dictionary()); 37 | 38 | for (int i = 0; i < num_hitboxes; ++i) 39 | { 40 | mstudiobbox_t model_hitbox = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, new IntPtr((0x44 * i) + hitbox_index + studio_hitbox_set)); 41 | float radius = model_hitbox.m_flRadius; 42 | if (radius != -1f) 43 | { 44 | model_hitbox.bbmin.x -= radius; 45 | model_hitbox.bbmin.y -= radius; 46 | model_hitbox.bbmin.z -= radius; 47 | 48 | model_hitbox.bbmin.x += radius; 49 | model_hitbox.bbmin.y += radius; 50 | model_hitbox.bbmin.z += radius; 51 | } 52 | m_ModelHitboxes[szModelName].Add(i, model_hitbox); 53 | } 54 | 55 | if (m_ModelHitboxes[szModelName].ContainsKey(iIndex)) 56 | return m_ModelHitboxes[szModelName][iIndex]; 57 | else 58 | return default(mstudiobbox_t); 59 | } 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /External-CSGO/Memory/PatternScanner.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Runtime.InteropServices; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.Memory 9 | { 10 | public static class PatternScanner 11 | { 12 | public static int FindPattern(IntPtr _handle, string pattern_str, GameModule module, bool sub, int offset = 0, bool read = false, int startAddress = 0) 13 | { 14 | var returnvalue = FindPatternEx(_handle, pattern_str, module, sub, offset, read, startAddress); 15 | GC.Collect(); 16 | return returnvalue; 17 | } 18 | 19 | public static int FindPatternEx(IntPtr _handle, string pattern_str, GameModule module, bool sub, int offset = 0, bool read = false, int startAddress = 0) 20 | { 21 | List temp = new List(); 22 | string mask = ""; 23 | foreach (string l in pattern_str.Split(' ')) 24 | { 25 | if (l == "?" || l == "00") 26 | { 27 | temp.Add(0x00); 28 | mask += "?"; 29 | } 30 | else 31 | { 32 | temp.Add((byte)int.Parse(l, System.Globalization.NumberStyles.HexNumber)); 33 | mask += "x"; 34 | } 35 | } 36 | byte[] pattern = temp.ToArray(); 37 | 38 | int moduleSize = module.Size; 39 | 40 | IntPtr moduleBase = module.BaseAddress; 41 | 42 | if (startAddress != 0) 43 | { 44 | moduleSize = ((int)moduleBase + moduleSize) - startAddress; 45 | moduleBase = new IntPtr(startAddress); 46 | } 47 | if (moduleSize == 0) 48 | throw new Exception($"Size of module {module} is INVALID."); 49 | 50 | byte[] moduleBytes = new byte[moduleSize]; 51 | int numBytes; 52 | 53 | if (WinAPI.ReadProcessMemory(_handle, moduleBase, moduleBytes, moduleSize, out numBytes)) 54 | { 55 | for (int i = 0; i < moduleSize; i++) 56 | { 57 | bool found = true; 58 | 59 | for (int l = 0; l < mask.Length; l++) 60 | { 61 | found = mask[l] == '?' || moduleBytes[l + i] == pattern[l]; 62 | 63 | if (!found) 64 | break; 65 | } 66 | 67 | if (found) 68 | { 69 | i += (int)moduleBase; 70 | if (read) 71 | i = MemoryAPI.ReadFromProcess(_handle, new IntPtr(i + offset)); 72 | if (sub) 73 | i -= (int)moduleBase; 74 | return i; 75 | } 76 | 77 | } 78 | } 79 | return 0; 80 | } 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /External-CSGO/Util/MathUtil.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.SDK; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.Util 9 | { 10 | public static class MathUtil 11 | { 12 | public static float DotProduct(Vector a, Vector b) 13 | { 14 | return (a._x * b._x + a._y * b._y + a._z * b._z); 15 | } 16 | 17 | public static Vector VectorTransform(Vector in1, matrix3x4 in2) 18 | { 19 | Vector vecOut = new Vector(0, 0, 0); 20 | vecOut._x = DotProduct(in1, new Vector(in2.first[0].second[0], in2.first[0].second[1], in2.first[0].second[2])) + in2.first[0].second[3]; 21 | vecOut._y = DotProduct(in1, new Vector(in2.first[1].second[0], in2.first[1].second[1], in2.first[1].second[2])) + in2.first[1].second[3]; 22 | vecOut._z = DotProduct(in1, new Vector(in2.first[2].second[0], in2.first[2].second[1], in2.first[2].second[2])) + in2.first[2].second[3]; 23 | return vecOut; 24 | } 25 | 26 | public static double DegreeToRadian(float angle) 27 | { 28 | return Math.PI * angle / 180.0; 29 | } 30 | 31 | public static Vector CalcAngle(Vector src, Vector dst) 32 | { 33 | Vector delta = new Vector((src._x - dst._x), (src._y - dst._y), (src._z - dst._z)); 34 | double hyp = Math.Sqrt(delta._x * delta._x + delta._y * delta._y); 35 | Vector angles = new Vector(0, 0, 0); 36 | angles._x = (float)(Math.Atan(delta._z / hyp) * 57.295779513082f); 37 | angles._y = (float)(Math.Atan(delta._y / delta._x) * 57.295779513082f); 38 | angles._z = 0.0f; 39 | if (delta._x >= 0.0) 40 | angles._y += 180.0f; 41 | return angles; 42 | } 43 | 44 | public static Vector AngleVectors(Vector angles) 45 | { 46 | float sp, sy, cp, cy; 47 | 48 | sy = (float)Math.Sin(DegreeToRadian(angles._y)); 49 | cy = (float)Math.Cos(DegreeToRadian(angles._y)); 50 | 51 | sp = (float)Math.Sin(DegreeToRadian(angles._x)); 52 | cp = (float)Math.Cos(DegreeToRadian(angles._x)); 53 | 54 | return new Vector(cp * cy, cp * sy, -sp); 55 | } 56 | 57 | public const float MaxDegrees = 180.0f; 58 | 59 | public static float FovToPlayer(Vector ViewOffSet, Vector View, CBasePlayer pEntity, int aHitBox) 60 | { 61 | Vector Angles = View; 62 | Vector Origin = ViewOffSet; 63 | 64 | Vector Delta = new Vector(0, 0, 0); 65 | Vector Forward = new Vector(0, 0, 0); 66 | 67 | Forward = AngleVectors(Angles); 68 | 69 | Vector AimPos = pEntity.GetHitboxPosition(aHitBox); 70 | 71 | Delta = AimPos - Origin; 72 | 73 | Delta.Normalize(); 74 | 75 | float Dot = DotProduct(Forward, Delta); 76 | return (float)(Math.Acos(Dot) * (MaxDegrees / Math.PI)); 77 | } 78 | 79 | 80 | } 81 | } 82 | -------------------------------------------------------------------------------- /External-CSGO/API/MemoryAPI.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.API 8 | { 9 | public static class MemoryAPI 10 | { 11 | public static byte[] ReadMemory(IntPtr handle, IntPtr adress, int size) 12 | { 13 | byte[] data = new byte[size]; 14 | int bytesRead = 0; 15 | WinAPI.ReadProcessMemory(handle, adress, data, data.Length, out bytesRead); 16 | if (bytesRead == 0) 17 | return BitConverter.GetBytes(0); 18 | return data; 19 | } 20 | 21 | public static void WriteToProcess(IntPtr _handle, IntPtr address, T str) 22 | { 23 | int size = 1; 24 | if (typeof(T) != typeof(bool)) 25 | size = Marshal.SizeOf(typeof(T)); 26 | byte[] arr = new byte[size]; 27 | 28 | IntPtr ptr = Marshal.AllocHGlobal(size); 29 | Marshal.StructureToPtr(str, ptr, true); 30 | Marshal.Copy(ptr, arr, 0, size); 31 | Marshal.FreeHGlobal(ptr); 32 | WinAPI.WriteProcessMemory(_handle, address, arr, arr.Length, 0); 33 | } 34 | 35 | 36 | public static byte[] GetStructBytes(T str) 37 | { 38 | int size = Marshal.SizeOf(typeof(T)); 39 | byte[] arr = new byte[size]; 40 | 41 | IntPtr ptr = Marshal.AllocHGlobal(size); 42 | Marshal.StructureToPtr(str, ptr, true); 43 | Marshal.Copy(ptr, arr, 0, size); 44 | Marshal.FreeHGlobal(ptr); 45 | 46 | return arr; 47 | } 48 | 49 | public static T ReadFromProcess(IntPtr _handle, IntPtr address) 50 | { 51 | int size = 1; 52 | if (typeof(T) != typeof(bool)) 53 | size = Marshal.SizeOf(typeof(T)); 54 | byte[] data = ReadMemory(_handle, address, size); 55 | GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned); 56 | T stuff = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T)); 57 | handle.Free(); 58 | return stuff; 59 | } 60 | public static string ReadTextFromProcess(IntPtr _handle, IntPtr address, int size) 61 | { 62 | byte[] data; 63 | if (size != -1) 64 | data = ReadMemory(_handle, address, size); 65 | else 66 | { 67 | List name = new List(); 68 | int offset = 0; 69 | byte curbyte = 0x00; 70 | do 71 | { 72 | curbyte = ReadMemory(_handle, address + offset, 1)[0]; 73 | name.Add(curbyte); 74 | ++offset; 75 | } while (curbyte != 0x00); 76 | size = offset; 77 | data = name.ToArray(); 78 | } 79 | Encoding encoding = Encoding.Default; 80 | string result = encoding.GetString(data, 0, (int)size); 81 | result = result.Substring(0, result.IndexOf('\0')); 82 | return result; 83 | 84 | } 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Entity/IClientEntity.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class IClientEntity 11 | { 12 | public IntPtr pThis; 13 | public IClientEntity() { } 14 | public IClientEntity(IntPtr pEntity) 15 | { 16 | pThis = pEntity; 17 | } 18 | 19 | public string GetNetworkName() 20 | { 21 | IntPtr vTables = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x8); 22 | IntPtr vFunction = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, vTables + 0x8); 23 | IntPtr vClass = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, vFunction + 0x1); 24 | return MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, vClass + 0x8),-1); 25 | } 26 | 27 | public CSGOClassID GetClassID() 28 | { 29 | IntPtr vTables = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + 0x8); 30 | IntPtr vFunction = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, vTables + 0x8); 31 | IntPtr vClass = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, vFunction + 0x1); 32 | return (CSGOClassID)MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, vClass + 0x14); 33 | } 34 | 35 | public Vector GetOrigin() 36 | { 37 | return new Vector(MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_vecOrigin)); 38 | } 39 | 40 | public int GetIndex() 41 | { 42 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iIndex); 43 | } 44 | 45 | public string GetModelName() 46 | { 47 | return MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, GetModel() + 0x4, 128); 48 | } 49 | 50 | public IntPtr GetModel() 51 | { 52 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_Model); 53 | } 54 | 55 | public IntPtr GetStudioHdr() 56 | { 57 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.m_pStudioHdr)); 58 | } 59 | 60 | public int GetGlowIndex() 61 | { 62 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iGlowIndex); 63 | } 64 | 65 | public bool IsDormant() 66 | { 67 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_bDormant); 68 | } 69 | 70 | public override bool Equals(System.Object obj) 71 | { 72 | var pEntity = obj as IClientEntity; 73 | 74 | return pEntity == null ? false : pEntity.pThis == this.pThis; 75 | } 76 | 77 | public override int GetHashCode() 78 | { 79 | return (int)pThis; 80 | } 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /External-CSGO/CodeInjection/LineGoesThroughSmoke.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.CodeInjection 9 | { 10 | //https://www.unknowncheats.me/forum/counterstrike-global-offensive/194139-external-linegoesthroughsmoke.html 11 | public static class LineGoesThroughSmoke 12 | { 13 | public static byte[] Shellcode = { 14 | 0x55, 15 | 0x8B, 0xEC, 16 | 0x83, 0xEC, 0x0C, 17 | 0x89, 0xE0, 18 | 0x8B, 0x0D, 0x12, 0x34, 0x56, 0x78, 19 | 0x89, 0x08, 20 | 0x8B, 0x15, 0x12, 0x34, 0x56, 0x78, 21 | 0x89, 0x50, 0x04, 22 | 0x8B, 0x0D, 0x12, 0x34, 0x56, 0x78, 23 | 0x89, 0x48, 0x08, 24 | 0x83, 0xEC, 0x0C, 25 | 0x89, 0xE2, 26 | 0xA1, 0x12, 0x34, 0x56, 0x78, 27 | 0x89, 0x02, 28 | 0x8B, 0x0D, 0x12, 0x34, 0x56, 0x78, 29 | 0x89, 0x4A, 0x04, 30 | 0xA1, 0x12, 0x34, 0x56, 0x78, 31 | 0x89, 0x42, 0x08, 32 | 0xB8, 0x12, 0x34, 0x56, 0x78, 33 | 0xFF, 0xD0, 34 | 0xA3, 0x12, 0x34, 0x56, 0x78, 35 | 0x83, 0xC4, 0x18, 36 | 0xC9, 37 | 0xC3, 38 | 0x12,0x34,0x56,0x78,0x12,0x34,0x56,0x78,0x12,0x34,0x56,0x78, 39 | 0x12,0x34,0x56,0x78,0x12,0x34,0x56,0x78,0x12,0x34,0x56,0x78, 40 | 0x12 41 | }; 42 | 43 | public static int Size = Shellcode.Length; 44 | public static IntPtr Address; 45 | public static IntPtr ReturnAddress; 46 | 47 | public static bool Do(Vector start, Vector end) 48 | { 49 | if (Address == IntPtr.Zero) 50 | { 51 | Alloc(); 52 | if (Address == IntPtr.Zero) 53 | return false; 54 | int param_startAddr = (int)Address + 80; 55 | int param_endAddr = param_startAddr + 12; 56 | int returnAddr = param_endAddr + 12; 57 | 58 | ReturnAddress = new IntPtr(returnAddr); 59 | 60 | int param_end_y = param_endAddr + 4; 61 | int param_end_z = param_endAddr + 8; 62 | 63 | int param_start_y = param_startAddr + 4; 64 | int param_start_z = param_startAddr + 8; 65 | 66 | Buffer.BlockCopy(BitConverter.GetBytes(param_endAddr), 0, Shellcode, 0xA, 4); 67 | Buffer.BlockCopy(BitConverter.GetBytes(param_end_y), 0, Shellcode, 0x12, 4); 68 | Buffer.BlockCopy(BitConverter.GetBytes(param_end_z), 0, Shellcode, 0x1B, 4); 69 | Buffer.BlockCopy(BitConverter.GetBytes(param_startAddr), 0, Shellcode, 0x28, 4); 70 | Buffer.BlockCopy(BitConverter.GetBytes(param_start_y), 0, Shellcode, 0x30, 4); 71 | Buffer.BlockCopy(BitConverter.GetBytes(param_start_z), 0, Shellcode, 0x38, 4); 72 | Buffer.BlockCopy(BitConverter.GetBytes(Globals._signatures.dw_lineThroughSmoke), 0, Shellcode, 0x40, 4); 73 | Buffer.BlockCopy(BitConverter.GetBytes(returnAddr), 0, Shellcode, 0x47, 4); 74 | } 75 | 76 | Buffer.BlockCopy(MemoryAPI.GetStructBytes(start.ToStruct()), 0, Shellcode, 0x50, 12); 77 | Buffer.BlockCopy(MemoryAPI.GetStructBytes(end.ToStruct()), 0, Shellcode, 0x5C, 12); 78 | 79 | WinAPI.WriteProcessMemory(Globals._csgo.ProcessHandle, Address, Shellcode, Shellcode.Length, 0); 80 | 81 | IntPtr Thread = WinAPI.CreateRemoteThread(Globals._csgo.ProcessHandle, (IntPtr)null, IntPtr.Zero, Address, (IntPtr)null, 0, (IntPtr)null); 82 | 83 | WinAPI.WaitForSingleObject(Thread, 0xFFFFFFFF); 84 | 85 | WinAPI.CloseHandle(Thread); 86 | 87 | bool returnVal = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, ReturnAddress); 88 | 89 | return returnVal; 90 | } 91 | 92 | public static void Alloc() 93 | { 94 | Address = Globals._alloc.SmartAlloc(Size); 95 | } 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /External-CSGO/Structs/Vector.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.Structs 8 | { 9 | [StructLayout(LayoutKind.Explicit)] 10 | public struct struct_Vector 11 | { 12 | [FieldOffset(0x0)] 13 | public float x; 14 | [FieldOffset(0x4)] 15 | public float y; 16 | [FieldOffset(0x8)] 17 | public float z; 18 | 19 | public override string ToString() 20 | { 21 | return string.Format("{0} {1} {2}", x, y, z); 22 | } 23 | } 24 | 25 | public class Vector 26 | { 27 | #region Variables 28 | public float _x; 29 | public float _y; 30 | public float _z; 31 | #endregion 32 | #region Constructors 33 | public Vector(struct_Vector vec) 34 | { 35 | _x = vec.x; 36 | _y = vec.y; 37 | _z = vec.z; 38 | } 39 | public Vector(float x, float y, float z) 40 | { 41 | _x = x; 42 | _y = y; 43 | _z = z; 44 | } 45 | public Vector(float x, float y) 46 | { 47 | _x = x; 48 | _y = y; 49 | _z = 0f; 50 | } 51 | public Vector(Vector vec) 52 | { 53 | _x = vec._x; 54 | _y = vec._y; 55 | _z = vec._z; 56 | } 57 | #endregion 58 | #region Operators 59 | public static Vector operator +(Vector _vec1, Vector _vec2) 60 | { 61 | return new Vector(_vec2._x + _vec1._x, _vec2._y + _vec1._y, _vec2._z + _vec1._z); 62 | } 63 | public static Vector operator -(Vector _vec1, Vector _vec2) 64 | { 65 | return new Vector(_vec1._x - _vec2._x, _vec1._y - _vec2._y, _vec1._z - _vec2._z); 66 | } 67 | public static Vector operator *(Vector _vec1, float _f) 68 | { 69 | return new Vector(_vec1._x * _f, _vec1._y * _f, _vec1._z * _f); 70 | } 71 | public static Vector operator /(Vector _vec1, float _f) 72 | { 73 | return new Vector(_vec1._x / _f, _vec1._y / _f, _vec1._z / _f); 74 | } 75 | #endregion 76 | #region Functions 77 | public double Lenght2D() 78 | { 79 | return Math.Sqrt(_x * _x + _y * _y); 80 | } 81 | public double Lenght() 82 | { 83 | return Math.Sqrt(_x * _x + _y * _y + _z * _z); 84 | } 85 | public double DistanceTo(Vector _to) 86 | { 87 | return (this - _to).Lenght(); 88 | } 89 | public void Normalize() 90 | { 91 | float flLen = (float)this.Lenght(); 92 | if (flLen == 0) 93 | { 94 | this._x = 0; 95 | this._y = 0; 96 | this._z = 1; 97 | return; 98 | } 99 | flLen = 1 / flLen; 100 | this._x *= flLen; 101 | this._y *= flLen; 102 | this._z *= flLen; 103 | } 104 | public void NormalizeAngles() 105 | { 106 | if (this._x > 89) 107 | this._x = 89; 108 | if (this._x < -89) 109 | this._x = -89; 110 | 111 | while (_y > 180.0f) 112 | _y -= 360.0f; 113 | while (_y < -180.0f) 114 | _y += 360.0f; 115 | 116 | if (this._y > 180) 117 | this._y = 180; 118 | if (this._y < -180) 119 | this._y = -180; 120 | 121 | } 122 | public override string ToString() 123 | { 124 | return string.Format("{0} {1} {2}", _x, _y, _z); 125 | } 126 | 127 | public struct_Vector ToStruct() 128 | { 129 | struct_Vector src = default(struct_Vector); 130 | src.x = this._x; 131 | src.y = this._y; 132 | src.z = this._z; 133 | return src; 134 | } 135 | 136 | #endregion 137 | } 138 | } 139 | -------------------------------------------------------------------------------- /External-CSGO/Settings/Config.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.Structs; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Globalization; 5 | using System.IO; 6 | using System.Linq; 7 | using System.Text; 8 | using System.Windows.Forms; 9 | 10 | namespace SimpleExternalCheatCSGO.Settings 11 | { 12 | public enum GlowType 13 | { 14 | Color = 0, 15 | Vis_Color, 16 | Health, 17 | }; 18 | 19 | public enum BoneSelector 20 | { 21 | Head = (1 << 0), 22 | Neck = (1 << 1), 23 | Chest = (1 << 2), 24 | Stomach = (1 << 3) 25 | }; 26 | 27 | public class WeaponConfig 28 | { 29 | #region TriggerBOT 30 | public bool bTriggerBotEnabled = true; 31 | public bool bFriendlyFire = false; 32 | public int iDelay = 1; 33 | public int iPause = 1; 34 | #endregion 35 | #region AimBot 36 | public bool bAimbotEnabled = true; 37 | public bool bVisibleCheck = true; 38 | public bool bTargetOnGroundCheck = true; 39 | public int iAimbotDeathBreak = 350; 40 | public float flAimbotFov = 12f; 41 | public float flAimbotSmooth = 15f; 42 | #endregion 43 | #region RecoilControlSystem 44 | public int iBones = (int)BoneSelector.Head | (int)BoneSelector.Neck; 45 | public float Vertical = 9f; 46 | public float Horizontal = 9f; 47 | public bool bRCS = true; 48 | #endregion 49 | } 50 | 51 | public static class Config 52 | { 53 | #region WeaponConfig 54 | public static Dictionary WeaponsConfig = new Dictionary(); 55 | 56 | public static WeaponConfig GetWeaponConfig(int weapon_id) 57 | { 58 | if (WeaponsConfig.Count <= 0) 59 | { 60 | var weaponconfig = new WeaponConfig(); 61 | WeaponsConfig.Add(0, weaponconfig); 62 | } 63 | if (WeaponsConfig.ContainsKey(weapon_id)) 64 | return WeaponsConfig[weapon_id]; 65 | return WeaponsConfig[0]; 66 | } 67 | #endregion 68 | 69 | #region GlobalsConfig 70 | public static bool AimbotEnabled = true; 71 | public static bool TriggerBotEnabled = true; 72 | public static bool MiscEnabled = true; 73 | public static bool ESPEnabled = true; 74 | public static bool AutoPistol = true; 75 | public static int iAimbotKey = 1; 76 | public static int iTriggerBotKey = 6; 77 | public static int iTriggerBotWorkWithAimKey = 5; 78 | public static int iPanicKey = 0x79; 79 | #endregion 80 | 81 | #region GlowESP 82 | public static bool bRadarEnabled = false; 83 | public static bool bGlowEnabled = true; 84 | public static bool bGlowEnemy = true; 85 | public static bool bGlowAlly = true; 86 | public static bool bInnerGlow = false; 87 | public static bool bFullRender = false; 88 | public static bool bGlowAfterDeath = false; 89 | public static bool bGlowWeapons = false; 90 | public static bool bGlowBomb = false; 91 | public static bool bCHAMSGOWNOPlayer = false; 92 | public static GlowType iGlowType = GlowType.Color; 93 | public static int iGlowToogleKey = -1; 94 | public static Color bGlowEnemyColor = new Color(200, 0, 0, 200); 95 | public static Color bGlowEnemyVisibleColor = new Color(255, 0, 65, 150); 96 | public static Color bGlowAllyColor = new Color(200, 200, 0, 200); 97 | public static Color bGlowAllyVisibleColor = new Color(0, 169, 251, 150); 98 | 99 | public static Color bChamsEnemyColor = new Color(255, 169, 0, 200); 100 | public static Color bChamsAllyColor = new Color(0, 255, 50, 200); 101 | #endregion 102 | 103 | #region BunnyHOP 104 | public static bool bBunnyHopEnabled = true; 105 | public static int iBunnyHopKey = 32; 106 | #endregion 107 | 108 | #region AutoAccept&ShowRanks 109 | public static bool bAutoAccept = false; 110 | public static bool bShowRanks = true; 111 | #endregion 112 | 113 | #region Fakelag 114 | public static bool bFakeLag = false; 115 | public static int iFakeLagPower = 4; 116 | #endregion 117 | 118 | #region FovChanger 119 | public static bool bFovChangerEnabled = false; 120 | public static int FovValue = 100; 121 | #endregion 122 | 123 | #region Namestealer 124 | public static bool bNameStealerEnabled = false; 125 | public static int iNameStealerMode = 0; 126 | public static int iNameStealerType = 0; 127 | public static bool bNameStealerCustom = false; 128 | public static int iNameStealerDelay = 250; 129 | 130 | public static string szName1 = "---SimpleExternalCheat"; 131 | public static string szName2 = "SimpleExternalCheat---"; 132 | #endregion 133 | 134 | #region ClantagChanger 135 | public static bool bClanTagChangerEnabled = false; 136 | public static int iClanTagChanger = 0; 137 | public static string szClanTag1 = "---SimpleExternalCheat"; 138 | public static string szClanTag2 = "SimpleExternalCheat---"; 139 | public static int iClantTagDelay = 250; 140 | #endregion 141 | } 142 | } 143 | -------------------------------------------------------------------------------- /External-CSGO/API/WinAPI.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Runtime.InteropServices; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.API 8 | { 9 | public static class WinAPI 10 | { 11 | 12 | [DllImport("ntdll.dll", SetLastError = true)] 13 | public static extern IntPtr RtlAdjustPrivilege(int Privilege, bool bEnablePrivilege, 14 | bool IsThreadPrivilege, out bool PreviousValue); 15 | 16 | [DllImport("kernel32.dll")] 17 | public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId); 18 | 19 | [DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)] 20 | public static extern IntPtr GetProcAddress(IntPtr hModule, string procName); 21 | 22 | [DllImport("kernel32.dll", CharSet = CharSet.Auto)] 23 | public static extern IntPtr GetModuleHandle(string lpModuleName); 24 | 25 | [StructLayout(LayoutKind.Sequential)] 26 | public struct CLIENT_ID 27 | { 28 | public IntPtr UniqueProcess; 29 | public IntPtr UniqueThread; 30 | } 31 | 32 | [StructLayout(LayoutKind.Sequential)] 33 | public struct THREAD_BASIC_INFORMATION 34 | { 35 | public int ExitStatus; 36 | public IntPtr TebBaseAdress; 37 | public CLIENT_ID ClientId; 38 | public IntPtr AffinityMask; 39 | public int Priority; 40 | public int BasePriority; 41 | } 42 | 43 | [DllImport("ntdll.dll", SetLastError = true)] 44 | public static extern int NtQueryInformationThread(IntPtr threadHandle, ThreadInfoClass threadInformationClass, ref THREAD_BASIC_INFORMATION threadInformation, int threadInformationLength, IntPtr returnLengthPtr); 45 | 46 | 47 | [DllImport("kernel32.dll")] 48 | public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, int nSize, uint flNewProtect, out uint lpflOldProtect); 49 | 50 | public enum Protection : uint 51 | { 52 | PAGE_NOACCESS = 0x01, 53 | PAGE_READONLY = 0x02, 54 | PAGE_READWRITE = 0x04, 55 | PAGE_WRITECOPY = 0x08, 56 | PAGE_EXECUTE = 0x10, 57 | PAGE_EXECUTE_READ = 0x20, 58 | PAGE_EXECUTE_READWRITE = 0x40, 59 | PAGE_EXECUTE_WRITECOPY = 0x80, 60 | PAGE_GUARD = 0x100, 61 | PAGE_NOCACHE = 0x200, 62 | PAGE_WRITECOMBINE = 0x400 63 | } 64 | public enum ThreadInfoClass : int 65 | { 66 | ThreadBasicInformation = 0, 67 | ThreadQuerySetWin32StartAddress = 9 68 | } 69 | 70 | [DllImport("kernel32.dll")] 71 | public static extern bool CloseHandle(IntPtr hObject); 72 | 73 | [DllImport("kernel32.dll", SetLastError = true)] 74 | public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, int dwSize, out int lpNumberOfBytesRead); 75 | 76 | [DllImport("kernel32.dll")] 77 | public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] buffer, int size, int lpNumberOfBytesWritten); 78 | 79 | [DllImport("kernel32.dll")] 80 | public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect); 81 | 82 | [DllImport("kernel32.dll", SetLastError = true)] 83 | public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttribute, IntPtr dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId); 84 | 85 | [DllImport("kernel32.dll")] 86 | public static extern void WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds); 87 | 88 | [DllImport("kernel32.dll")] 89 | public static extern bool TerminateThread(IntPtr hHandle, uint dwExitCode); 90 | 91 | [DllImport("kernel32.dll")] 92 | public static extern bool SetThreadPriority(IntPtr hHandle, int nPriority); 93 | 94 | [DllImport("kernel32.dll")] 95 | public static extern IntPtr OpenThread(int dwDesiredAccess, bool bInheritHandle, int dwThreadId); 96 | 97 | [DllImport("kernel32.dll")] 98 | public static extern int GetThreadId(IntPtr hHandle); 99 | 100 | [DllImport("ntdll.dll")] 101 | public static extern int RtlRemoteCall(IntPtr Process, IntPtr Thread, IntPtr CallSite, long ArgumentCount, uint Arguments, bool PassContext, bool AlreadySuspended); 102 | 103 | [DllImport("kernel32.dll")] 104 | public static extern int SuspendThread(IntPtr hHandle); 105 | 106 | [DllImport("kernel32.dll")] 107 | public static extern int ResumeThread(IntPtr handle); 108 | 109 | [DllImport("kernel32.dll")] 110 | public static extern bool GetThreadContext(IntPtr hHandle, [Out] int[] context); 111 | 112 | [DllImport("kernel32.dll")] 113 | public static extern bool SetThreadContext(IntPtr thread, [In] int[] context); 114 | 115 | [DllImport("user32.dll")] 116 | public static extern short GetAsyncKeyState(int vKey); 117 | 118 | [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)] 119 | public static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, int dwSize, uint dwFreeType); 120 | 121 | public const int 122 | MEM_COMMIT = 0x1000, 123 | MEM_RELEASE = 0x800, 124 | MEM_RESERVE = 0x2000; 125 | 126 | public const int 127 | PAGE_READWRITE = 0x40, 128 | PROCESS_VM_OPERATION = 0x0008, 129 | PROCESS_VM_READ = 0x0010, 130 | PROCESS_VM_WRITE = 0x0020; 131 | } 132 | } 133 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Entity/CBasePlayer.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using SimpleExternalCheatCSGO.Util; 4 | using System; 5 | using System.Collections.Generic; 6 | using System.Linq; 7 | using System.Text; 8 | 9 | namespace SimpleExternalCheatCSGO.SDK 10 | { 11 | public class CBasePlayer : IClientEntity 12 | { 13 | public CBasePlayer() { } 14 | public CBasePlayer(IntPtr pEntity) 15 | { 16 | pThis = pEntity; 17 | } 18 | 19 | public Vector GetHitboxPosition(int iHitbox, string szModelName = "") 20 | { 21 | if (szModelName == "") 22 | szModelName = this.GetModelName(); 23 | 24 | var hitbox = CCHitboxManager.GetHitBox(this, szModelName, iHitbox); 25 | 26 | var matrix = GetMatrix3x4(hitbox.bone); 27 | 28 | Vector vMin = MathUtil.VectorTransform(new Vector(hitbox.bbmin), matrix); 29 | Vector vMax = MathUtil.VectorTransform(new Vector(hitbox.bbmax), matrix); 30 | Vector vCenter = ((vMin + vMax) * 0.5f); 31 | 32 | return vCenter; 33 | } 34 | 35 | public bool HasGunGameImmunity() 36 | { 37 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_bGunGameImmunity); 38 | } 39 | 40 | public bool IsScoped() 41 | { 42 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_bIsScoped); 43 | } 44 | 45 | public void SetRenderColor(Color col) 46 | { 47 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_clrRender, (char)col.R); 48 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_clrRender + 1, (char)col.G); 49 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_clrRender + 2, (char)col.B); 50 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_clrRender + 3, (char)col.A); 51 | } 52 | 53 | public void SetWearable(int iHandle) 54 | { 55 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_hMyWearables, iHandle); 56 | } 57 | 58 | public CBaseCombatWeapon GetActiveWeapon() 59 | { 60 | int Handle = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_hActiveWeapon); 61 | 62 | Handle &= 0xFFF; 63 | 64 | return new CBaseCombatWeapon(MainThread.g_EntityList.GetEntityByIndex(Handle)); 65 | } 66 | 67 | public void SetSpotted(bool val) 68 | { 69 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_bSpotted, val); 70 | } 71 | 72 | public List GetWeapons() 73 | { 74 | List wp = new List(); 75 | 76 | var weapon = GetWeaponHandle(0); 77 | 78 | for (int i = 1; weapon != -1; ++i) 79 | { 80 | int id = weapon & 0xFFF; 81 | wp.Add(new CBaseCombatWeapon(MainThread.g_EntityList.GetEntityByIndex(id))); 82 | weapon = GetWeaponHandle(i); 83 | } 84 | 85 | return wp; 86 | } 87 | 88 | public int GetWeaponHandle(int index) 89 | { 90 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_hMyWeapons + (index * 0x4)); 91 | } 92 | 93 | public CBaseCombatWeapon GetWearableWeapon() 94 | { 95 | int Handle = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_hMyWearables); 96 | 97 | Handle &= 0xFFF; 98 | 99 | return new CBaseCombatWeapon(MainThread.g_EntityList.GetEntityByIndex(Handle)); 100 | } 101 | 102 | public matrix3x4 GetMatrix3x4(int iBone) 103 | { 104 | IntPtr pBase = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_dwBoneMatrix); 105 | 106 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pBase + 0x30 * iBone); 107 | } 108 | 109 | public int GetHealth() 110 | { 111 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iHealth); 112 | } 113 | 114 | public Team GetTeamNum() 115 | { 116 | return (Team)MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iTeamNum); 117 | } 118 | 119 | public float GetVelocity() 120 | { 121 | return (float)(new Vector(MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_vecVelocity)).Lenght2D()); 122 | } 123 | 124 | public Vector GetViewOffset() 125 | { 126 | return new Vector(MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_vecViewOffset)); 127 | } 128 | 129 | public Int64 GetSpottedMask() 130 | { 131 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_bSpottedByMask); 132 | } 133 | 134 | public bool IsOnGround() 135 | { 136 | return (GetFlags() & (1 << 0)) != 0; 137 | } 138 | 139 | public int GetFlags() 140 | { 141 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_nFlags); 142 | } 143 | 144 | public bool IsSpottedByMask(CBasePlayer pEntity) 145 | { 146 | return (GetSpottedMask() & (1 << (pEntity.GetIndex() - 1))) != 0; 147 | } 148 | 149 | public Vector GetEyePosition() 150 | { 151 | return GetOrigin() + GetViewOffset(); 152 | } 153 | } 154 | } 155 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Interfaces/CClientState.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Structs; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.SDK 9 | { 10 | public class CClientState 11 | { 12 | public IntPtr pThis; 13 | public ModelINetworkStringTable m_pModelPrecacheTable = null; 14 | public void Update() 15 | { 16 | pThis = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["engine"].BaseAddress + Globals._signatures.dw_ClientState); 17 | if (IsInGame()) 18 | { 19 | if (m_pModelPrecacheTable == null) 20 | m_pModelPrecacheTable = GetModelPrecacheTable(); 21 | if (m_pModelPrecacheTable != null && m_pModelPrecacheTable.lastMap != GetMapName()) 22 | { 23 | m_pModelPrecacheTable.Update(); 24 | m_pModelPrecacheTable.lastMap = GetMapName(); 25 | } 26 | } 27 | } 28 | 29 | public int GetModelIndexByName(string model_name) 30 | { 31 | if (m_pModelPrecacheTable == null) 32 | return -1; 33 | if (m_pModelPrecacheTable.Items.ContainsKey(model_name)) 34 | return m_pModelPrecacheTable.Items[model_name]; 35 | else 36 | return -1; 37 | } 38 | 39 | public void ForceUpdate() 40 | { 41 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + 0x174, -1); 42 | } 43 | 44 | public int GetLastOutGoingCommand() 45 | { 46 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_lastoutgoingcommand); 47 | } 48 | 49 | public void OneTickAttack() 50 | { 51 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceattack, 6); 52 | } 53 | 54 | public void PlusAttack() 55 | { 56 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceattack, 5); 57 | } 58 | 59 | public void MinusAttack() 60 | { 61 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceattack, 4); 62 | } 63 | 64 | public void PlusJump() 65 | { 66 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceJump, 5); 67 | } 68 | 69 | public void MinusJump() 70 | { 71 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceJump, 4); 72 | } 73 | 74 | public int GetJumpState() 75 | { 76 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceJump); 77 | } 78 | 79 | public int GetAttackState() 80 | { 81 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["client"].BaseAddress + Globals._signatures.dw_forceattack); 82 | } 83 | 84 | public string GetMapDirectory() 85 | { 86 | return MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.m_dwMapDirectory, 64); 87 | } 88 | 89 | public string GetMapName() 90 | { 91 | string directory = GetMapDirectory(); 92 | return directory.Substring(5, directory.LastIndexOf('.') - 5); 93 | } 94 | 95 | public ModelINetworkStringTable GetModelPrecacheTable() 96 | { 97 | IntPtr pPointer = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_ModelPrecacheTable); 98 | 99 | return pPointer != IntPtr.Zero ? new ModelINetworkStringTable(pPointer) : null; 100 | } 101 | 102 | public IntPtr GetUserInfoTable() 103 | { 104 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_UserInfoTable); 105 | } 106 | 107 | public player_info_s GetPlayerInfo(int index) 108 | { 109 | var items = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, GetUserInfoTable() + 0x3C) + 0xC); 110 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, items + 0x20 + ((index - 1) * 0x34))); 111 | } 112 | 113 | public bool IsInGame() 114 | { 115 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_isingame) == 6; 116 | } 117 | 118 | public void SetSendPacket(bool bSendPacket) 119 | { 120 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["engine"].BaseAddress + Globals._signatures.dw_bSendPackets, bSendPacket); 121 | } 122 | public bool GetSendPacket() 123 | { 124 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["engine"].BaseAddress + Globals._signatures.dw_bSendPackets); 125 | } 126 | public Vector GetViewAngles() 127 | { 128 | return new Vector(MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_viewangles)); 129 | } 130 | 131 | public void SetViewAngles(Vector angles) 132 | { 133 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_viewangles, angles.ToStruct()); 134 | } 135 | } 136 | } 137 | -------------------------------------------------------------------------------- /External-CSGO/SDK/Entity/CBaseWeapon.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | 7 | namespace SimpleExternalCheatCSGO.SDK 8 | { 9 | public class CBaseCombatWeapon : IClientEntity 10 | { 11 | public CBaseCombatWeapon(IntPtr pEntity) 12 | { 13 | pThis = pEntity; 14 | } 15 | 16 | public int GetAvailableAmmo() 17 | { 18 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iClip1); 19 | } 20 | 21 | public int GetWeaponID() 22 | { 23 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iItemDefinitionIndex); 24 | } 25 | 26 | public void SetAccountID(int accountid) 27 | { 28 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iAccountID, accountid); 29 | } 30 | 31 | public void SetItemDefinitionIndex(int itemdefiniotion) 32 | { 33 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iItemDefinitionIndex, itemdefiniotion); 34 | } 35 | 36 | public void SetFallbackPaintKit(int fallback_skin) 37 | { 38 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_nFallbackPaintKit, fallback_skin); 39 | } 40 | 41 | public void SetOriginalOwnerXuidLow(int xuidlow) 42 | { 43 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_OriginalOwnerXuidLow, xuidlow); 44 | } 45 | 46 | public void SetOriginalOwnerXuidHigh(int xuidhigh) 47 | { 48 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_OriginalOwnerXuidHigh, xuidhigh); 49 | } 50 | 51 | public void SetFallbackWear(float wear) 52 | { 53 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_flFallbackWear, wear); 54 | } 55 | 56 | public void SetItemIDHigh(int id) 57 | { 58 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_iItemIDHigh, id); 59 | } 60 | 61 | public void SetFallbackStatTrak(int stattrak) 62 | { 63 | MemoryAPI.WriteToProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_nFallbackStatTrak, stattrak); 64 | } 65 | 66 | public int GetFallbackPaintKit() 67 | { 68 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_nFallbackPaintKit); 69 | } 70 | 71 | public int GetFallbackStatTrak() 72 | { 73 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_nFallbackStatTrak); 74 | } 75 | 76 | public float GetFallbackWear() 77 | { 78 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._netvar.m_flFallbackWear); 79 | } 80 | 81 | public bool IsBomb() 82 | { 83 | var id = this.GetWeaponID(); 84 | switch (id) 85 | { 86 | case 49: 87 | return true; 88 | } 89 | 90 | return false; 91 | } 92 | 93 | public bool IsGrenade() 94 | { 95 | var id = this.GetWeaponID(); 96 | switch (id) 97 | { 98 | case 43: 99 | case 44: 100 | case 45: 101 | case 46: 102 | case 47: 103 | case 48: 104 | return true; 105 | } 106 | 107 | return false; 108 | } 109 | 110 | public bool IsKnife() 111 | { 112 | var id = this.GetWeaponID(); 113 | switch (id) 114 | { 115 | case 42: 116 | case 59: 117 | case 500: 118 | case 505: 119 | case 506: 120 | case 507: 121 | case 508: 122 | case 509: 123 | case 512: 124 | case 514: 125 | case 515: 126 | case 516: 127 | return true; 128 | } 129 | 130 | return false; 131 | } 132 | 133 | public bool IsPistol() 134 | { 135 | var id = this.GetWeaponID(); 136 | switch (id) 137 | { 138 | case 1: 139 | case 2: 140 | case 3: 141 | case 4: 142 | case 30: 143 | case 32: 144 | case 36: 145 | case 61: 146 | return true; 147 | } 148 | 149 | return false; 150 | } 151 | 152 | public bool IsSniper() 153 | { 154 | var id = this.GetWeaponID(); 155 | switch (id) 156 | { 157 | case 9: 158 | case 11: 159 | case 38: 160 | case 40: 161 | return true; 162 | } 163 | 164 | return false; 165 | } 166 | 167 | public bool IsRestrictedRcs() 168 | { 169 | var id = this.GetWeaponID(); 170 | switch (id) 171 | { 172 | case 1: 173 | case 9: 174 | case 11: 175 | case 25: 176 | case 27: 177 | case 29: 178 | case 35: 179 | case 38: 180 | case 40: 181 | return true; 182 | } 183 | 184 | return false; 185 | } 186 | 187 | public int GetWeaponTableIndex() 188 | { 189 | return MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, pThis + Globals._signatures.dw_WeaponTableIndex); 190 | } 191 | 192 | } 193 | } 194 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ## Ignore Visual Studio temporary files, build results, and 2 | ## files generated by popular Visual Studio add-ons. 3 | ## 4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore 5 | 6 | # User-specific files 7 | *.suo 8 | *.user 9 | *.userosscache 10 | *.sln.docstates 11 | 12 | # User-specific files (MonoDevelop/Xamarin Studio) 13 | *.userprefs 14 | 15 | # Build results 16 | [Dd]ebug/ 17 | [Dd]ebugPublic/ 18 | [Rr]elease/ 19 | [Rr]eleases/ 20 | x64/ 21 | x86/ 22 | bld/ 23 | [Bb]in/ 24 | [Oo]bj/ 25 | [Ll]og/ 26 | 27 | # Visual Studio 2015 cache/options directory 28 | .vs/ 29 | # Uncomment if you have tasks that create the project's static files in wwwroot 30 | #wwwroot/ 31 | 32 | # MSTest test Results 33 | [Tt]est[Rr]esult*/ 34 | [Bb]uild[Ll]og.* 35 | 36 | # NUNIT 37 | *.VisualState.xml 38 | TestResult.xml 39 | 40 | # Build Results of an ATL Project 41 | [Dd]ebugPS/ 42 | [Rr]eleasePS/ 43 | dlldata.c 44 | 45 | # .NET Core 46 | project.lock.json 47 | project.fragment.lock.json 48 | artifacts/ 49 | **/Properties/launchSettings.json 50 | 51 | *_i.c 52 | *_p.c 53 | *_i.h 54 | *.ilk 55 | *.meta 56 | *.obj 57 | *.pch 58 | *.pdb 59 | *.pgc 60 | *.pgd 61 | *.rsp 62 | *.sbr 63 | *.tlb 64 | *.tli 65 | *.tlh 66 | *.tmp 67 | *.tmp_proj 68 | *.log 69 | *.vspscc 70 | *.vssscc 71 | .builds 72 | *.pidb 73 | *.svclog 74 | *.scc 75 | 76 | # Chutzpah Test files 77 | _Chutzpah* 78 | 79 | # Visual C++ cache files 80 | ipch/ 81 | *.aps 82 | *.ncb 83 | *.opendb 84 | *.opensdf 85 | *.sdf 86 | *.cachefile 87 | *.VC.db 88 | *.VC.VC.opendb 89 | 90 | # Visual Studio profiler 91 | *.psess 92 | *.vsp 93 | *.vspx 94 | *.sap 95 | 96 | # TFS 2012 Local Workspace 97 | $tf/ 98 | 99 | # Guidance Automation Toolkit 100 | *.gpState 101 | 102 | # ReSharper is a .NET coding add-in 103 | _ReSharper*/ 104 | *.[Rr]e[Ss]harper 105 | *.DotSettings.user 106 | 107 | # JustCode is a .NET coding add-in 108 | .JustCode 109 | 110 | # TeamCity is a build add-in 111 | _TeamCity* 112 | 113 | # DotCover is a Code Coverage Tool 114 | *.dotCover 115 | 116 | # Visual Studio code coverage results 117 | *.coverage 118 | *.coveragexml 119 | 120 | # NCrunch 121 | _NCrunch_* 122 | .*crunch*.local.xml 123 | nCrunchTemp_* 124 | 125 | # MightyMoose 126 | *.mm.* 127 | AutoTest.Net/ 128 | 129 | # Web workbench (sass) 130 | .sass-cache/ 131 | 132 | # Installshield output folder 133 | [Ee]xpress/ 134 | 135 | # DocProject is a documentation generator add-in 136 | DocProject/buildhelp/ 137 | DocProject/Help/*.HxT 138 | DocProject/Help/*.HxC 139 | DocProject/Help/*.hhc 140 | DocProject/Help/*.hhk 141 | DocProject/Help/*.hhp 142 | DocProject/Help/Html2 143 | DocProject/Help/html 144 | 145 | # Click-Once directory 146 | publish/ 147 | 148 | # Publish Web Output 149 | *.[Pp]ublish.xml 150 | *.azurePubxml 151 | # TODO: Comment the next line if you want to checkin your web deploy settings 152 | # but database connection strings (with potential passwords) will be unencrypted 153 | *.pubxml 154 | *.publishproj 155 | 156 | # Microsoft Azure Web App publish settings. Comment the next line if you want to 157 | # checkin your Azure Web App publish settings, but sensitive information contained 158 | # in these scripts will be unencrypted 159 | PublishScripts/ 160 | 161 | # NuGet Packages 162 | *.nupkg 163 | # The packages folder can be ignored because of Package Restore 164 | **/packages/* 165 | # except build/, which is used as an MSBuild target. 166 | !**/packages/build/ 167 | # Uncomment if necessary however generally it will be regenerated when needed 168 | #!**/packages/repositories.config 169 | # NuGet v3's project.json files produces more ignorable files 170 | *.nuget.props 171 | *.nuget.targets 172 | 173 | # Microsoft Azure Build Output 174 | csx/ 175 | *.build.csdef 176 | 177 | # Microsoft Azure Emulator 178 | ecf/ 179 | rcf/ 180 | 181 | # Windows Store app package directories and files 182 | AppPackages/ 183 | BundleArtifacts/ 184 | Package.StoreAssociation.xml 185 | _pkginfo.txt 186 | 187 | # Visual Studio cache files 188 | # files ending in .cache can be ignored 189 | *.[Cc]ache 190 | # but keep track of directories ending in .cache 191 | !*.[Cc]ache/ 192 | 193 | # Others 194 | ClientBin/ 195 | ~$* 196 | *~ 197 | *.dbmdl 198 | *.dbproj.schemaview 199 | *.jfm 200 | *.pfx 201 | *.publishsettings 202 | orleans.codegen.cs 203 | 204 | # Since there are multiple workflows, uncomment next line to ignore bower_components 205 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) 206 | #bower_components/ 207 | 208 | # RIA/Silverlight projects 209 | Generated_Code/ 210 | 211 | # Backup & report files from converting an old project file 212 | # to a newer Visual Studio version. Backup files are not needed, 213 | # because we have git ;-) 214 | _UpgradeReport_Files/ 215 | Backup*/ 216 | UpgradeLog*.XML 217 | UpgradeLog*.htm 218 | 219 | # SQL Server files 220 | *.mdf 221 | *.ldf 222 | *.ndf 223 | 224 | # Business Intelligence projects 225 | *.rdl.data 226 | *.bim.layout 227 | *.bim_*.settings 228 | 229 | # Microsoft Fakes 230 | FakesAssemblies/ 231 | 232 | # GhostDoc plugin setting file 233 | *.GhostDoc.xml 234 | 235 | # Node.js Tools for Visual Studio 236 | .ntvs_analysis.dat 237 | node_modules/ 238 | 239 | # Typescript v1 declaration files 240 | typings/ 241 | 242 | # Visual Studio 6 build log 243 | *.plg 244 | 245 | # Visual Studio 6 workspace options file 246 | *.opt 247 | 248 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.) 249 | *.vbw 250 | 251 | # Visual Studio LightSwitch build output 252 | **/*.HTMLClient/GeneratedArtifacts 253 | **/*.DesktopClient/GeneratedArtifacts 254 | **/*.DesktopClient/ModelManifest.xml 255 | **/*.Server/GeneratedArtifacts 256 | **/*.Server/ModelManifest.xml 257 | _Pvt_Extensions 258 | 259 | # Paket dependency manager 260 | .paket/paket.exe 261 | paket-files/ 262 | 263 | # FAKE - F# Make 264 | .fake/ 265 | 266 | # JetBrains Rider 267 | .idea/ 268 | *.sln.iml 269 | 270 | # CodeRush 271 | .cr/ 272 | 273 | # Python Tools for Visual Studio (PTVS) 274 | __pycache__/ 275 | *.pyc 276 | 277 | # Cake - Uncomment if you are using it 278 | # tools/** 279 | # !tools/packages.config 280 | 281 | # Telerik's JustMock configuration file 282 | *.jmconfig 283 | 284 | # BizTalk build output 285 | *.btp.cs 286 | *.btm.cs 287 | *.odx.cs 288 | *.xsd.cs 289 | -------------------------------------------------------------------------------- /External-CSGO/ExternalCSGO.csproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | AnyCPU 7 | {909D494F-72FD-47B3-A5E8-B01650982BCC} 8 | Exe 9 | Properties 10 | SimpleExternalCSGOCheat 11 | SimpleExternalCSGOCheat 12 | v4.0 13 | 512 14 | 15 | 16 | AnyCPU 17 | true 18 | full 19 | false 20 | bin\Debug\ 21 | DEBUG;TRACE 22 | prompt 23 | 4 24 | 25 | 26 | AnyCPU 27 | pdbonly 28 | true 29 | bin\Release\ 30 | TRACE 31 | prompt 32 | 4 33 | 34 | 35 | true 36 | bin\x86\Debug\ 37 | DEBUG;TRACE 38 | full 39 | x86 40 | prompt 41 | MinimumRecommendedRules.ruleset 42 | 1 43 | 44 | 45 | bin\x86\Release\ 46 | TRACE 47 | true 48 | pdbonly 49 | x86 50 | prompt 51 | MinimumRecommendedRules.ruleset 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 128 | -------------------------------------------------------------------------------- /External-CSGO/Structs/ClassId.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Linq; 4 | using System.Text; 5 | 6 | namespace SimpleExternalCheatCSGO.Structs 7 | { 8 | public enum CSGOClassID 9 | { 10 | CAI_BaseNPC = 0, 11 | CAK47, 12 | CBaseAnimating, 13 | CBaseAnimatingOverlay, 14 | CBaseAttributableItem, 15 | CBaseButton, 16 | CBaseCombatCharacter, 17 | CBaseCombatWeapon, 18 | CBaseCSGrenade, 19 | CBaseCSGrenadeProjectile, 20 | CBaseDoor, 21 | CBaseEntity, 22 | CBaseFlex, 23 | CBaseGrenade, 24 | CBaseParticleEntity, 25 | CBasePlayer, 26 | CBasePropDoor, 27 | CBaseTeamObjectiveResource, 28 | CBaseTempEntity, 29 | CBaseToggle, 30 | CBaseTrigger, 31 | CBaseViewModel, 32 | CBaseVPhysicsTrigger, 33 | CBaseWeaponWorldModel, 34 | CBeam, 35 | CBeamSpotlight, 36 | CBoneFollower, 37 | CBreakableProp, 38 | CBreakableSurface, 39 | CC4, 40 | CCascadeLight, 41 | CChicken, 42 | CColorCorrection, 43 | CColorCorrectionVolume, 44 | CCSGameRulesProxy, 45 | CCSPlayer, 46 | CCSPlayerResource, 47 | CCSRagdoll, 48 | CCSTeam, 49 | CDEagle, 50 | CDecoyGrenade, 51 | CDecoyProjectile, 52 | CDynamicLight, 53 | CDynamicProp, 54 | CEconEntity, 55 | CEconWearable, 56 | CEmbers, 57 | CEntityDissolve, 58 | CEntityFlame, 59 | CEntityFreezing, 60 | CEntityParticleTrail, 61 | CEnvAmbientLight, 62 | CEnvDetailController, 63 | CEnvDOFController, 64 | CEnvParticleScript, 65 | CEnvProjectedTexture, 66 | CEnvQuadraticBeam, 67 | CEnvScreenEffect, 68 | CEnvScreenOverlay, 69 | CEnvTonemapController, 70 | CEnvWind, 71 | CFEPlayerDecal, 72 | CFireCrackerBlast, 73 | CFireSmoke, 74 | CFireTrail, 75 | CFish, 76 | CFlashbang, 77 | CFogController, 78 | CFootstepControl, 79 | CFunc_Dust, 80 | CFunc_LOD, 81 | CFuncAreaPortalWindow, 82 | CFuncBrush, 83 | CFuncConveyor, 84 | CFuncLadder, 85 | CFuncMonitor, 86 | CFuncMoveLinear, 87 | CFuncOccluder, 88 | CFuncReflectiveGlass, 89 | CFuncRotating, 90 | CFuncSmokeVolume, 91 | CFuncTrackTrain, 92 | CGameRulesProxy, 93 | CHandleTest, 94 | CHEGrenade, 95 | CHostage, 96 | CHostageCarriableProp, 97 | CIncendiaryGrenade, 98 | CInferno, 99 | CInfoLadderDismount, 100 | CInfoOverlayAccessor, 101 | CItem_Healthshot, 102 | CItemDogtags, 103 | CKnife, 104 | CKnifeGG, 105 | CLightGlow, 106 | CMaterialModifyControl, 107 | CMolotovGrenade, 108 | CMolotovProjectile, 109 | CMovieDisplay, 110 | CParticleFire, 111 | CParticlePerformanceMonitor, 112 | CParticleSystem, 113 | CPhysBox, 114 | CPhysBoxMultiplayer, 115 | CPhysicsProp, 116 | CPhysicsPropMultiplayer, 117 | CPhysMagnet, 118 | CPlantedC4, 119 | CPlasma, 120 | CPlayerResource, 121 | CPointCamera, 122 | CPointCommentaryNode, 123 | CPointWorldText, 124 | CPoseController, 125 | CPostProcessController, 126 | CPrecipitation, 127 | CPrecipitationBlocker, 128 | CPredictedViewModel, 129 | CProp_Hallucination, 130 | CPropDoorRotating, 131 | CPropJeep, 132 | CPropVehicleDriveable, 133 | CRagdollManager, 134 | CRagdollProp, 135 | CRagdollPropAttached, 136 | CRopeKeyframe, 137 | CSCAR17, 138 | CSceneEntity, 139 | CSensorGrenade, 140 | CSensorGrenadeProjectile, 141 | CShadowControl, 142 | CSlideshowDisplay, 143 | CSmokeGrenade, 144 | CSmokeGrenadeProjectile, 145 | CSmokeStack, 146 | CSpatialEntity, 147 | CSpotlightEnd, 148 | CSprite, 149 | CSpriteOriented, 150 | CSpriteTrail, 151 | CStatueProp, 152 | CSteamJet, 153 | CSun, 154 | CSunlightShadowControl, 155 | CTeam, 156 | CTeamplayRoundBasedRulesProxy, 157 | CTEArmorRicochet, 158 | CTEBaseBeam, 159 | CTEBeamEntPoint, 160 | CTEBeamEnts, 161 | CTEBeamFollow, 162 | CTEBeamLaser, 163 | CTEBeamPoints, 164 | CTEBeamRing, 165 | CTEBeamRingPoint, 166 | CTEBeamSpline, 167 | CTEBloodSprite, 168 | CTEBloodStream, 169 | CTEBreakModel, 170 | CTEBSPDecal, 171 | CTEBubbles, 172 | CTEBubbleTrail, 173 | CTEClientProjectile, 174 | CTEDecal, 175 | CTEDust, 176 | CTEDynamicLight, 177 | CTEEffectDispatch, 178 | CTEEnergySplash, 179 | CTEExplosion, 180 | CTEFireBullets, 181 | CTEFizz, 182 | CTEFootprintDecal, 183 | CTEFoundryHelpers, 184 | CTEGaussExplosion, 185 | CTEGlowSprite, 186 | CTEImpact, 187 | CTEKillPlayerAttachments, 188 | CTELargeFunnel, 189 | CTEMetalSparks, 190 | CTEMuzzleFlash, 191 | CTEParticleSystem, 192 | CTEPhysicsProp, 193 | CTEPlantBomb, 194 | CTEPlayerAnimEvent, 195 | CTEPlayerDecal, 196 | CTEProjectedDecal, 197 | CTERadioIcon, 198 | CTEShatterSurface, 199 | CTEShowLine, 200 | CTesla, 201 | CTESmoke, 202 | CTESparks, 203 | CTESprite, 204 | CTESpriteSpray, 205 | CTest_ProxyToggle_Networkable, 206 | CTestTraceline, 207 | CTEWorldDecal, 208 | CTriggerPlayerMovement, 209 | CTriggerSoundOperator, 210 | CVGuiScreen, 211 | CVoteController, 212 | CWaterBullet, 213 | CWaterLODControl, 214 | CWeaponAug, 215 | CWeaponAWP, 216 | CWeaponBaseItem, 217 | CWeaponBizon, 218 | CWeaponCSBase, 219 | CWeaponCSBaseGun, 220 | CWeaponCycler, 221 | CWeaponElite, 222 | CWeaponFamas, 223 | CWeaponFiveSeven, 224 | CWeaponG3SG1, 225 | CWeaponGalil, 226 | CWeaponGalilAR, 227 | CWeaponGlock, 228 | CWeaponHKP2000, 229 | CWeaponM249, 230 | CWeaponM3, 231 | CWeaponM4A1, 232 | CWeaponMAC10, 233 | CWeaponMag7, 234 | CWeaponMP5Navy, 235 | CWeaponMP7, 236 | CWeaponMP9, 237 | CWeaponNegev, 238 | CWeaponNOVA, 239 | CWeaponP228, 240 | CWeaponP250, 241 | CWeaponP90, 242 | CWeaponSawedoff, 243 | CWeaponSCAR20, 244 | CWeaponScout, 245 | CWeaponSG550, 246 | CWeaponSG552, 247 | CWeaponSG556, 248 | CWeaponSSG08, 249 | CWeaponTaser, 250 | CWeaponTec9, 251 | CWeaponTMP, 252 | CWeaponUMP45, 253 | CWeaponUSP, 254 | CWeaponXM1014, 255 | CWorld, 256 | DustTrail, 257 | MovieExplosion, 258 | ParticleSmokeGrenade, 259 | RocketTrail, 260 | SmokeTrail, 261 | SporeExplosion, 262 | SporeTrail, 263 | }; 264 | } 265 | -------------------------------------------------------------------------------- /External-CSGO/CSGOProcess.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.CodeInjection; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Diagnostics; 6 | using System.Linq; 7 | using System.Runtime.InteropServices; 8 | using System.Text; 9 | using System.Threading; 10 | 11 | namespace SimpleExternalCheatCSGO 12 | { 13 | public struct GameModule 14 | { 15 | public IntPtr BaseAddress; 16 | public int Size; 17 | public GameModule(IntPtr baseaddress, int size) 18 | { 19 | this.BaseAddress = baseaddress; 20 | this.Size = size; 21 | } 22 | } 23 | 24 | public class CSGOProcess 25 | { 26 | public IntPtr ProcessHandle = IntPtr.Zero; 27 | 28 | public Process GameProcess = null; 29 | 30 | public Dictionary CSGOModules = new Dictionary(); 31 | 32 | public void DumpInfo() 33 | { 34 | Console.WriteLine("--------"); 35 | 36 | Console.WriteLine("Process PID - " + Globals._csgo.GameProcess.Id); 37 | Console.WriteLine("Handle - 0x" + Globals._csgo.ProcessHandle.ToString("X")); 38 | 39 | Console.WriteLine("--------"); 40 | 41 | foreach (var mod in CSGOModules) 42 | { 43 | Console.WriteLine(""); 44 | Console.WriteLine(" " + mod.Key + ".dll"); 45 | Console.WriteLine("- BaseAddress - 0x" + mod.Value.BaseAddress.ToString("X")); 46 | Console.WriteLine("- Size - 0x" + mod.Value.Size.ToString("X")); 47 | } 48 | 49 | Console.WriteLine(""); 50 | Console.WriteLine(""); 51 | } 52 | 53 | public bool CheckHandle() 54 | { 55 | bool bFail = false; 56 | try 57 | { 58 | GameProcess = Process.GetProcessById(GameProcess.Id); 59 | } 60 | catch { bFail = true; } 61 | 62 | if (GameProcess == null || ProcessHandle == IntPtr.Zero || bFail) 63 | { 64 | if (MainThread.TriggerThread != null && MainThread.TriggerThread.IsAlive) 65 | MainThread.TriggerThread.Abort(); 66 | 67 | Environment.Exit(0); 68 | Console.WriteLine("Invalid handle!"); 69 | Clear(); 70 | return false; 71 | } 72 | return true; 73 | } 74 | 75 | public void Clear() 76 | { 77 | Globals._alloc.Free(); 78 | Globals._alloc.AllocatedSize.Clear(); 79 | 80 | SendClantag.Address = IntPtr.Zero; 81 | LineGoesThroughSmoke.Address = IntPtr.Zero; 82 | RevealRank.Address = IntPtr.Zero; 83 | ClientCmd.Address = IntPtr.Zero; 84 | 85 | GameProcess = null; 86 | CSGOModules.Clear(); 87 | WinAPI.CloseHandle(ProcessHandle); 88 | } 89 | 90 | public bool LoadCSGO() 91 | { 92 | try 93 | { 94 | var _loaded = false; 95 | while (!_loaded) 96 | { 97 | var _processes = Process.GetProcessesByName("csgo"); 98 | 99 | if (_processes.Length <= 0) 100 | { 101 | Thread.Sleep(50); 102 | continue; 103 | } 104 | 105 | var _process = _processes.FirstOrDefault(); 106 | 107 | if (_processes.Length > 1) 108 | { 109 | Console.WriteLine("--------"); 110 | for (var i = 1; i < +_processes.Length; ++i) 111 | { 112 | var _proc = _processes[i - 1]; 113 | Console.WriteLine(i + ". csgo.exe - " + _proc.Id); 114 | } 115 | Console.WriteLine("--------"); 116 | 117 | Console.Write("Select index: "); 118 | int iIndex = 0; 119 | try 120 | { 121 | iIndex = Convert.ToInt32(Console.ReadLine()) - 1; 122 | } 123 | catch { } 124 | 125 | _process = _processes[iIndex]; 126 | } 127 | 128 | int _ProcessID = _process.Id; 129 | bool _modulesLoaded = false; 130 | Console.WriteLine("Getting modules..."); 131 | while (!_modulesLoaded) 132 | { 133 | CSGOModules.Clear(); 134 | _process = Process.GetProcessById(_ProcessID); 135 | 136 | bool _clientLoaded = false; 137 | bool _engineLoaded = false; 138 | bool _vstdlibLoaded = false; 139 | bool _inputsystemLoaded = false; 140 | bool _steam_apiLoaded = false; 141 | 142 | foreach (ProcessModule _module in _process.Modules) 143 | { 144 | if (!_clientLoaded && _module.ModuleName == "client.dll" && _module.BaseAddress != IntPtr.Zero) 145 | { 146 | GameModule _clientmodule = new GameModule(_module.BaseAddress, _module.ModuleMemorySize); 147 | CSGOModules.Add("client", _clientmodule); 148 | _clientLoaded = true; 149 | } 150 | if (!_engineLoaded && _module.ModuleName == "engine.dll" && _module.BaseAddress != IntPtr.Zero) 151 | { 152 | GameModule _enginemodule = new GameModule(_module.BaseAddress, _module.ModuleMemorySize); 153 | CSGOModules.Add("engine", _enginemodule); 154 | _engineLoaded = true; 155 | } 156 | if (!_vstdlibLoaded && _module.ModuleName == "vstdlib.dll" && _module.BaseAddress != IntPtr.Zero) 157 | { 158 | GameModule _vstdlibmodule = new GameModule(_module.BaseAddress, _module.ModuleMemorySize); 159 | CSGOModules.Add("vstdlib", _vstdlibmodule); 160 | _vstdlibLoaded = true; 161 | } 162 | if (!_inputsystemLoaded && _module.ModuleName == "inputsystem.dll" && _module.BaseAddress != IntPtr.Zero) 163 | { 164 | GameModule _inputsystemmodule = new GameModule(_module.BaseAddress, _module.ModuleMemorySize); 165 | CSGOModules.Add("inputsystem", _inputsystemmodule); 166 | _inputsystemLoaded = true; 167 | } 168 | if (!_steam_apiLoaded && _module.ModuleName == "steam_api.dll" && _module.BaseAddress != IntPtr.Zero) 169 | { 170 | GameModule _steam_api = new GameModule(_module.BaseAddress, _module.ModuleMemorySize); 171 | CSGOModules.Add("steam_api", _steam_api); 172 | _steam_apiLoaded = true; 173 | } 174 | if (_engineLoaded && _clientLoaded && _vstdlibLoaded && _inputsystemLoaded && _steam_apiLoaded) 175 | { 176 | _modulesLoaded = true; 177 | break; 178 | } 179 | } 180 | Thread.Sleep(50); 181 | } 182 | GameProcess = _process; 183 | 184 | ProcessHandle = WinAPI.OpenProcess(0x1F0FFF, false, GameProcess.Id); 185 | 186 | _loaded = true; 187 | } 188 | return true; 189 | } 190 | catch { return false; } 191 | } 192 | } 193 | } 194 | -------------------------------------------------------------------------------- /External-CSGO/Offsets/NetVarManager.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Memory; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.Offsets 9 | { 10 | //https://github.com/Y3t1y3t/CSGO-Dumper/tree/master/Dumper/src 11 | public class NetVarManager 12 | { 13 | public Dictionary> _tables = new Dictionary>(); 14 | 15 | void ScanTable(IntPtr table, int level, int offset, string name) 16 | { 17 | var count = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, table + 0x4); 18 | for (var i = 0; i < count; ++i) 19 | { 20 | int propID = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, table) + i * 0x3C; 21 | string propName = MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, new IntPtr(propID)), 64); 22 | var isBaseClass = propName.IndexOf("baseclass") == 0; 23 | int propOffset = offset + MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, new IntPtr(propID + 0x2C)); 24 | if (!isBaseClass) 25 | { 26 | if (!_tables.ContainsKey(name)) 27 | _tables.Add(name, new Dictionary()); 28 | if (!_tables[name].ContainsKey(propName)) 29 | _tables[name].Add(propName, propOffset); 30 | 31 | } 32 | 33 | var child = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, new IntPtr(propID + 0x28)); 34 | if (child == IntPtr.Zero) 35 | continue; 36 | 37 | if (isBaseClass) 38 | --level; 39 | 40 | ScanTable(child, ++level, propOffset, name); 41 | } 42 | } 43 | 44 | //NET_VARS 45 | public int m_vecOrigin; 46 | public int m_iHealth; 47 | public int m_iGlowIndex; 48 | public int m_iTeamNum; 49 | public int m_vecViewOffset; 50 | public int m_Model; 51 | public int m_dwBoneMatrix; 52 | public int m_iIndex; 53 | public int m_bSpottedByMask; 54 | public int m_iItemDefinitionIndex; 55 | public int m_iClip1; 56 | public int m_iFOV; 57 | public int m_iDefaultFOV; 58 | public int m_iShotsFired; 59 | public int m_aimPunchAngle; 60 | public int m_nFlags; 61 | public int m_hMyWearables; 62 | 63 | public int m_OriginalOwnerXuidLow; 64 | public int m_OriginalOwnerXuidHigh; 65 | public int m_nFallbackPaintKit; 66 | public int m_nFallbackSeed; 67 | public int m_flFallbackWear; 68 | public int m_nFallbackStatTrak; 69 | public int m_iAccountID; 70 | public int m_iItemIDHigh; 71 | public int m_iEntityLevel; 72 | 73 | public int m_vecVelocity; 74 | public int m_hActiveWeapon; 75 | public int m_hMyWeapons; 76 | 77 | public int m_bIsScoped; 78 | public int m_bSpotted; 79 | public int m_iCrosshairId; 80 | 81 | public int m_bGunGameImmunity; 82 | public int m_clrRender; 83 | 84 | public void Init() 85 | { 86 | var _firstclass = new IntPtr(PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "A1 ? ? ? ? 8B 4F 0C 85 C0 74 18 0F 1F 00 39 48 14 74 09 8B 40 10 85 C0 75 F4 EB 07 8B 58 08 85 DB 75 0E 68 ? ? ? ? FF 15 ? ? ? ? 83 C4 04 8B 47 18", Globals._csgo.CSGOModules["client"], false, 0x1, true)); 87 | 88 | _firstclass = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, _firstclass); 89 | 90 | do 91 | { 92 | var table = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, (_firstclass + 0xC)); 93 | if (table != IntPtr.Zero) 94 | { 95 | string table_name = MemoryAPI.ReadTextFromProcess(Globals._csgo.ProcessHandle, MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, (table + 0xC)), 32); 96 | ScanTable(table, 0, 0, table_name); 97 | } 98 | _firstclass = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, (_firstclass + 0x10)); 99 | } while (_firstclass != IntPtr.Zero); 100 | 101 | m_vecOrigin = _tables["DT_BaseEntity"]["m_vecOrigin"]; 102 | 103 | Console.WriteLine("- m_vecOrigin => 0x" + m_vecOrigin.ToString("X")); 104 | 105 | m_iHealth = _tables["DT_CSPlayer"]["m_iHealth"]; 106 | 107 | Console.WriteLine("- m_iHealth => 0x" + m_iHealth.ToString("X")); 108 | 109 | m_iGlowIndex = _tables["DT_CSPlayer"]["m_flFlashDuration"] + 0x18; 110 | 111 | Console.WriteLine("- m_iGlowIndex => 0x" + m_iGlowIndex.ToString("X")); 112 | 113 | m_iTeamNum = _tables["DT_BaseEntity"]["m_iTeamNum"]; 114 | 115 | Console.WriteLine("- m_iTeamNum => 0x" + m_iTeamNum.ToString("X")); 116 | 117 | m_vecViewOffset = _tables["DT_CSPlayer"]["m_vecViewOffset[0]"]; 118 | 119 | Console.WriteLine("- m_vecViewOffset => 0x" + m_vecViewOffset.ToString("X")); 120 | 121 | m_Model = 0x6C; 122 | 123 | Console.WriteLine("- m_Model => 0x" + m_Model.ToString("X")); 124 | 125 | m_dwBoneMatrix = _tables["DT_BaseAnimating"]["m_nForceBone"] + 28; 126 | 127 | Console.WriteLine("- m_dwBoneMatrix => 0x" + m_dwBoneMatrix.ToString("X")); 128 | 129 | m_iIndex = 0x64; 130 | 131 | Console.WriteLine("- m_iIndex => 0x" + m_iIndex.ToString("X")); 132 | 133 | m_bSpottedByMask = _tables["DT_BaseEntity"]["m_bSpottedByMask"]; 134 | 135 | Console.WriteLine("- m_bSpottedByMask => 0x" + m_bSpottedByMask.ToString("X")); 136 | 137 | m_iItemDefinitionIndex = _tables["DT_BaseCombatWeapon"]["m_iItemDefinitionIndex"]; 138 | 139 | Console.WriteLine("- m_iItemDefinitionIndex => 0x" + m_iItemDefinitionIndex.ToString("X")); 140 | 141 | m_iClip1 = _tables["DT_BaseCombatWeapon"]["m_iClip1"]; 142 | 143 | Console.WriteLine("- m_iClip1 => 0x" + m_iClip1.ToString("X")); 144 | 145 | m_iFOV = _tables["DT_CSPlayer"]["m_iFOV"]; 146 | 147 | Console.WriteLine("- m_iFOV => 0x" + m_iFOV.ToString("X")); 148 | 149 | m_iDefaultFOV = _tables["DT_CSPlayer"]["m_iDefaultFOV"]; 150 | 151 | Console.WriteLine("- m_iDefaultFOV => 0x" + m_iDefaultFOV.ToString("X")); 152 | 153 | m_iShotsFired = _tables["DT_CSPlayer"]["m_iShotsFired"]; 154 | 155 | Console.WriteLine("- m_iShotsFired => 0x" + m_iShotsFired.ToString("X")); 156 | 157 | m_aimPunchAngle = _tables["DT_BasePlayer"]["m_aimPunchAngle"]; 158 | 159 | Console.WriteLine("- m_aimPunchAngle => 0x" + m_aimPunchAngle.ToString("X")); 160 | 161 | m_nFlags = _tables["DT_CSPlayer"]["m_fFlags"]; 162 | 163 | Console.WriteLine("- m_fFlags => 0x" + m_nFlags.ToString("X")); 164 | 165 | m_hMyWearables = _tables["DT_BaseCombatCharacter"]["m_hMyWearables"]; 166 | 167 | Console.WriteLine("- m_hMyWearables => 0x" + m_hMyWearables.ToString("X")); 168 | 169 | m_iEntityLevel = _tables["DT_BaseAttributableItem"]["m_iEntityLevel"]; 170 | 171 | Console.WriteLine("- m_iEntityLevel => 0x" + m_iEntityLevel.ToString("X")); 172 | 173 | m_iItemIDHigh = _tables["DT_BaseAttributableItem"]["m_iItemIDHigh"]; 174 | 175 | Console.WriteLine("- m_iItemIDHigh => 0x" + m_iItemIDHigh.ToString("X")); 176 | 177 | m_iAccountID = _tables["DT_BaseAttributableItem"]["m_iAccountID"]; 178 | 179 | Console.WriteLine("- m_iAccountID => 0x" + m_iAccountID.ToString("X")); 180 | 181 | m_OriginalOwnerXuidLow = _tables["DT_BaseAttributableItem"]["m_OriginalOwnerXuidLow"]; 182 | 183 | Console.WriteLine("- m_OriginalOwnerXuidLow => 0x" + m_OriginalOwnerXuidLow.ToString("X")); 184 | 185 | m_OriginalOwnerXuidHigh = _tables["DT_BaseAttributableItem"]["m_OriginalOwnerXuidHigh"]; 186 | 187 | Console.WriteLine("- m_OriginalOwneruidHigh => 0x" + m_OriginalOwnerXuidHigh.ToString("X")); 188 | 189 | m_nFallbackPaintKit = _tables["DT_BaseAttributableItem"]["m_nFallbackPaintKit"]; 190 | 191 | Console.WriteLine("- m_nFallbackPaintKit => 0x" + m_nFallbackPaintKit.ToString("X")); 192 | 193 | m_nFallbackSeed = _tables["DT_BaseAttributableItem"]["m_nFallbackSeed"]; 194 | 195 | Console.WriteLine("- m_nFallbackSeed => 0x" + m_nFallbackSeed.ToString("X")); 196 | 197 | m_flFallbackWear = _tables["DT_BaseAttributableItem"]["m_flFallbackWear"]; 198 | 199 | Console.WriteLine("- m_flFallbackWear => 0x" + m_flFallbackWear.ToString("X")); 200 | 201 | m_nFallbackStatTrak = _tables["DT_BaseAttributableItem"]["m_nFallbackStatTrak"]; 202 | 203 | Console.WriteLine("- m_nFallbackStatTrak => 0x" + m_nFallbackStatTrak.ToString("X")); 204 | 205 | m_vecVelocity = _tables["DT_BasePlayer"]["m_vecVelocity[0]"]; 206 | 207 | Console.WriteLine("- m_vecVelocity => 0x" + m_vecVelocity.ToString("X")); 208 | 209 | m_hActiveWeapon = _tables["DT_CSPlayer"]["m_hActiveWeapon"]; 210 | 211 | Console.WriteLine("- m_hActiveWeapon => 0x" + m_hActiveWeapon.ToString("X")); 212 | 213 | m_hMyWeapons = _tables["DT_CSPlayer"]["m_hMyWeapons"]; 214 | 215 | Console.WriteLine("- m_hMyWeapons => 0x" + m_hMyWeapons.ToString("X")); 216 | 217 | m_bIsScoped = _tables["DT_CSPlayer"]["m_bIsScoped"]; 218 | 219 | Console.WriteLine("- m_bIsScoped => 0x" + m_bIsScoped.ToString("X")); 220 | 221 | m_iCrosshairId = _tables["DT_CSPlayer"]["m_bHasDefuser"] + 92; 222 | 223 | Console.WriteLine("- m_iCrosshairId => 0x" + m_iCrosshairId.ToString("X")); 224 | 225 | m_bGunGameImmunity = _tables["DT_CSPlayer"]["m_bGunGameImmunity"]; 226 | 227 | Console.WriteLine("- m_bGunGameImmunity => 0x" + m_bGunGameImmunity.ToString("X")); 228 | 229 | m_bSpotted = _tables["DT_BaseEntity"]["m_bSpotted"]; 230 | 231 | Console.WriteLine("- m_bSpotted => 0x" + m_bSpotted.ToString("X")); 232 | 233 | m_clrRender = _tables["DT_BaseEntity"]["m_clrRender"]; 234 | 235 | Console.WriteLine("- m_clrRender => 0x" + m_clrRender.ToString("X")); 236 | 237 | } 238 | } 239 | } 240 | -------------------------------------------------------------------------------- /External-CSGO/Offsets/Signatures.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.API; 2 | using SimpleExternalCheatCSGO.Memory; 3 | using System; 4 | using System.Collections.Generic; 5 | using System.Linq; 6 | using System.Text; 7 | 8 | namespace SimpleExternalCheatCSGO.Offsets 9 | { 10 | public class Signatures 11 | { 12 | public int dw_LocalPlayer; 13 | 14 | public int dw_traceline; 15 | 16 | public int dw_entitylist; 17 | 18 | public int dw_lineThroughSmoke; 19 | 20 | public int dw_CLobbyScreen; 21 | 22 | public int dw_AcceptMatch; 23 | 24 | public int dw_MatchFound; 25 | 26 | public int dw_MatchAccepted; 27 | 28 | public int dw_ChangeClanTag; 29 | 30 | public int dw_RevealRankFn; 31 | 32 | public int dw_pInput; 33 | 34 | public int dw_ClientState; 35 | 36 | public int dw_viewangles; 37 | 38 | public int dw_lastoutgoingcommand; 39 | 40 | public int dw_bSendPackets; 41 | 42 | public int dw_GlobalVars; 43 | 44 | public int dw_bDormant; 45 | 46 | public int m_pStudioHdr; 47 | 48 | public int dw_GlowObjectManager; 49 | 50 | public int dw_forceJump; 51 | 52 | public int dw_isingame; 53 | 54 | public int m_dwMapDirectory; 55 | 56 | public int dw_HighestEntityIndex; 57 | 58 | public int dw_ModelPrecacheTable; 59 | 60 | public int dw_UserInfoTable; 61 | 62 | public int dw_Convarchartable; 63 | 64 | public int dw_enginecvar; 65 | 66 | public int dw_clientcmd; 67 | 68 | public int dw_inputsystem; 69 | 70 | public int dw_inputenabled; 71 | 72 | public int dw_WeaponTable; 73 | 74 | public int dw_WeaponTableIndex; 75 | 76 | public int dw_forceattack; 77 | 78 | public void Init() 79 | { 80 | dw_LocalPlayer = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "A3 ? ? ? ? C7 05 ? ? ? ? ? ? ? ? E8 ? ? ? ? 59 C3 6A ?", Globals._csgo.CSGOModules["client"], true, 0x1, true, 0) + 16; 81 | 82 | Console.WriteLine("- dw_LocalPlayer => 0x" + dw_LocalPlayer.ToString("X")); 83 | 84 | dw_traceline = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "55 8B EC 83 E4 F0 83 EC 7C 56 52", Globals._csgo.CSGOModules["client"], true); 85 | 86 | Console.WriteLine("- dw_traceline => 0x" + dw_traceline.ToString("X")); 87 | dw_traceline += (int)Globals._csgo.CSGOModules["client"].BaseAddress; 88 | 89 | dw_lineThroughSmoke = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "55 8B EC 83 EC 08 8B 15 ? ? ? ? 0F 57 C0", Globals._csgo.CSGOModules["client"], true); 90 | 91 | Console.WriteLine("- dw_lineThroughSmoke => 0x" + dw_lineThroughSmoke.ToString("X")); 92 | dw_lineThroughSmoke += (int)Globals._csgo.CSGOModules["client"].BaseAddress; 93 | 94 | dw_entitylist = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "BB ? ? ? ? 83 FF 01 0F 8C ? ? ? ? 3B F8", Globals._csgo.CSGOModules["client"], true, 0x1, true, 0); 95 | 96 | Console.WriteLine("- dw_entitylist => 0x" + dw_entitylist.ToString("X")); 97 | 98 | dw_CLobbyScreen = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "A1 ? ? ? ? 85 C0 74 0F 6A 00", Globals._csgo.CSGOModules["client"], true, 0x1, true, 0); 99 | 100 | Console.WriteLine("- dw_CLobbyScreen => 0x" + dw_CLobbyScreen.ToString("X")); 101 | 102 | dw_AcceptMatch = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "55 8B EC 83 E4 F8 83 EC 08 56 8B 35 ? ? ? ? 57 83 BE", Globals._csgo.CSGOModules["client"], true); 103 | 104 | Console.WriteLine("- dw_AcceptMatch => 0x" + dw_AcceptMatch.ToString("X")); 105 | dw_AcceptMatch += (int)Globals._csgo.CSGOModules["client"].BaseAddress; 106 | 107 | dw_MatchAccepted = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "89 B7 ? ? ? ? 8B 4F 04 85 C9", Globals._csgo.CSGOModules["client"], false, 0x2, true); 108 | 109 | Console.WriteLine("- dw_MatchAccepted => 0x" + dw_MatchAccepted.ToString("X")); 110 | 111 | dw_MatchFound = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "89 87 ? ? ? ? 8B 87 ? ? ? ? 3B F0", Globals._csgo.CSGOModules["client"], false, 0x2, true); 112 | 113 | Console.WriteLine("- dw_MatchFound => 0x" + dw_MatchFound.ToString("X")); 114 | 115 | dw_ChangeClanTag = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "53 56 57 8B DA 8B F9 FF 15", Globals._csgo.CSGOModules["engine"], true); 116 | 117 | Console.WriteLine("- dw_ChangeClanTag => 0x" + dw_ChangeClanTag.ToString("X")); 118 | dw_ChangeClanTag += (int)Globals._csgo.CSGOModules["engine"].BaseAddress; 119 | 120 | dw_RevealRankFn = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "55 8B EC 8B 0D ? ? ? ? 68", Globals._csgo.CSGOModules["client"], true); 121 | 122 | Console.WriteLine("- dw_RevealRankFn => 0x" + dw_RevealRankFn.ToString("X")); 123 | dw_RevealRankFn += (int)Globals._csgo.CSGOModules["client"].BaseAddress; 124 | 125 | dw_pInput = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "B9 ? ? ? ? F3 0F 11 04 24 FF 50 10", Globals._csgo.CSGOModules["client"], true, 0x1, true); 126 | 127 | Console.WriteLine("- dw_pInput => 0x" + dw_pInput.ToString("X")); 128 | 129 | dw_ClientState = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "A1 ? ? ? ? 33 D2 6A 00 6A 00 33 C9 89 B0", Globals._csgo.CSGOModules["engine"], true, 0x1, true); 130 | 131 | Console.WriteLine("- dw_ClientState => 0x" + dw_ClientState.ToString("X")); 132 | 133 | dw_viewangles = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "F3 0F 11 80 ? ? ? ? D9 46 04", Globals._csgo.CSGOModules["engine"], false, 0x4, true); 134 | 135 | Console.WriteLine("- dw_viewangles => 0x" + dw_viewangles.ToString("X")); 136 | 137 | dw_lastoutgoingcommand = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "C7 80 ? ? ? ? ? ? ? ? A1 ? ? ? ? F2 0F 10 05 ? ? ? ? F2 0F 11 80 ? ? ? ? FF 15", Globals._csgo.CSGOModules["engine"], false, 0x2, true); 138 | 139 | Console.WriteLine("- dw_lastoutgoingcommand => 0x" + dw_lastoutgoingcommand.ToString("X")); 140 | 141 | dw_bSendPackets = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "B3 01 8B 01 8B 40 10 FF D0 84 C0 74 0F 80 BF ? ? ? ? ? 0F 84", Globals._csgo.CSGOModules["engine"], true) + 0x1; 142 | 143 | Console.WriteLine("- dw_bSendPackets => 0x" + dw_bSendPackets.ToString("X")); 144 | 145 | dw_GlobalVars = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "68 ? ? ? ? 68 ? ? ? ? FF 50 08 85 C0", Globals._csgo.CSGOModules["engine"], true, 0x1, true); 146 | 147 | Console.WriteLine("- dw_GlobalVars => 0x" + dw_GlobalVars.ToString("X")); 148 | 149 | dw_bDormant = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "55 8B EC 53 8B 5D 08 56 8B F1 88 9E ? ? ? ? E8", Globals._csgo.CSGOModules["client"], false, 0xC, true); 150 | 151 | Console.WriteLine("- dw_bDormant => 0x" + dw_bDormant.ToString("X")); 152 | 153 | m_pStudioHdr = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "8B B6 ? ? ? ? 85 F6 74 05 83 3E 00 75 02 33 F6 F3 0F 10 44 24", Globals._csgo.CSGOModules["client"], false, 0x2, true); 154 | 155 | Console.WriteLine("- dw_pStudioHdr => 0x" + m_pStudioHdr.ToString("X")); 156 | 157 | dw_GlowObjectManager = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "A1 ? ? ? ? A8 01 75 4B", Globals._csgo.CSGOModules["client"], true, 0x1, true) + 4; 158 | 159 | Console.WriteLine("- dw_GlowObjectManager => 0x" + dw_GlowObjectManager.ToString("X")); 160 | 161 | dw_forceJump = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "89 0D ? ? ? ? 8B 0D ? ? ? ? 8B F2 8B C1 83 CE 08", Globals._csgo.CSGOModules["client"], true, 0x2, true); 162 | 163 | Console.WriteLine("- dw_forceJump => 0x" + dw_forceJump.ToString("X")); 164 | 165 | dw_forceattack = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "89 0D ? ? ? ? 8B 0D ? ? ? ? 8B F2 8B C1 83 CE 04", Globals._csgo.CSGOModules["client"], true, 0x2, true); 166 | 167 | Console.WriteLine("- dw_forceattack => 0x" + dw_forceattack.ToString("X")); 168 | 169 | dw_isingame = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "83 B8 ? ? ? ? ? 0F 94 C0 C3", Globals._csgo.CSGOModules["engine"], false, 0x2, true); 170 | 171 | Console.WriteLine("- dw_isingame => 0x" + dw_isingame.ToString("X")); 172 | 173 | m_dwMapDirectory = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "05 ? ? ? ? C3 CC CC CC CC CC CC CC 80 3D", Globals._csgo.CSGOModules["engine"], false, 0x1, true); 174 | 175 | Console.WriteLine("- dw_MapDirectory => 0x" + m_dwMapDirectory.ToString("X")); 176 | 177 | dw_ModelPrecacheTable = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "8B 8E ? ? ? ? 8B D0 85 C9", Globals._csgo.CSGOModules["engine"], false, 0x2, true); 178 | 179 | Console.WriteLine("- dw_ModelPrecacheTable => 0x" + dw_ModelPrecacheTable.ToString("X")); 180 | 181 | dw_UserInfoTable = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "8B 89 ? ? ? ? 85 C9 0F 84 ? ? ? ? 8B 01", Globals._csgo.CSGOModules["engine"], false, 0x2, true); 182 | 183 | Console.WriteLine("- dw_UserInfoTable => 0x" + dw_UserInfoTable.ToString("X")); 184 | 185 | dw_Convarchartable = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "8B 3C 85", Globals._csgo.CSGOModules["vstdlib"], true, 0x3, true); 186 | 187 | Console.WriteLine("- dw_Convarchartable => 0x" + dw_Convarchartable.ToString("X")); 188 | 189 | dw_enginecvar = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "8B 0D ? ? ? ? C7 05", Globals._csgo.CSGOModules["vstdlib"], true, 0x2, true); 190 | 191 | Console.WriteLine("- dw_enginecvar => 0x" + dw_enginecvar.ToString("X")); 192 | 193 | dw_clientcmd = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "55 8B EC A1 ? ? ? ? 33 C9 8B 55 08", Globals._csgo.CSGOModules["engine"], true); 194 | 195 | Console.WriteLine("- dw_clientcmd => 0x" + dw_clientcmd.ToString("X")); 196 | dw_clientcmd += (int)Globals._csgo.CSGOModules["engine"].BaseAddress; 197 | 198 | dw_WeaponTable = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "B9 ? ? ? ? 6A 00 FF 50 08 C3", Globals._csgo.CSGOModules["client"], true, 0x1, true); 199 | 200 | Console.WriteLine("- dw_WeaponTable => 0x" + dw_WeaponTable.ToString("X")); 201 | 202 | dw_WeaponTableIndex = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "39 86 ? ? ? ? 74 06 89 86 ? ? ? ? 8B 86", Globals._csgo.CSGOModules["client"], false, 0x2, true); 203 | 204 | Console.WriteLine("- dw_WeaponTableIndex => 0x" + dw_WeaponTableIndex.ToString("X")); 205 | 206 | dw_inputsystem = PatternScanner.FindPattern(Globals._csgo.ProcessHandle, "8B 0D ? ? ? ? FF 75 10", Globals._csgo.CSGOModules["inputsystem"], true, 0x2, true); 207 | 208 | Console.WriteLine("- dw_inputsystem => 0x" + dw_inputsystem.ToString("X")); 209 | 210 | dw_inputenabled = MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, 211 | MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, 212 | MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, 213 | MemoryAPI.ReadFromProcess(Globals._csgo.ProcessHandle, Globals._csgo.CSGOModules["inputsystem"].BaseAddress + dw_inputsystem)) 214 | + 0x2C /*(11 * 4)*/) + 0x8); 215 | 216 | Console.WriteLine("- dw_inputenabled => 0x" + dw_inputenabled.ToString("X")); 217 | } 218 | } 219 | } 220 | -------------------------------------------------------------------------------- /External-CSGO/MainThread.cs: -------------------------------------------------------------------------------- 1 | using SimpleExternalCheatCSGO.SDK; 2 | using SimpleExternalCheatCSGO.Settings; 3 | using SimpleExternalCheatCSGO.Structs; 4 | using SimpleExternalCheatCSGO.CodeInjection; 5 | using System; 6 | using System.Collections.Generic; 7 | using System.Linq; 8 | using System.Text; 9 | using System.Threading; 10 | using SimpleExternalCheatCSGO.API; 11 | using System.Runtime.InteropServices; 12 | using SimpleExternalCheatCSGO.SDK.MiscClasses; 13 | using SimpleExternalCheatCSGO.Util; 14 | using SimpleExternalCheatCSGO.Memory; 15 | using System.Reflection; 16 | 17 | namespace SimpleExternalCheatCSGO 18 | { 19 | public static class MainThread 20 | { 21 | public static IClientEntityList g_EntityList; 22 | public static CInput g_Input; 23 | public static CConVarManager g_ConVar; 24 | public static CInputSystem g_InputSystem; 25 | 26 | public static CClientState g_pEngineClient = new CClientState(); 27 | public static CGlobalVarsBase g_GlobalVars = new CGlobalVarsBase(); 28 | public static CGlowObjectManager g_GlowObjectManager = new CGlowObjectManager(); 29 | public static CLocalPlayer pLocal = new CLocalPlayer(); 30 | public static CWeaponTable g_WeaponTable = new CWeaponTable(); 31 | 32 | public static Vector last_vecPunch = new Vector(0, 0, 0); 33 | 34 | public static bool[] lastKeyState = new bool[255]; 35 | public static bool[] currentKeyState = new bool[255]; 36 | 37 | public static int lastOutgoingcommand; 38 | 39 | public static int chockedPackets = 0; 40 | 41 | public static bool bLastFakeLag = false; 42 | 43 | public static bool bDoForceUpdate = false; 44 | 45 | public static bool bSwapClantag = false; 46 | 47 | public static bool bSwapNamestealer = false; 48 | 49 | public static string LastTag = ""; 50 | 51 | public static char[] Tag = new char[15]; 52 | 53 | public static CBasePlayer pLastTarget = null; 54 | 55 | public static int BreakTickCount = 0; 56 | 57 | public static int ClantagTickCount = 0; 58 | 59 | public static int NamestealerTickCount = 0; 60 | 61 | public static bool WaitBreak = false; 62 | 63 | public static bool IsKeyPress(int key) 64 | { 65 | return !lastKeyState[key] && currentKeyState[key]; 66 | } 67 | 68 | public static bool IsKeyState(int key) 69 | { 70 | return currentKeyState[key]; 71 | } 72 | 73 | public static void Update() 74 | { 75 | g_GlobalVars.Update(); 76 | pLocal.Update(); 77 | g_EntityList.Update(); 78 | g_GlowObjectManager.Update(); 79 | g_Input.Update(); 80 | g_WeaponTable.Update(); 81 | } 82 | 83 | public static Thread TriggerThread; 84 | 85 | public static void StartTrigger() 86 | { 87 | Thread.Sleep(500); 88 | 89 | while (true) 90 | { 91 | #region TriggerBOT 92 | if (pLocal.pThis != IntPtr.Zero && g_pEngineClient.IsInGame() && pLocal.GetHealth() > 0) 93 | { 94 | var LocalWeapon = pLocal.GetActiveWeapon(); 95 | 96 | var LocalWeaponID = LocalWeapon.GetIndex(); 97 | 98 | var LocalWeaponConfig = Config.GetWeaponConfig(LocalWeaponID); 99 | 100 | 101 | if (LocalWeaponConfig.bTriggerBotEnabled && Config.TriggerBotEnabled) 102 | { 103 | bool isKeyPressed = IsKeyState(Config.iTriggerBotKey) || IsKeyState(Config.iTriggerBotWorkWithAimKey); 104 | 105 | if (LocalWeapon.IsKnife() || LocalWeapon.IsBomb() || LocalWeapon.IsGrenade()) 106 | isKeyPressed = false; 107 | 108 | if (isKeyPressed) 109 | { 110 | var cross = pLocal.GetCrosshairID(); 111 | 112 | if (cross > 0 && cross <= 64) 113 | { 114 | CBasePlayer pTarget = new CBasePlayer(g_EntityList.GetEntityByIndex(cross)); 115 | if (pTarget.pThis != IntPtr.Zero && !pTarget.IsDormant() && pTarget.GetHealth() > 0 && !pTarget.HasGunGameImmunity()) 116 | { 117 | if (LocalWeaponConfig.bFriendlyFire || pLocal.GetTeamNum() != pTarget.GetTeamNum()) 118 | { 119 | Thread.Sleep(LocalWeaponConfig.iDelay); 120 | g_pEngineClient.OneTickAttack(); 121 | Thread.Sleep(LocalWeaponConfig.iPause); 122 | } 123 | } 124 | } 125 | } 126 | } 127 | } 128 | #endregion 129 | Thread.Sleep(5); 130 | } 131 | } 132 | 133 | public static void GlowESP(Team iLocalTeamNum, bool bLocalPlayerAlive) 134 | { 135 | if (Config.ESPEnabled && (Config.bGlowWeapons || Config.bGlowBomb) && Config.bGlowEnabled && (!Config.bGlowAfterDeath || !bLocalPlayerAlive)) 136 | { 137 | for (int i = 0; i < g_GlowObjectManager.Size(); ++i) 138 | { 139 | var pObject = g_GlowObjectManager.GetEntityByGlowIndex(i); 140 | 141 | var class_id = pObject.GetClassID(); 142 | 143 | #region PlayerESP 144 | if (class_id == CSGOClassID.CCSPlayer) 145 | { 146 | var pEntity = new CBasePlayer(pObject.pThis); 147 | 148 | int EntityHealth = pEntity.GetHealth(); 149 | 150 | Team EntityTeamnum = pEntity.GetTeamNum(); 151 | 152 | if (!pEntity.IsDormant() && EntityHealth > 0) 153 | { 154 | bool bFillerGood = true; 155 | if (iLocalTeamNum == EntityTeamnum && !Config.bGlowAlly) 156 | bFillerGood = false; 157 | else if (iLocalTeamNum != EntityTeamnum && !Config.bGlowEnemy) 158 | bFillerGood = false; 159 | if (bFillerGood) 160 | { 161 | Color color = new Color(); 162 | switch (Config.iGlowType) 163 | { 164 | case GlowType.Color: 165 | color = iLocalTeamNum == EntityTeamnum ? Config.bGlowAllyVisibleColor : Config.bGlowEnemyVisibleColor; 166 | break; 167 | case GlowType.Vis_Color: 168 | bool bVisible = pEntity.IsSpottedByMask(pLocal); 169 | if (bVisible) 170 | color = iLocalTeamNum == EntityTeamnum ? Config.bGlowAllyVisibleColor : Config.bGlowEnemyVisibleColor; 171 | else 172 | color = iLocalTeamNum == EntityTeamnum ? Config.bGlowAllyColor : Config.bGlowEnemyColor; 173 | break; 174 | case GlowType.Health: 175 | color = new Color(255 - (EntityHealth * 2.55f), EntityHealth * 2.55f, 0, 255); 176 | break; 177 | } 178 | g_GlowObjectManager.RegisterGlowObject(pEntity, color, Config.bInnerGlow, Config.bFullRender); 179 | } 180 | } 181 | } 182 | #endregion 183 | 184 | #region BombESP 185 | else if (class_id == CSGOClassID.CPlantedC4 || class_id == CSGOClassID.CC4) 186 | g_GlowObjectManager.RegisterGlowObject(i, 250, 0, 0, 200, Config.bInnerGlow, Config.bFullRender); 187 | #endregion 188 | 189 | #region WeaponESP 190 | else if (class_id != CSGOClassID.CBaseWeaponWorldModel && (pObject.GetNetworkName().Contains("Weapon") || class_id == CSGOClassID.CAK47 || class_id == CSGOClassID.CDEagle)) 191 | g_GlowObjectManager.RegisterGlowObject(i, 200, 0, 50, 200, Config.bInnerGlow, Config.bFullRender); 192 | else if (class_id == CSGOClassID.CBaseCSGrenadeProjectile || class_id == CSGOClassID.CDecoyProjectile || 193 | class_id == CSGOClassID.CMolotovProjectile || class_id == CSGOClassID.CSmokeGrenadeProjectile) 194 | g_GlowObjectManager.RegisterGlowObject(i, 200, 0, 50, 200, Config.bInnerGlow, Config.bFullRender); 195 | else if (class_id == CSGOClassID.CBaseAnimating && iLocalTeamNum == Team.CT) 196 | g_GlowObjectManager.RegisterGlowObject(i, 100, 100, 200, 200, Config.bInnerGlow, Config.bFullRender); 197 | #endregion 198 | } 199 | } 200 | } 201 | 202 | public static void Start() 203 | { 204 | GC.Collect(); 205 | 206 | g_EntityList = new IClientEntityList(); 207 | g_Input = new CInput(); 208 | g_ConVar = new CConVarManager(); 209 | g_InputSystem = new CInputSystem(); 210 | 211 | var dwMouseEnabled = new ConVar("cl_mouseenable"); 212 | 213 | var name = new ConVar("name"); 214 | 215 | TriggerThread = new Thread(new ThreadStart(StartTrigger)); 216 | TriggerThread.IsBackground = true; 217 | TriggerThread.Start(); 218 | 219 | while (true) 220 | { 221 | try 222 | { 223 | g_pEngineClient.Update(); 224 | 225 | if (g_pEngineClient.IsInGame()) 226 | { 227 | bool bMouseEnabled = dwMouseEnabled.GetBool(); 228 | 229 | #region UpdateRegion 230 | 231 | Update(); 232 | 233 | bool bLocalPlayerAlive = pLocal.GetHealth() > 0; 234 | Team iLocalTeamNum = pLocal.GetTeamNum(); 235 | 236 | Vector localPlayerEyePosition = pLocal.GetEyePosition(); 237 | 238 | Vector viewangles = g_pEngineClient.GetViewAngles(); 239 | 240 | bool FindNewAimBotTarget = false; 241 | 242 | var LocalWeapon = pLocal.GetActiveWeapon(); 243 | 244 | var LocalWeaponID = LocalWeapon.GetWeaponID(); 245 | 246 | var LocalWeaponConfig = Config.GetWeaponConfig(LocalWeaponID); 247 | 248 | bool bAimBotKey = IsKeyState(Config.iAimbotKey) || IsKeyState(Config.iTriggerBotWorkWithAimKey); 249 | 250 | if (LocalWeapon.IsKnife() || LocalWeapon.IsBomb() || LocalWeapon.IsGrenade()) 251 | bAimBotKey = false; 252 | 253 | if (!bLocalPlayerAlive) 254 | bAimBotKey = false; 255 | 256 | if (LocalWeapon.GetAvailableAmmo() <= 0) 257 | bAimBotKey = false; 258 | 259 | if (!Config.AimbotEnabled) 260 | bAimBotKey = false; 261 | 262 | if (!bAimBotKey) 263 | { 264 | WaitBreak = false; 265 | pLastTarget = null; 266 | } 267 | 268 | if (LocalWeaponConfig.bAimbotEnabled && bAimBotKey && pLastTarget == null) 269 | FindNewAimBotTarget = true; 270 | 271 | if (pLastTarget != null && LocalWeaponConfig.bVisibleCheck && !pLastTarget.IsSpottedByMask(pLocal)) 272 | FindNewAimBotTarget = true; 273 | 274 | #endregion 275 | 276 | #region KeyStateCheck 277 | for (int i = 0; i < 255; ++i) 278 | currentKeyState[i] = WinAPI.GetAsyncKeyState(i) != 0; 279 | 280 | if (Config.iGlowToogleKey != -1 && IsKeyPress(Config.iGlowToogleKey)) 281 | Config.bGlowEnabled = !Config.bGlowEnabled; 282 | if (Config.iPanicKey != -1 && IsKeyPress(Config.iPanicKey)) 283 | { 284 | Globals._csgo.ProcessHandle = IntPtr.Zero; 285 | Globals._csgo.CheckHandle(); 286 | } 287 | #endregion 288 | 289 | #region GlowESP 290 | 291 | GlowESP(iLocalTeamNum, bLocalPlayerAlive); 292 | 293 | #endregion 294 | 295 | #region ForeachPlayerList 296 | CBasePlayer pTarget = null; 297 | float fDistance = -1; 298 | List names_to_steal = new List(); 299 | 300 | foreach (var pPointer in g_EntityList.pPlayerList) 301 | { 302 | CBasePlayer pEntity = new CBasePlayer(pPointer); 303 | 304 | int EntityHealth = pEntity.GetHealth(); 305 | 306 | Team EntityTeamnum = pEntity.GetTeamNum(); 307 | 308 | #region Namestealer 309 | if (Config.MiscEnabled && Config.bNameStealerEnabled && !Config.bNameStealerCustom) 310 | if (Config.iNameStealerType == 0 && EntityTeamnum == iLocalTeamNum) 311 | names_to_steal.Add(new string(g_pEngineClient.GetPlayerInfo(pEntity.GetIndex()).m_szPlayerName)); 312 | else if (Config.iNameStealerType == 1 && EntityTeamnum != iLocalTeamNum) 313 | names_to_steal.Add(new string(g_pEngineClient.GetPlayerInfo(pEntity.GetIndex()).m_szPlayerName)); 314 | else if (Config.iNameStealerType == 2) 315 | names_to_steal.Add(new string(g_pEngineClient.GetPlayerInfo(pEntity.GetIndex()).m_szPlayerName)); 316 | #endregion 317 | 318 | #region Radar 319 | if (Config.ESPEnabled && Config.bRadarEnabled) 320 | pEntity.SetSpotted(true); 321 | #endregion 322 | 323 | #region RenderColor 324 | if (Config.ESPEnabled && Config.bCHAMSGOWNOPlayer) 325 | if (EntityTeamnum == iLocalTeamNum) 326 | pEntity.SetRenderColor(Config.bChamsAllyColor); 327 | else 328 | pEntity.SetRenderColor(Config.bChamsEnemyColor); 329 | #endregion 330 | 331 | #region GlowESPOnlyPlayers 332 | if (Config.ESPEnabled && !Config.bGlowWeapons && !Config.bGlowBomb && Config.bGlowEnabled && (!Config.bGlowAfterDeath || !bLocalPlayerAlive)) 333 | { 334 | if (!pEntity.IsDormant() && EntityHealth > 0) 335 | { 336 | bool bFillerGood = true; 337 | if (iLocalTeamNum == EntityTeamnum && !Config.bGlowAlly) 338 | bFillerGood = false; 339 | else if (iLocalTeamNum != EntityTeamnum && !Config.bGlowEnemy) 340 | bFillerGood = false; 341 | if (bFillerGood) 342 | { 343 | Color color = new Color(); 344 | switch (Config.iGlowType) 345 | { 346 | case GlowType.Color: 347 | color = iLocalTeamNum == EntityTeamnum ? Config.bGlowAllyVisibleColor : Config.bGlowEnemyVisibleColor; 348 | break; 349 | case GlowType.Vis_Color: 350 | bool bVisible = pEntity.IsSpottedByMask(pLocal); 351 | if (bVisible) 352 | color = iLocalTeamNum == EntityTeamnum ? Config.bGlowAllyVisibleColor : Config.bGlowEnemyVisibleColor; 353 | else 354 | color = iLocalTeamNum == EntityTeamnum ? Config.bGlowAllyColor : Config.bGlowEnemyColor; 355 | break; 356 | case GlowType.Health: 357 | color = new Color(255 - (EntityHealth * 2.55f), EntityHealth * 2.55f, 0, 255); 358 | break; 359 | } 360 | g_GlowObjectManager.RegisterGlowObject(pEntity, color, Config.bInnerGlow, Config.bFullRender); 361 | } 362 | } 363 | } 364 | #endregion 365 | 366 | #region FindAimBotTarget 367 | if (FindNewAimBotTarget) 368 | { 369 | if (!pEntity.IsDormant() && EntityHealth > 0 && !pEntity.HasGunGameImmunity()) 370 | { 371 | if (LocalWeaponConfig.bFriendlyFire || EntityTeamnum != iLocalTeamNum) 372 | { 373 | if (!LocalWeaponConfig.bVisibleCheck || pEntity.IsSpottedByMask(pLocal)) 374 | { 375 | if (!LocalWeaponConfig.bTargetOnGroundCheck || pEntity.IsOnGround()) 376 | { 377 | float cur_distance = MathUtil.FovToPlayer(localPlayerEyePosition, viewangles, pEntity, 0); 378 | 379 | if (cur_distance <= LocalWeaponConfig.flAimbotFov) 380 | { 381 | if (fDistance == -1 || cur_distance < fDistance) 382 | { 383 | fDistance = cur_distance; 384 | pTarget = pEntity; 385 | } 386 | } 387 | } 388 | } 389 | } 390 | } 391 | } 392 | #endregion 393 | } 394 | #endregion 395 | 396 | #region LocalPlayerFunctions 397 | 398 | #region BunnyHop 399 | 400 | bool bLocalIsOnGround = pLocal.IsOnGround(); 401 | 402 | if (bMouseEnabled && Config.MiscEnabled && Config.bBunnyHopEnabled && IsKeyState(Config.iBunnyHopKey) && pLocal.GetVelocity() > 45f) 403 | { 404 | if (bLocalIsOnGround) 405 | g_pEngineClient.PlusJump(); 406 | else if (g_pEngineClient.GetJumpState() == 5) 407 | g_pEngineClient.MinusJump(); 408 | } 409 | #endregion 410 | 411 | #region FovChanger 412 | 413 | if (Config.MiscEnabled && Config.bFovChangerEnabled && !pLocal.IsScoped()) 414 | pLocal.SetFov(Config.FovValue); 415 | else if (!pLocal.IsScoped()) 416 | pLocal.ResetFov(); 417 | #endregion 418 | 419 | #endregion 420 | 421 | #region Aimbot 422 | bool b_do_RCS = false; 423 | bool b_do_Aimbot = false; 424 | if (FindNewAimBotTarget && fDistance != -1) 425 | pLastTarget = pTarget; 426 | 427 | if (LocalWeaponConfig.bAimbotEnabled && bAimBotKey && pLastTarget != null) 428 | { 429 | if (pLastTarget.GetHealth() <= 0) 430 | { 431 | if (!WaitBreak) 432 | { 433 | BreakTickCount = Environment.TickCount + LocalWeaponConfig.iAimbotDeathBreak; 434 | WaitBreak = true; 435 | } 436 | else if (BreakTickCount <= Environment.TickCount) 437 | { 438 | WaitBreak = false; 439 | pLastTarget = null; 440 | } 441 | } 442 | else 443 | { 444 | List hitboxes = new List(); 445 | 446 | if ((LocalWeaponConfig.iBones & (int)BoneSelector.Head) != 0) 447 | hitboxes.Add(pLastTarget.GetHitboxPosition((int)HitboxList.HITBOX_HEAD)); 448 | if ((LocalWeaponConfig.iBones & (int)BoneSelector.Neck) != 0) 449 | hitboxes.Add(pLastTarget.GetHitboxPosition((int)HitboxList.HITBOX_NECK)); 450 | if ((LocalWeaponConfig.iBones & (int)BoneSelector.Chest) != 0) 451 | hitboxes.Add(pLastTarget.GetHitboxPosition((int)HitboxList.HITBOX_CHEST)); 452 | if ((LocalWeaponConfig.iBones & (int)BoneSelector.Stomach) != 0) 453 | hitboxes.Add(pLastTarget.GetHitboxPosition((int)HitboxList.HITBOX_BODY)); 454 | 455 | float best = -1; 456 | Vector calcang = new Vector(0, 0, 0); 457 | 458 | for (int i = 0; i < hitboxes.Count(); i++) 459 | { 460 | Vector temp_calcang = MathUtil.CalcAngle(localPlayerEyePosition, hitboxes[i]); 461 | Vector delta_bone = viewangles - temp_calcang; 462 | delta_bone.NormalizeAngles(); 463 | float len = (float)delta_bone.Lenght2D(); 464 | if (best == -1 || len < best) 465 | { 466 | best = len; 467 | calcang = temp_calcang; 468 | } 469 | } 470 | 471 | Vector current_punch = new Vector(last_vecPunch._x * 2f, last_vecPunch._y * (LocalWeaponConfig.Horizontal / 5f), 0); 472 | calcang -= current_punch; 473 | calcang.NormalizeAngles(); 474 | Vector delta = calcang - viewangles; 475 | delta.NormalizeAngles(); 476 | if (LocalWeaponConfig.flAimbotSmooth != 0f) 477 | calcang = viewangles + (delta / LocalWeaponConfig.flAimbotSmooth); 478 | calcang.NormalizeAngles(); 479 | viewangles = calcang; 480 | b_do_Aimbot = true; 481 | } 482 | } 483 | #endregion 484 | 485 | #region RecoilControlSystem 486 | if (Config.AimbotEnabled && LocalWeaponConfig.Vertical != 0f && LocalWeaponConfig.Horizontal != 0f && LocalWeaponConfig.bRCS) 487 | { 488 | if (pLocal.GetShootsFired() > 1 && IsKeyState(1) && LocalWeapon.GetAvailableAmmo() > 0) 489 | { 490 | Vector Punch = pLocal.GetPunch(); 491 | 492 | float[] multiple = { LocalWeaponConfig.Vertical / 5f, LocalWeaponConfig.Horizontal / 5f }; 493 | 494 | Vector current_RCS_Punch = new Vector((Punch._x * multiple[0]) - (last_vecPunch._x * multiple[0]), (Punch._y * multiple[1]) - (last_vecPunch._y * multiple[1]), 0); 495 | Vector ViewAngle_RCS = viewangles - current_RCS_Punch; 496 | ViewAngle_RCS.NormalizeAngles(); 497 | Vector delta = (viewangles - ViewAngle_RCS); 498 | delta.NormalizeAngles(); 499 | 500 | if ((float)delta.Lenght2D() <= 3.1f) 501 | viewangles = ViewAngle_RCS; 502 | 503 | last_vecPunch = Punch; 504 | 505 | b_do_RCS = true; 506 | } 507 | else 508 | last_vecPunch = new Vector(0, 0, 0); 509 | } 510 | #endregion 511 | 512 | #region ShowRanks 513 | if (Config.ESPEnabled && Config.bShowRanks) 514 | { 515 | var Command = g_pEngineClient.GetLastOutGoingCommand(); 516 | 517 | if (Command != lastOutgoingcommand) 518 | { 519 | var VerifiedCommandSystem = g_Input.GetVerifiedUserCmd(); 520 | 521 | var VerifiedCommand = VerifiedCommandSystem.GetVerifiedUserCmdBySequence(Command); 522 | 523 | if ((VerifiedCommand.m_cmd.buttons & (1 << 16)) != 0) 524 | RevealRank.Do(); 525 | } 526 | 527 | lastOutgoingcommand = Command; 528 | } 529 | #endregion 530 | 531 | #region FakeLag 532 | if (Config.MiscEnabled && Config.bFakeLag) 533 | { 534 | if (chockedPackets < Config.iFakeLagPower) 535 | { 536 | g_pEngineClient.SetSendPacket(false); 537 | chockedPackets++; 538 | } 539 | else 540 | { 541 | g_pEngineClient.SetSendPacket(true); 542 | chockedPackets = 0; 543 | } 544 | } 545 | else if (Config.bFakeLag != bLastFakeLag) 546 | g_pEngineClient.SetSendPacket(true); 547 | 548 | bLastFakeLag = Config.bFakeLag; 549 | #endregion 550 | 551 | #region SetAngles 552 | if (b_do_Aimbot || b_do_RCS) 553 | g_pEngineClient.SetViewAngles(viewangles); 554 | #endregion 555 | 556 | #region ClanTagChanger 557 | if (Config.MiscEnabled && Config.bClanTagChangerEnabled) 558 | { 559 | if (Environment.TickCount > ClantagTickCount) 560 | { 561 | if (Config.iClanTagChanger == 0) 562 | { 563 | if (bSwapClantag) 564 | SendClantag.Do(Config.szClanTag1, "ozon"); 565 | else 566 | SendClantag.Do(Config.szClanTag2, "ozon"); 567 | bSwapClantag = !bSwapClantag; 568 | } 569 | else if (Config.iClanTagChanger == 1) 570 | { 571 | if (LastTag != Config.szClanTag1) 572 | { 573 | LastTag = Config.szClanTag1; 574 | int start = 7 - LastTag.Length / 2; 575 | for (int i = 0; i < 15; i++) 576 | { 577 | if (i < start || i >= start + LastTag.Length) 578 | Tag[i] = ' '; 579 | else 580 | Tag[i] = LastTag[i - start]; 581 | } 582 | SendClantag.Do(new string(Tag), "ozon"); 583 | } 584 | else 585 | { 586 | char temp_var; 587 | 588 | for (int i = 0; i < (15 - 1); i++) 589 | { 590 | temp_var = Tag[15 - 1]; 591 | Tag[15 - 1] = Tag[i]; 592 | Tag[i] = temp_var; 593 | } 594 | SendClantag.Do(new string(Tag), "ozon"); 595 | } 596 | } 597 | else if (Config.iClanTagChanger == 2) 598 | SendClantag.Do(DateTime.Now.ToString("hh:mm:ss"), "ozon"); 599 | ClantagTickCount = Environment.TickCount + Config.iClantTagDelay; 600 | } 601 | } 602 | #endregion 603 | 604 | #region Namestealer 605 | if (Config.MiscEnabled && Config.bNameStealerEnabled) 606 | { 607 | if (Environment.TickCount > NamestealerTickCount) 608 | { 609 | if (Config.iNameStealerMode == 0) 610 | { 611 | name.ClearCallbacks(); 612 | if (Config.bNameStealerCustom) 613 | { 614 | if (bSwapNamestealer) 615 | ClientCmd.Do("name \"" + Config.szName1 + "\""); 616 | else 617 | ClientCmd.Do("name \"" + Config.szName2 + "\""); 618 | bSwapNamestealer = !bSwapNamestealer; 619 | } 620 | else 621 | ClientCmd.Do("name \"" + names_to_steal[RandomHelper.RandomInt(0, names_to_steal.Count - 1)] + " \""); 622 | } 623 | NamestealerTickCount = Environment.TickCount + Config.iNameStealerDelay; 624 | } 625 | } 626 | #endregion 627 | 628 | #region AutoPistol 629 | if (Config.MiscEnabled && bMouseEnabled && Config.AutoPistol && IsKeyState(0x01) && LocalWeaponID != 64 && LocalWeapon.IsPistol()) 630 | { 631 | if (g_pEngineClient.GetAttackState() == 5) 632 | g_pEngineClient.MinusAttack(); 633 | else 634 | g_pEngineClient.PlusAttack(); 635 | } 636 | #endregion 637 | 638 | #region ForceUpdate 639 | if (bDoForceUpdate) 640 | { 641 | g_pEngineClient.ForceUpdate(); 642 | bDoForceUpdate = false; 643 | } 644 | #endregion 645 | 646 | Buffer.BlockCopy(currentKeyState, 0, lastKeyState, 0, 255); 647 | } 648 | else 649 | { 650 | if (!Globals._csgo.CheckHandle()) 651 | break; 652 | 653 | Thread.Sleep(1000); 654 | 655 | #region AutoAccept 656 | if (Config.MiscEnabled && Config.bAutoAccept) 657 | { 658 | if (UTILS_GAME.MatchFound()) 659 | { 660 | Thread.Sleep(1500); 661 | UTILS_GAME.AcceptMatch(); 662 | } 663 | } 664 | #endregion 665 | } 666 | } 667 | catch 668 | { 669 | if (!Globals._csgo.CheckHandle()) 670 | break; 671 | } 672 | Thread.Sleep(5); 673 | } 674 | Program.StartCheat(); 675 | } 676 | 677 | } 678 | } 679 | --------------------------------------------------------------------------------