zoukankan      html  css  js  c++  java
  • CSGO项目

    #include <Windows.h>
    #include <sstream>
    #include <iostream> 
    #include <math.h>  
    #include "HackProcess.h"
    #include <vector>
    #include <algorithm>   
    
    CHackProcess fProcess;  
    using namespace std;  
    
    #define F6_Key 0x75
    
    #define RIGHT_MOUSE 0x02
    
    int NumOfPlayers = 32;
    
    const DWORD dw_PlayerCountOffs = 0x7994E0;//Engine.dll
    
    
    //自己人物模块偏移
    const DWORD Player_Base = 0x4C5B3B4;//client_panorama.dll
    
    //阵营
    const DWORD dw_mTeamOffset = 0xE8;//client_panorama.dll
    //血量
    const DWORD dw_Health = 0xF4;//client_panorama.dll
    
    //人物坐标偏移
    const DWORD dw_Pos = 0x12C;//client_panorama.dll
    
    //敌人地址
    const DWORD EntityPlayer_Base = 0x4c5b3bc;//client_panorama.dll
    
    //敌人结构偏移
    const DWORD EntityLoopDistance = 0x8;
    
    //鼠标指针
    const DWORD dw_m_angRotation = 0x461A9C;
    RECT m_Rect; 
    
    HDC HDC_Desktop;
    
    HBRUSH EnemyBrush;
    HFONT Font; 
    
    //矩阵地址
    const DWORD dw_vMatrix = 0x4C2CD04 + 0xb0;
    const DWORD dw_antiFlick = 0x58C2B8;
    
    
    HWND TargetWnd;
    HWND Handle;
    DWORD DwProcId;
    
    COLORREF SnapLineCOLOR;
    COLORREF TextCOLOR; 
    
    typedef struct
    {
        float flMatrix [4][4];
    }WorldToScreenMatrix_t;
    
    float Get3dDistance(float * myCoords, float * enemyCoords)
    {
        return sqrt(
            pow(double(enemyCoords[0] - myCoords[0]), 2.0) +
            pow(double(enemyCoords[1] - myCoords[1]), 2.0) +
            pow(double(enemyCoords[2] - myCoords[2]), 2.0));
    
    }
    
    
    void SetupDrawing(HDC hDesktop, HWND handle)
    {
        HDC_Desktop =hDesktop;
        Handle = handle;
        EnemyBrush = CreateSolidBrush(RGB(255, 0, 0));
        //Color
        SnapLineCOLOR = RGB(0, 0, 255);
        TextCOLOR = RGB(0, 255, 0);
    }
    struct MyPlayer_t  
    { 
        DWORD CLocalPlayer; 
        int Team; 
        int Health; 
        WorldToScreenMatrix_t WorldToScreenMatrix;
        float Position[3]; 
        int flickerCheck;
        void ReadInformation() 
        {
            // 读自己地址
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + Player_Base), &CLocalPlayer, sizeof(DWORD), 0);
            // 读阵营
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_mTeamOffset), &Team, sizeof(int), 0);
            // 读血量   
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_Health), &Health, sizeof(int), 0); 
            // 读坐标
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_Pos), &Position, sizeof(float[3]), 0); 
    
            //读房间人数
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_PlayerCountOffs), &NumOfPlayers, sizeof(int), 0); 
    
    
    
            //anti flicker
            //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_antiFlick), &flickerCheck, sizeof(int), 0); 
            //VMATRIX
            //if(flickerCheck == 0)
            //{
    
            //读矩阵
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_vMatrix), &WorldToScreenMatrix, sizeof(WorldToScreenMatrix), 0);
            //}
            //-1A4 = ANTI FLICKER
            //Engine.dll+0x58C45C
        }
    }MyPlayer;    
    
    
    
    
    
    
    //ENemy struct
    struct PlayerList_t 
    {
        DWORD CBaseEntity; 
        int Team; 
        int Health; 
        float Position[3]; 
        float AimbotAngle[3]; 
        char Name[39]; 
    
        void ReadInformation(int Player) 
        {
            // 读敌人地址
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + EntityPlayer_Base  + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);
            // 读阵营 
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_mTeamOffset), &Team, sizeof(int), 0);
            // 读血量    
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_Health), &Health, sizeof(int), 0); 
            // 读坐标
            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_Pos), &Position, sizeof(float[3]), 0); 
         }
    }PlayerList[32];  
    
    
    bool WorldToScreen(float * from, float * to)
    {
        float w = 0.0f;
    
        to[0] = MyPlayer.WorldToScreenMatrix.flMatrix[0][0] * from[0] + MyPlayer.WorldToScreenMatrix.flMatrix[0][1] * from[1] + MyPlayer.WorldToScreenMatrix.flMatrix[0][2] * from[2] + MyPlayer.WorldToScreenMatrix.flMatrix[0][3];
        to[1] = MyPlayer.WorldToScreenMatrix.flMatrix[1][0] * from[0] + MyPlayer.WorldToScreenMatrix.flMatrix[1][1] * from[1] + MyPlayer.WorldToScreenMatrix.flMatrix[1][2] * from[2] + MyPlayer.WorldToScreenMatrix.flMatrix[1][3];
        w = MyPlayer.WorldToScreenMatrix.flMatrix[3][0] * from[0] + MyPlayer.WorldToScreenMatrix.flMatrix[3][1] * from[1] + MyPlayer.WorldToScreenMatrix.flMatrix[3][2] * from[2] + MyPlayer.WorldToScreenMatrix.flMatrix[3][3];
    
        if(w < 0.01f)
            return false;
    
        float invw = 1.0f / w;
        to[0] *= invw;
        to[1] *= invw;
    
        int width = (int)(m_Rect.right - m_Rect.left);
        int height = (int)(m_Rect.bottom - m_Rect.top);
    
        float x = width/2;
        float y = height/2;
    
        x += 0.5 * to[0] * width + 0.5;
        y -= 0.5 * to[1] * height + 0.5;
    
        to[0] = x+ m_Rect.left;
        to[1] = y+ m_Rect.top ;
    
        return true;
    }
    
    
    
    
    
    
    
    
    
    void DrawFilledRect(int x, int y, int w, int h)
    {
    
        RECT rect = { x, y, x + w, y + h }; 
    
        FillRect(HDC_Desktop, &rect, EnemyBrush);
    }
    
    
    void DrawBorderBox(int x, int y, int w, int h, int thickness)
    {
        //Top horiz line
        DrawFilledRect(x, y, w, thickness);
        //Left vertical line
        DrawFilledRect( x, y, thickness, h);
        //right vertical line
        DrawFilledRect((x + w), y, thickness, h);
        //bottom horiz line
        DrawFilledRect(x, y + h, w+thickness, thickness);
    }
    
    
    
    void DrawLine(float StartX, float StartY, float EndX, float EndY, COLORREF Pen)
    {
        int a,b=0;
        HPEN hOPen;
        HPEN hNPen = CreatePen(PS_SOLID, 2, Pen);
        hOPen = (HPEN)SelectObject(HDC_Desktop, hNPen);
        MoveToEx(HDC_Desktop, StartX, StartY, NULL);
        a = LineTo(HDC_Desktop, EndX, EndY);
        DeleteObject(SelectObject(HDC_Desktop, hOPen));
    }
    
    void DrawString(int x, int y, COLORREF color, const char* text)
    {    
        SetTextAlign(HDC_Desktop,TA_CENTER|TA_NOUPDATECP);
    
        SetBkColor(HDC_Desktop,RGB(0,0,0));
        SetBkMode(HDC_Desktop,TRANSPARENT);
    
        SetTextColor(HDC_Desktop,color);
    
        SelectObject(HDC_Desktop,Font);
    
        TextOutA(HDC_Desktop,x,y,text,strlen(text));
    
        DeleteObject(Font);
    }
    
    
    void DrawESP(int x, int y, float distance)
    {
        int width = 18100/distance;
        int height = 36000/distance;
        DrawBorderBox(x-(width/2), y-height, width, height, 1);
    
        DrawLine((m_Rect.right - m_Rect.left)/2,
                m_Rect.bottom - m_Rect.top, x, y, 
                SnapLineCOLOR);
    
    
        std::stringstream ss;
        ss << (int)distance;
    
        char * distanceInfo = new char[ss.str().size()+1];
        strcpy(distanceInfo, ss.str().c_str());
    
        DrawString(x, y, TextCOLOR, distanceInfo);
    
        delete [] distanceInfo;
    }
    
    void ESP()
    {
        GetWindowRect(FindWindow(NULL, "Counter-Strike: Global Offensive"), &m_Rect);
    
        for(int i = 0; i < NumOfPlayers; i ++)
        {
            PlayerList[i].ReadInformation(i);
    
            if(PlayerList[i].Health < 2)
                continue;
    
            if(PlayerList[i].Team == MyPlayer.Team)
                continue;
    
            float EnemyXY[3];
            if(WorldToScreen(PlayerList[i].Position, EnemyXY))
            {
                DrawESP(EnemyXY[0] - m_Rect.left, EnemyXY[1] - m_Rect.top, Get3dDistance(MyPlayer.Position, PlayerList[i].Position));
            }
    
        }
    
    
    
    
    }
    
    
    int main()
    {
        fProcess.RunProcess(); 
    
        ShowWindow(FindWindowA("ConsoleWindowClass", NULL), false);
        TargetWnd = FindWindow(0, "Counter-Strike: Global Offensive");
        HDC HDC_Desktop = GetDC(TargetWnd);
        SetupDrawing(HDC_Desktop, TargetWnd);
    
        for(;;)
        {
            MyPlayer.ReadInformation();
    
            ESP();
    
        }
    
    
        return 0;
    }
    main.cpp
    #pragma once
    
    #include <Windows.h>
    #include <TlHelp32.h>
    
    //THIS FILE SIMPLY DOES MOST OF THE BACKEND WORK FOR US, 
    //FROM FINDING THE PROCESS TO SETTING UP CORRECT ACCESS FOR US 
    //TO EDIT MEMORY 
    //IN MOST GAMES, A SIMPLER VERSION OF THIS CAN BE USED, or if you're injecting then its often not necessary
    //This file has been online for quite a while so credits should be shared but im using this from NubTIK
    //So Credits to him and thanks
    
    class CHackProcess
    {
    public:
    
        PROCESSENTRY32 __gameProcess;
        HANDLE __HandleProcess;
        HWND __HWNDCss; 
        DWORD __dwordClient;
        DWORD __dwordEngine;
        DWORD __dwordOverlay;
        DWORD __dwordVGui;
        DWORD __dwordLibCef;
        DWORD __dwordSteam; 
        DWORD FindProcessName(const char *__ProcessName, PROCESSENTRY32 *pEntry)
        {     
            PROCESSENTRY32 __ProcessEntry;
            __ProcessEntry.dwSize = sizeof(PROCESSENTRY32);
            HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (hSnapshot == INVALID_HANDLE_VALUE) return 0;        if (!Process32First(hSnapshot, &__ProcessEntry))
            {
                CloseHandle(hSnapshot);
                return 0;
            }
            do{if (!_strcmpi(__ProcessEntry.szExeFile, __ProcessName))
            {
                memcpy((void *)pEntry, (void *)&__ProcessEntry, sizeof(PROCESSENTRY32));
                CloseHandle(hSnapshot);
                return __ProcessEntry.th32ProcessID;
            }} while (Process32Next(hSnapshot, &__ProcessEntry));
            CloseHandle(hSnapshot);
            return 0;
    }
    
    
    DWORD getThreadByProcess(DWORD __DwordProcess)
    {     
            THREADENTRY32 __ThreadEntry;
            __ThreadEntry.dwSize = sizeof(THREADENTRY32);
            HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
            if (hSnapshot == INVALID_HANDLE_VALUE) return 0;
    
            if (!Thread32First(hSnapshot, &__ThreadEntry)) {CloseHandle(hSnapshot); return 0; }
    
            do {if (__ThreadEntry.th32OwnerProcessID == __DwordProcess)
            {
                CloseHandle(hSnapshot);
                return __ThreadEntry.th32ThreadID;
            }} while (Thread32Next(hSnapshot, &__ThreadEntry)); 
            CloseHandle(hSnapshot);       
            return 0;
    }
    
    DWORD GetModuleNamePointer(LPSTR LPSTRModuleName, DWORD __DwordProcessId)
    { 
            MODULEENTRY32 lpModuleEntry = {0};
            HANDLE hSnapShot = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, __DwordProcessId);
            if(!hSnapShot)
                return NULL;  
            lpModuleEntry.dwSize = sizeof(lpModuleEntry);
            BOOL __RunModule = Module32First( hSnapShot, &lpModuleEntry );
            while(__RunModule)
            {
                if(!strcmp(lpModuleEntry.szModule, LPSTRModuleName ) )
                {CloseHandle( hSnapShot );
                return (DWORD)lpModuleEntry.modBaseAddr;
                }
                __RunModule = Module32Next( hSnapShot, &lpModuleEntry );
            }
            CloseHandle( hSnapShot );
            return NULL;
    }
    
    
    void runSetDebugPrivs() 
    {
        HANDLE __HandleProcess=GetCurrentProcess(), __HandleToken;
        TOKEN_PRIVILEGES priv;
        LUID __LUID; 
        OpenProcessToken(__HandleProcess, TOKEN_ADJUST_PRIVILEGES, &__HandleToken);
        LookupPrivilegeValue(0, "seDebugPrivilege", &__LUID);
        priv.PrivilegeCount = 1;
        priv.Privileges[0].Luid = __LUID;
        priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(__HandleToken, false, &priv, 0, 0, 0);
        CloseHandle(__HandleToken);
        CloseHandle(__HandleProcess);
    }
        
        
        
    void RunProcess()
    {
        //commented lines are for non steam versions of the game
        runSetDebugPrivs();
        while (!FindProcessName("csgo.exe", &__gameProcess)) Sleep(12);
        while (!(getThreadByProcess(__gameProcess.th32ProcessID))) Sleep(12);
        __HandleProcess = OpenProcess(PROCESS_ALL_ACCESS, false, __gameProcess.th32ProcessID); 
    
        while(__dwordClient == 0x0) __dwordClient = GetModuleNamePointer("client_panorama.dll", __gameProcess.th32ProcessID);
    
        while(__dwordEngine == 0x0) __dwordEngine = GetModuleNamePointer("engine.dll", __gameProcess.th32ProcessID);
    
        //while(__dwordOverlay == 0x0) __dwordOverlay = GetModuleNamePointer("gameoverlayrenderer.dll", __gameProcess.th32ProcessID);
        //while(__dwordVGui == 0x0) __dwordVGui = GetModuleNamePointer("vguimatsurface.dll", __gameProcess.th32ProcessID);
        //while(__dwordLibCef == 0x0) __dwordLibCef = GetModuleNamePointer("libcef.dll", __gameProcess.th32ProcessID);
    //    while(__dwordSteam == 0x0) __dwordSteam = GetModuleNamePointer("steam.dll", __gameProcess.th32ProcessID); 
        __HWNDCss = FindWindow(NULL, "Counter-Strike: Global Offensive"); 
    }
    };
    
    extern CHackProcess fProcess;
    hackprocess.h
  • 相关阅读:
    1442. Count Triplets That Can Form Two Arrays of Equal XOR
    1441. Build an Array With Stack Operations
    312. Burst Balloons
    367. Valid Perfect Square
    307. Range Sum Query
    1232. Check If It Is a Straight Line
    993. Cousins in Binary Tree
    1436. Destination City
    476. Number Complement
    383. Ransom Note
  • 原文地址:https://www.cnblogs.com/MiraculousB/p/12718946.html
Copyright © 2011-2022 走看看