Гайд Auto Searching Interface

[I69]

Данный код перебирает номера интерфейсов и возвращает валидный класс:

Спойлер

void* CaptureInterface(const char* chHandle, const char* chInterfaceName)
{
    volatile auto handlegotten = (GetModuleHandleA(chHandle) != nullptr);
    while (!GetModuleHandleA(chHandle)) Sleep(100);
    void* fnFinal = nullptr;
    auto PossibleInterfaceName = new char[strlen(chInterfaceName) + 4];
    auto TestInterface = reinterpret_cast<CreateInterface_t>(GetProcAddress(GetModuleHandleA(chHandle), XorStr("CreateInterface")));
    for (auto i = 100; i > 0; i--)
    {
        XorCompileTime::w_sprintf(PossibleInterfaceName, XorStr("%s%03i"), chInterfaceName, i);
        fnFinal = static_cast<void*>(TestInterface(PossibleInterfaceName, nullptr));
 
    if (fnFinal != nullptr)
            break;
    }
    delete PossibleInterfaceName;
    return fnFinal;
}

Пространство имен Xor и структура,соответственно :

Спойлер

#pragma once
#include <string>
#include <array>
#include <cstdarg>


namespace XorCompileTime
{
    constexpr auto time = __TIME__;
    constexpr auto seed = static_cast< int >(time[7]) + static_cast< int >(time[6]) * 10 + static_cast< int >(time[4]) * 60 + static_cast< int >(time[3]) * 600 + static_cast< int >(time[1]) * 3600 + static_cast< int >(time[0]) * 36000;

    template < int iValue >
    struct RandomGenerator
    {
    private:
        static constexpr unsigned a = 16807;
        static constexpr unsigned m = 2147483647;
        static constexpr unsigned s = RandomGenerator<iValue - 1>::value;
        static constexpr unsigned lo = a * (s & 0xFFFF);
        static constexpr unsigned hi = a * (s >> 16);
        static constexpr unsigned lo2 = lo + ((hi & 0x7FFF) << 16);
        static constexpr unsigned hi2 = hi >> 15;
        static constexpr unsigned lo3 = lo2 + hi;

    public:
        static constexpr unsigned max = m;
        static constexpr unsigned value = lo3 > m ? lo3 - m : lo3;
    };

    template <>
    struct RandomGenerator< 0 >
    {
        static constexpr unsigned value = seed;
    };

    template < int N, int M >
    struct RandomInt
    {
        static constexpr auto value = RandomGenerator< N + 1 >::value % M;
    };

    template < int N >
    struct RandomChar
    {
        static const char value = static_cast< char >(1 + RandomInt< N, 0x7F - 1 >::value);
    };

    template < size_t N, int K >
    struct XorString
    {
    private:
        const char _key;
        std::array< char, N + 1 > _encrypted;

        constexpr char enc(char c) const { return c ^ _key; }
        char dec(char c) const { return c ^ _key; }
    public:
        template < size_t... Is >
        constexpr __forceinline XorString(const char* str, std::index_sequence< Is... >) : _key(RandomChar< K >::value), _encrypted{ enc(str[Is])... } {}

        __forceinline decltype(auto) decrypt(void)
        {
            for (size_t i = 0; i < N; ++i)
            {
                _encrypted[i] = dec(_encrypted[i]);
            }
            _encrypted[N] = '\0';
            return _encrypted.data();
        }
    };

    static auto w_printf = [](const char* fmt, ...)
    {
        va_list args;
        va_start(args, fmt);
        vprintf_s(fmt, args);
        va_end(args);
    };

    static auto w_printf_s = [](const char* fmt, ...)
    {
        va_list args;
        va_start(args, fmt);
        vprintf_s(fmt, args);
        va_end(args);
    };

    static auto w_sprintf = [](char* buf, const char* fmt, ...)
    {
        va_list args;
        va_start(args, fmt);
#pragma warning(push)
#pragma warning(disable:4996)
        vsprintf(buf, fmt, args);
#pragma warning (pop)

        va_end(args);
    };

    static auto w_sprintf_s = [](char* buf, size_t buf_size, const char* fmt, ...)
    {
        va_list args;
        va_start(args, fmt);
        vsprintf_s(buf, buf_size, fmt, args);
        va_end(args);
    };


#define XorStr( s ) ( XorCompileTime::XorString< sizeof( s ) - 1, __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ).decrypt() )

}

Пример использования :

Спойлер

void _fastcall init_iterface(void)
{
    do{
        pClient = reinterpret_cast<IBaseClientDLL*>(CaptureInterface(XorStr("client.dll"), XorStr("VClient")));
    } while (!pClient);
}

Так же,для предотвращения крашей мы можем сделать функцию не типа VOID ,а типa BOOL ,но тогда еще придется делать ретурны.
Пример :

Спойлер

bool  _fastcall init_iterface(bool)
{
    do{
        pClient = reinterpret_cast<IBaseClientDLL*>(CaptureInterface(XorStr("client.dll"), XorStr("VClient")));
    } while (!pClient);

if(pClient)
   return true;
else
  return false;
}

 

[P45H3]

Я могу тебя разочаровать. Во всех интернал читах есть данная функция)

 

[Крайслер]

Так же,для предотвращения крашей мы можем сделать функцию не типа VOID ,а типa BOOL ,но тогда еще придется делать ретурны.

в этом нет не какого смысла, так как в первоначальном варианте у тебя и так проверка стоит:

 while (!pClient)

у тебя будет вызываться

pClient = reinterpret_cast<IBaseClientDLL*>(CaptureInterface(XorStr("client.dll"), XorStr("VClient")));

до тех пор пока не вернет что-то валидное