Бесплатный необнаруженный пелликс dota 2

//c++23
//super shitcode
#include <iostream>
#include <expected>
#include <vector>
#include <format>
#include <span>
#include <array>
#include <source_location>

#include <Windows.h>
#include <Psapi.h>
#include <tlhelp32.h>

bool fuzzy_memcmp(const std::uint8_t* lhs, const std::uint8_t* rhs, std::size_t size, const char* masks) noexcept
{
    constexpr auto wildcard = '?';
    const auto end = lhs + size;
    for (; lhs < end; ++lhs, ++rhs, ++masks)
    {
        if (*masks != wildcard && *lhs != *rhs)
            return false;
    }
    return true;
}

const std::uint8_t* sigscan_naive(const std::uint8_t* base, std::size_t input_size, const uint8_t* pattern,
    std::size_t pattern_size, const char* masks) noexcept
{
    if (
        pattern_size
        && (input_size >= pattern_size)
        && base
        && pattern
        && masks
        )
    {
        const auto alignmentCount = (input_size - pattern_size) + 1;
        const auto end = base + alignmentCount;
        for (auto current = base; current < end; ++current)
        {
            if (fuzzy_memcmp(current, pattern, pattern_size, masks))
                return current;
        }
    }

    return nullptr;
}

std::vector<std::string_view> strsplit(std::string_view input, std::string_view token)
{
    std::vector<std::string_view> result{};
    const auto token_size = token.size();
    std::size_t pos{};
    while ((pos = input.find(token)) != std::string_view::npos)
    {
        result.push_back(input.substr(0, pos));
        input = input.substr(pos + token_size);
    }
    result.push_back(input);
    return result;
}

constexpr auto _invalid_hex_char = (std::numeric_limits<std::uint8_t>::max)();
constexpr std::uint8_t get_hex_char(std::uint8_t x)
{
    if (x >= '0' && x <= '9')
        return x - '0';
    else if (x >= 'A' && x <= 'F')
        return x - 'A' + 0xA;
    else if (x >= 'a' && x <= 'f')
        return x - 'a' + 0xA;
    return _invalid_hex_char;
}

struct _sig
{
    std::vector<std::uint8_t> bytes{};
    std::vector<char> masks{};
};
_sig preprocess_patern_fuzzy(std::string_view textsig)
{
    _sig result{};
    if (!textsig.empty())
    {
        result.bytes.reserve(textsig.size());
        result.masks.reserve(textsig.size());
        for (const auto& chunk : strsplit(textsig, " "))
        {
            if (chunk.size() == 2)
            {
                if (chunk.front() == '?')
                {
                    result.bytes.push_back('?');
                    result.masks.push_back('?');
                }
                else
                {
                    const auto high = get_hex_char(chunk.front());
                    const auto low = get_hex_char(chunk.back());
                    if (high == _invalid_hex_char || low == _invalid_hex_char)
                        return {};
                    result.bytes.push_back((high << 4) | low);
                    result.masks.push_back('x');
                }
            }
            else
                return {};
        }
    }
    return result;
}

constexpr auto _sig_not_found = (std::numeric_limits<std::ptrdiff_t>::max)();
std::ptrdiff_t ExternalSigscanGetRVA(const std::uint8_t* base, std::size_t input_size, std::string_view textsig)
{
    const auto& sig = preprocess_patern_fuzzy(textsig);
    if (!sig.bytes.empty() && sig.bytes.size() == sig.masks.size())
    {
        const auto result =
            sigscan_naive(base, input_size, sig.bytes.data(), sig.bytes.size(), sig.masks.data());
        if (result)
        {
            return result - base;
        }
    }
    return _sig_not_found;
}

std::span<std::uint8_t> GetModuleExternal(HANDLE hProcess, std::string_view moduleName)
{
    std::array<HMODULE, 1024> hMods{};
    DWORD out_size;
    if (K32EnumProcessModules(hProcess, hMods.data(), sizeof(hMods), &out_size))
    {
        for (const auto& mod : std::span{ hMods.data(), out_size / sizeof(HMODULE) })
        {
            std::array<char, MAX_PATH> szModName;
            if (K32GetModuleBaseNameA(hProcess, mod, szModName.data(), (DWORD)szModName.size()))
            {
                if (std::string_view{ szModName.data() } == moduleName)
                {
                    MODULEINFO out_modinfo;
                    if (K32GetModuleInformation(hProcess, mod, &out_modinfo, sizeof(MODULEINFO)))
                    {
                        return { (std::uint8_t*)out_modinfo.lpBaseOfDll, out_modinfo.SizeOfImage };
                    }
                }
            }
        }
    }

    return {};
}

std::vector<std::uint8_t> ReadModule(HANDLE hProcess, std::span<std::uint8_t> mod)
{
    std::vector<std::uint8_t> result{};
    result.resize(mod.size());
    SIZE_T out_size;
    if (ReadProcessMemory(hProcess, mod.data(), result.data(), mod.size(), &out_size)
        && out_size == mod.size())
    {
        return result;
    }
    return {};
}

void* ExternalSigscan(HANDLE hProcess, std::string_view moduleName, std::string_view textsig)
{
    const auto extmod = GetModuleExternal(hProcess, moduleName);
    if (extmod.empty())
        throw std::runtime_error{ std::format("module {} not found!", moduleName) };
    const auto& intmod = ReadModule(hProcess, extmod);
    if (intmod.size() != extmod.size())
        throw std::runtime_error{ std::format("can't map module {}!", moduleName) };

    if (const auto rva = ExternalSigscanGetRVA(intmod.data(), intmod.size(), textsig);
        rva != _sig_not_found)
    {
        return extmod.data() + rva;
    }
    return nullptr;
}

template<class T>
std::expected<T, DWORD> ReadMemory(HANDLE process, const void* ptr) noexcept
{
    if (process != NULL)
    {
        constexpr auto expected_size = sizeof(T);
        T obj;
        SIZE_T out_size;
        if (!ReadProcessMemory(process, ptr, &obj, expected_size, &out_size))
            return std::unexpected{ GetLastError() };

        if (out_size != expected_size)
            return std::unexpected{ ERROR_MORE_DATA };

        return { obj };
    }
    return std::unexpected{ ERROR_INVALID_HANDLE };
}

template<HANDLE invalid_value>
struct handle_raii
{
    HANDLE handle = invalid_value;
    bool IsValid() const noexcept
    {
        return handle != invalid_value;
    }
    ~handle_raii()
    {
        if (IsValid())
            CloseHandle(handle);
    }
    operator HANDLE() const noexcept
    {
        return handle;
    }
};

constexpr DWORD _invalid_pid = (std::numeric_limits<DWORD>::max)();
DWORD GetProcessID(const std::string_view& processName)
{
    if (const handle_raii<INVALID_HANDLE_VALUE> hSnap{ CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL) };
        hSnap.IsValid())
    {
#pragma push_macro("PROCESSENTRY32")
#pragma push_macro("Process32First")
#pragma push_macro("Process32Next")
#undef PROCESSENTRY32
#undef Process32First
#undef Process32Next

        PROCESSENTRY32 entry{ .dwSize = sizeof(PROCESSENTRY32) };

        for (auto result = Process32First(hSnap, &entry); result; result = Process32Next(hSnap, &entry))
            if (std::string_view{ entry.szExeFile } == processName)
                return entry.th32ProcessID;

#pragma pop_macro("Process32Next")
#pragma pop_macro("Process32First")
#pragma pop_macro("PROCESSENTRY32")
    }
    return _invalid_pid;
}


struct CanReadProcessMemory
{
    HANDLE _process = NULL;

    template<class T>
    std::expected<T, DWORD> Read(const void* ptr) const noexcept
    {
        return ReadMemory<T>(_process, ptr);
    }
};

struct ExternalClass : public CanReadProcessMemory
{
    void* instance_ptr;
    bool HasObject() const noexcept
    {
        return instance_ptr != nullptr;
    }

    template<class T>
    T Member(std::ptrdiff_t offset, const std::source_location& source = std::source_location::current()) const
    {
        const auto obj = Read<T>((char*)instance_ptr + offset);
        if (!obj.has_value())
        {
            throw std::runtime_error
            {
                std::format("error({}) reading member from {}", obj.error(), source.function_name())
            };
        }
        return obj.value();
    }

    template<class T>
    T ExternalClassPointer(std::ptrdiff_t offset, const std::source_location& source = std::source_location::current()) const
        requires(std::derived_from<T, ExternalClass>)
    {
        const auto val = Member<T*>(offset, source);
        return { _process, val };
    }

    std::string ReadNullTerminatedString
    (std::ptrdiff_t offset, const std::source_location& source = std::source_location::current()) const
    {
        std::string str{};
        const char* ptr = Member<char*>(offset, source);
        if (ptr)
        {
            for (char character; (character = Read<char>(ptr).value()) != '\x00'; ++ptr)
                str += character;
        }
        return str;
    }
};

struct _sized_struct {};

template<class T>
    requires(std::derived_from<T, _sized_struct>)
struct ExternalArray : ExternalClass
{
    T At(std::size_t index) const
    {
        return T{ _process, (char*)instance_ptr + T::_sizeof * index };
    }
};

struct PlayerID_t
{
    std::uint32_t value;
};

struct EntityIndex_t
{
    std::int32_t value;
    bool IsValid() const noexcept
    {
        return value != -1;
    }
    static EntityIndex_t from(PlayerID_t playerid) noexcept
    {
        return EntityIndex_t{ static_cast<std::int32_t>(playerid.value + 1) };
    }
};

static constexpr auto ES_ENTITY_LIST_COUNT = 64;
static constexpr auto ES_ENTITY_COUNT_PER_LIST = 512;
struct CHandle
{
    std::int32_t value;
    EntityIndex_t index() const noexcept
    {
        return { value & ((ES_ENTITY_LIST_COUNT * ES_ENTITY_COUNT_PER_LIST) - 1) };
    }
    bool IsValid() const noexcept
    {
        return value != -1;
    }
};

struct CNetworkGameClient : ExternalClass
{
    PlayerID_t LocalPlayerIndex() const
    {
        return Member<PlayerID_t>(0x100);
    }
};

struct C_BaseEntity;
struct CEntityIdentity : ExternalClass, _sized_struct
{
    constexpr static auto _sizeof = 0x78;

    C_BaseEntity GetEntity() const;
    std::string GetName() const
    {
        return ReadNullTerminatedString(0x18);
    }
    std::string GetDesignerName() const
    {
        return ReadNullTerminatedString(0x20);
    }
};

struct C_BaseEntity : ExternalClass
{
    CEntityIdentity GetIdentity() const
    {
        return ExternalClassPointer<CEntityIdentity>(0x10);
    }
    std::string GetName() const
    {
        if (const auto identity = GetIdentity(); identity.HasObject())
            return identity.GetName();
        return {};
    }
    std::string GetDesignerName() const
    {
        if (const auto identity = GetIdentity(); identity.HasObject())
            return identity.GetDesignerName();
        return {};
    }
    int GetHealth() const
    {
        return Member<int>(0x334);
    }
};

struct C_DOTAPlayerController : C_BaseEntity
{
    CHandle GetAssignedHeroHandle() const
    {
        return Member<CHandle>(0x7e4);
    }
};

C_BaseEntity CEntityIdentity::GetEntity() const
{
    return ExternalClassPointer<C_BaseEntity>(0x0);
}

struct CGameEntitySystem : ExternalClass
{
private:
    ExternalArray<CEntityIdentity> GetList(std::size_t listIndex) const
    {
        if (listIndex < ES_ENTITY_LIST_COUNT)
            return ExternalClassPointer<ExternalArray<CEntityIdentity>>(0x10 + listIndex * sizeof(void*));
        return {};
    }
public:
    EntityIndex_t GetHighestIndex() const
    {
        return Member<EntityIndex_t>(0x1510);
    }
    C_BaseEntity GetEntityByIndex(EntityIndex_t index) const
    {
        if (index.value > 0 && index.value < (ES_ENTITY_LIST_COUNT * ES_ENTITY_COUNT_PER_LIST))
        {
            const auto highest = GetHighestIndex();
            if (highest.IsValid() && index.value <= highest.value)
            {
                const auto list_index = index.value / ES_ENTITY_COUNT_PER_LIST;
                const auto index_in_list = index.value % ES_ENTITY_COUNT_PER_LIST;
                const auto list = GetList(list_index);
                if (list.HasObject())
                {
                    const auto identity = list.At(index_in_list);
                    if (identity.HasObject())
                    {
                        return identity.GetEntity();
                    }
                }
            }
        }
        return {};
    }
};

int main()
{
    try
    {
        const auto pid = GetProcessID("dota2.exe");
        if (pid == _invalid_pid)
            throw std::runtime_error{ "No dota2.exe" };
        const handle_raii < HANDLE{ NULL } > process
        {
            OpenProcess(PROCESS_VM_OPERATION | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid)
        };
        if (!process.IsValid())
            throw std::runtime_error{ "Can't open process" };

        //inside cl_ent_find cmd. string xref "format: ent_find"
        const auto entitysystem_sig = ExternalSigscan(process, "client.dll",
            "48 8D 0D ?? ?? ?? ?? FF 15 ?? ?? ?? ?? 48 8B 0D ?? ?? ?? ?? 33 D2 E8");
        if (!entitysystem_sig)
            throw std::runtime_error{ "entitysystem_sig null" };

        constexpr auto es_OFFSET_FROM_SIG_TO_XREF = 0xD;
        constexpr auto es_OFFSET_TO_MOV_OPERAND = 0x3;
        constexpr auto es_SIZE_OF_MOV = 0x7;
        char* es_insn_ptr = ((char*)entitysystem_sig + es_OFFSET_FROM_SIG_TO_XREF);
        const auto es_rel32 = ReadMemory<std::int32_t>
            (process, es_insn_ptr + es_OFFSET_TO_MOV_OPERAND).value();
        void* g_pEntitySystem_addr = (es_insn_ptr + es_rel32 + es_SIZE_OF_MOV);
        std::cout << "g_pEntitySystem_addr: " << g_pEntitySystem_addr << std::endl;

        void* _g_pEntitySystem = ReadMemory<void*>(process, g_pEntitySystem_addr).value();
        if (!_g_pEntitySystem)
            throw std::runtime_error{ "CGameEntitySystem not created yet!" };
        CGameEntitySystem g_pEntitySystem{ process, _g_pEntitySystem };

        //inside CEngineClient::GetLocalPlayerIndex. virtual function 27
        const auto CNetworkGameClient_sig = ExternalSigscan(process, "engine2.dll",
            "4C 8B 0D ?? ?? ?? ?? 4D 85 C9 74 ?? 33 C0");
        if (!CNetworkGameClient_sig)
            throw std::runtime_error{ "entitysystem_sig null" };

        constexpr auto ngc_OFFSET_FROM_SIG_TO_XREF = 0;
        constexpr auto ngc_OFFSET_TO_MOV_OPERAND = 0x3;
        constexpr auto ngc_SIZE_OF_MOV = 0x7;

        char* ngc_insn_ptr = ((char*)CNetworkGameClient_sig + ngc_OFFSET_FROM_SIG_TO_XREF);
        const auto ngc_rel32 = ReadMemory<std::int32_t>
            (process, ngc_insn_ptr + ngc_OFFSET_TO_MOV_OPERAND).value();
        void* g_pNetworkGameClient_addr = (ngc_insn_ptr + ngc_rel32 + ngc_SIZE_OF_MOV);
        std::cout << "g_pNetworkGameClient_addr: " << g_pNetworkGameClient_addr << std::endl;

        void* _g_pNetworkGameClient = ReadMemory<void*>(process, g_pNetworkGameClient_addr).value();
        if (!_g_pNetworkGameClient)
            throw std::runtime_error{ "CNetworkGameClient not created yet!" };
        CNetworkGameClient g_pNetworkGameClient{ process, _g_pNetworkGameClient };
        const auto LocalPlayerIndex = g_pNetworkGameClient.LocalPlayerIndex();
        const auto LocalPlayerEntityIndex = EntityIndex_t::from(g_pNetworkGameClient.LocalPlayerIndex());
        std::cout << "LocalPlayerIndex: " << LocalPlayerIndex.value << std::endl;
        std::cout << "LocalPlayerEntityIndex: " << LocalPlayerEntityIndex.value << std::endl;
        const auto LocalPlayerController = g_pEntitySystem.GetEntityByIndex(LocalPlayerEntityIndex);
        std::cout << "Local player entity: " << LocalPlayerController.instance_ptr << std::endl;
        if (LocalPlayerController.HasObject())
        {
            std::cout << "Local player name: " << LocalPlayerController.GetName() << std::endl;
            std::cout << "Local player designer name: " << LocalPlayerController.GetDesignerName() << std::endl;
            const auto local_hero_handle =
                ((C_DOTAPlayerController&)LocalPlayerController).GetAssignedHeroHandle();
            if (local_hero_handle.IsValid())
            {
                const auto local_hero_index = local_hero_handle.index();
                std::cout << "local hero entity index: " << local_hero_index.value << std::endl;
                const auto local_hero = g_pEntitySystem.GetEntityByIndex(local_hero_index);
                std::cout << "Local hero entity: " << local_hero.instance_ptr << std::endl;
                if (local_hero.HasObject())
                {
                    std::cout << "Local hero name: " << local_hero.GetName() << std::endl;
                    std::cout << "Local hero health: " << local_hero.GetHealth() << std::endl;
                }
            }
        }
    }
    catch (const std::exception& ex)
    {
        std::cout << "Exception: " << ex.what() << std::endl;
    }
    return 0;
}