Что нового?

[C++] Hook Scanner v2

iDReeM
Я лучше тебя
iDReeM
Участник
Статус
Оффлайн
Регистрация
31 Июл 2017
Сообщения
383
Реакции[?]
448
Поинты[?]
1K
Снова шалом.
Решил залить фиксы по классу сканера хуков, с небольшим функциональным дополнением.
Предыдущая версия: [C++] Hook Scanner
В этой версии учел некоторые недочеты, на пример с некоторыми функциями были проблемы, или же наш процесс из которого мы берем незатронутые данные, мог не содержать нужной библиотеки, так как она могла быть "кастумной" (частью некого ПО которое сканируем).
Добавил комментарии к коду.
Так же в этой версии добавил использование класса Крайслер
>> std::map. Упрощаем немного себе жизнь <<
Так как судя по комментариям к той теме, которых там нет, почти совсем никто не допер где его можно применять.
И да,
True_Scamer написал(а):
Это похоже на просьбу не давать планктону инфу такого рода.
Нажмите для раскрытия...
Просьба отклонена. Там нихуя сверхтакого нет.
Обновленный Класс:​
Scanner.h:
Код: 
#include <Windows.h>

#include <string>
#include <vector>

using namespace std;

#include "cProcess.h"

//припаяный мап лист крайслера
#include "MapList.h"

//структура експорта
typedef struct _export_data
{
    //адресс процедуры
    FARPROC api_call;
    //имя функции
    std::string api_name;

    _export_data(FARPROC _call, std::string _name) : api_call(_call), api_name(_name)
    {

    }
};

typedef struct _memory_block {
    //буфер памяти
    void* buffer;
    //размер буфера
    size_t size;

    _memory_block(void* _buffer, size_t _size) : buffer(_buffer), size(_size) { }
};

//Кому то покажется что апи блок просто копия експорт дата - но так надо, отвали
typedef struct _api_block {
    //имя функции
    std::string api_name;
    //процедура
    FARPROC api_call;

    _api_block(std::string _name, FARPROC _call) : api_name(_name), api_call(_call) { }
};

typedef struct _hook_memory_data {
    //0 локальный блок
    _memory_block* internal_memory_block;
    //4 дамп
    _memory_block* external_memory_block;
    //8 функция
    _api_block* api_data;

    _hook_memory_data(_memory_block* _internal, _memory_block* _external, _api_block* _api) : internal_memory_block(_internal), external_memory_block(_external), api_data(_api) { }
};

typedef enum _memory_block_type {
    //интернал память
    internal_memory = 0,
    //екстернал память
    external_memory
};
typedef enum _change_data_type {
    //снять хук
    data_restore = 0,
    //вернуть хук
    data_reset
};

#define S_SUCCRESS(a) a != NULL

class Scanner
{
public:
    Scanner();
    Scanner(cProcess* g_pProcess);
    ~Scanner();
    //дамп памяти
    _memory_block* _dump_memory_block(void* address, size_t size_to_dump, _memory_block_type type);
    //сравнение памяти
    bool _compare_memory_block(_memory_block* a, _memory_block* b);
    //особождение памяти
    void _free_memory_block(_memory_block* block);
    //поиск хука на функции
    _hook_memory_data* _find_data(std::string _name_of_module, std::string _name_of_api, size_t size_of_search);
    //поиск хуков по модулю
    std::vector<_hook_memory_data*> _find_data_module(std::string _name_of_module, size_t size_of_search);
    //поиск хуков в группе модулей
    MapList _find_data_module_group(std::vector<std::string> _names_of_module, size_t size_of_search);
    //функция замены данных, снять хук/вернуть на место
    bool _change_data(_hook_memory_data* data, _change_data_type type);
private:
    FARPROC find_function(HMODULE Mod, const char* fName);
    vector<_export_data*> query_function_list(HMODULE Mod);
private:
    cProcess* vProcess;
};
Scanner.cpp:
Код: 
#include "Scanner.h"

Scanner::Scanner()
{
    this->vProcess = nullptr;
}
Scanner::Scanner(cProcess* g_pProcess)
{
    this->vProcess = g_pProcess;
}

Scanner::~Scanner()
{
}

_memory_block* Scanner::_dump_memory_block(void* address, size_t size_to_dump, _memory_block_type type)
{
    _memory_block* _block = nullptr;
    //если адресс и размер указаны, проверка от дебилов
    if (S_SUCCRESS(address) && S_SUCCRESS(size_to_dump))
    {
        HANDLE hProcess = NULL;
        //тип памяти
        switch (type)
        {
        case internal_memory:
            //если внутрянка берем хендл своего процесса
            hProcess = GetCurrentProcess();
            break;

        case external_memory:
            //если внешняя берем хендл процесса к которому цепляемся
            hProcess = this->vProcess->GetHandle();
            break;
        }
        //выделяем память
        void* mem_block = malloc(size_to_dump);

        DWORD dwOldProtect = 0;
        //на всякий ставим PAGE_EXECUTE_READ: если там стоит хук, флаг доступа может быть изменен, по этому перестрахуемся.
        //в следующем обновлении учту VirtualQuery.
        VirtualProtectEx(hProcess, address, size_to_dump, PAGE_EXECUTE_READ, &dwOldProtect);
        //считываем в блок
        bool bReturn = ReadProcessMemory(hProcess, address, mem_block, size_to_dump, 0);
        //возвращаем флаг доступа
        VirtualProtectEx(hProcess, address, size_to_dump, dwOldProtect, &dwOldProtect);

        if (bReturn)
        {
            //если удачно: выделяем структуру
            _block = new _memory_block(mem_block, size_to_dump);
        }
        else
        {
            //если нет отсобождаем выделенный буфер
            free(mem_block);
        }
    }

    return _block;
}

bool Scanner::_compare_memory_block(_memory_block* a, _memory_block* b)
{
    //Если оба блока существуют, тоже защита от дебилов
    if (S_SUCCRESS(a) && S_SUCCRESS(b))
    {
        //Если буферы есть, дабл защита от дебилов
        if (S_SUCCRESS(a->buffer) && S_SUCCRESS(b->buffer))
        {
            //сравниваем, вернет true если память идентична, false если отличается.
            return memcmp(a->buffer, b->buffer, a->size) == 0;
        }
    }
    return false;
}
void Scanner::_free_memory_block(_memory_block* block)
{
    //если блок есть
    if (S_SUCCRESS(block))
    {
        //если буфер есть
        if (S_SUCCRESS(block->buffer))
        {
            //освобождаем буфер и удаляем блок
            free(block->buffer);
            delete block;
        }
    }
}
_hook_memory_data* Scanner::_find_data(std::string _name_of_module, std::string _name_of_api, size_t size_of_search)
{
    _hook_memory_data* _hook_data = nullptr;
    //получаем нужный модуль во внешнем процессе
    cModule* g_pModule = this->vProcess->GetModule(_name_of_module.c_str());
    //нужного нам модуля может не быть в нашем процессе, по этому грузим именно тот модуль
    //который использует нужный нам процесс
    HMODULE m_pModule = LoadLibraryA(g_pModule->GetPath().c_str());
    //Если с модулями порядок
    if (S_SUCCRESS(m_pModule) && S_SUCCRESS(g_pModule))
    {
        //ищем нужную функцию
        FARPROC m_pFunction = this->find_function(m_pModule, _name_of_api.c_str());
        //если нашло
        if (S_SUCCRESS(m_pFunction))
        {
            //дампим память, сперва у себя, потом в искомом процессе
            _memory_block* _block_internal = this->_dump_memory_block(m_pFunction, size_of_search, internal_memory);
            _memory_block* _block_external = this->_dump_memory_block(m_pFunction, size_of_search, external_memory);
            //если сдампило удачно
            if (S_SUCCRESS(_block_internal) && S_SUCCRESS(_block_external))
            {
                //сравниваем блоки
                if (this->_compare_memory_block(_block_internal, _block_external))
                {
                    //если совпали = хука нету на функции. очищаем память
                    this->_free_memory_block(_block_internal);
                    this->_free_memory_block(_block_external);
                }
                else
                {
                    //если не совпало - память модифицирована.
                    _hook_data = new _hook_memory_data(_block_internal, _block_external, new _api_block(_name_of_api, m_pFunction));
                }
            }

        }
    }
    return _hook_data;
}

std::vector<_hook_memory_data*> Scanner::_find_data_module(std::string _name_of_module, size_t size_of_search)
{
    std::vector<_hook_memory_data*> _hook_data_list;
    //получаем нужный модуль во внешнем процессе
    cModule* g_pModule = this->vProcess->GetModule(_name_of_module.c_str());
    //нужного нам модуля может не быть в нашем процессе, по этому грузим именно тот модуль
    //который использует нужный нам процесс
    HMODULE m_pModule = LoadLibraryA(g_pModule->GetPath().c_str());
    //Если с модулями порядок
    if (S_SUCCRESS(m_pModule) && S_SUCCRESS(g_pModule))
    {
        //извлекаем список експортируемых модулем функций.
        vector<_export_data*> m_pFunction_List = this->query_function_list(m_pModule);
        //если список не пуст
        if (S_SUCCRESS(m_pFunction_List.size()))
        {
            //перебираем експорты
            for (_export_data* Data : m_pFunction_List)
            {
                //берем имя
                string Name = Data->api_name;
                //если експорты покрыты пакером, длинна может быть искажена
                if (Name.length() == 0 || Name.length() < 2 || Name.length() < 4)
                    continue;
                //если процедуру нашло
                if (S_SUCCRESS(Data->api_call))
                {
                    //дампим память, сперва у себя, потом в искомом процессе
                    _memory_block* _block_internal = this->_dump_memory_block(Data->api_call, size_of_search, internal_memory);
                    _memory_block* _block_external = this->_dump_memory_block(Data->api_call, size_of_search, external_memory);
                    //если сдампило удачно
                    if (S_SUCCRESS(_block_internal) && S_SUCCRESS(_block_external))
                    {
                        //сравниваем блоки
                        if (this->_compare_memory_block(_block_internal, _block_external))
                        {
                            //если совпали = хука нету на функции. очищаем память
                            this->_free_memory_block(_block_internal);
                            this->_free_memory_block(_block_external);
                        }
                        else
                        {
                            //если не совпало - память модифицирована.
                            _hook_data_list.push_back(new _hook_memory_data(_block_internal, _block_external, new _api_block(Name, Data->api_call)));
                        }
                    }
                }
            }
        }
    }

    return _hook_data_list;
}

bool Scanner::_change_data(_hook_memory_data* data, _change_data_type type)
{
    bool bEnable = false;
    //если функция определена (от турбо вареников)
    if (S_SUCCRESS(data->api_data))
    {
        //если блоки есть
        if (S_SUCCRESS(data->external_memory_block) && S_SUCCRESS(data->internal_memory_block))
        {
            HANDLE hProcess = this->vProcess->GetHandle();
            //переменная для буфера
            void* buffer = nullptr;

            switch (type)
            {
            case data_restore:
                //если ресторе - хук снимется
                buffer = data->internal_memory_block->buffer;
                break;
            case data_reset:
                //если ресет, хук вернется
                buffer = data->external_memory_block->buffer;
                break;
            }

            DWORD dwOldProtect = 0;
            //ставим флаг доступа на запись
            VirtualProtectEx(hProcess, data->api_data->api_call, data->external_memory_block->size, PAGE_EXECUTE_READWRITE, &dwOldProtect);
            //патчим
            bEnable = WriteProcessMemory(hProcess, data->api_data->api_call, buffer, data->external_memory_block->size, 0);
            //возвращаем флаг доступа
            VirtualProtectEx(hProcess, data->api_data->api_call, data->external_memory_block->size, dwOldProtect, &dwOldProtect);
        }
    }
    return bEnable;
}

MapList Scanner::_find_data_module_group(std::vector<std::string> _names_of_module, size_t size_of_search)
{
    MapList MapList_hooks;
    //перебирает список модулей
    for (std::string name : _names_of_module)
    {
        //получает список хуков в каждом модуле
        std::vector<_hook_memory_data*> data_list = this->_find_data_module(name, size_of_search);
        //если они там есть
        if (S_SUCCRESS(data_list.size()))
        {
            //заносит в мап лист по имени
            MapList_hooks.set<std::vector<_hook_memory_data*>>(name, data_list);
        }
    }

    return MapList_hooks;
}
FARPROC Scanner::find_function(HMODULE Mod, const char* fName)
{
    ULONG  uReturn = 0;
    USHORT strTMP = 0;
    USHORT tmpINDEX;
    char * tmpName;
    ULONG Adress;

    if ((ULONG)fName <= 0xFFFF)
        strTMP = (USHORT)fName;

    if (Mod)
    {
        ULONG Portable_Executable = *(ULONG*)((ULONG)Mod + 0x3C) + (ULONG)Mod;
        PIMAGE_EXPORT_DIRECTORY EXPORT_DIRECTORY = (PIMAGE_EXPORT_DIRECTORY)(*(ULONG*)((ULONG)Portable_Executable + 0x78) + (ULONG)Mod);
        PULONG RVAPointer = (ULONG*)(EXPORT_DIRECTORY->AddressOfNames + (ULONG)Mod);
        PUSHORT oTb_RVA = (USHORT*)(EXPORT_DIRECTORY->AddressOfNameOrdinals + (ULONG)Mod);
        PULONG dwTbRVA = (ULONG*)(EXPORT_DIRECTORY->AddressOfFunctions + (ULONG)Mod);

        ULONG size_CNT = (EXPORT_DIRECTORY->NumberOfNames > EXPORT_DIRECTORY->NumberOfFunctions) ? EXPORT_DIRECTORY->NumberOfNames : EXPORT_DIRECTORY->NumberOfFunctions;

        for (USHORT i = 0; i < size_CNT; i++)
        {
            if (i < EXPORT_DIRECTORY->NumberOfFunctions)
            {
                tmpName = (char*)(RVAPointer[i] + (ULONG)Mod);
                tmpINDEX = oTb_RVA[i];
            }
            else
            {
                tmpName = 0;
                tmpINDEX = i;
            }
            Adress = dwTbRVA[tmpINDEX] + (ULONG)Mod;
            if ((strTMP == tmpINDEX + EXPORT_DIRECTORY->Base) || (tmpName && !strcmp(tmpName, fName))) // wcscmp
            {
                uReturn = Adress;
                break;
            }
        }
    }
    return reinterpret_cast<FARPROC>(uReturn);
}

vector<_export_data*> Scanner::query_function_list(HMODULE Mod)
{
    vector<_export_data*> t3Vector;

    ULONG  uReturn = 0;
    USHORT strTMP = 0;
    USHORT tmpINDEX;
    char * tmpName;
    ULONG Adress;

    if (Mod)
    {
        ULONG Portable_Executable = *(ULONG*)((ULONG)Mod + 0x3C) + (ULONG)Mod;
        PIMAGE_EXPORT_DIRECTORY EXPORT_DIRECTORY = (PIMAGE_EXPORT_DIRECTORY)(*(ULONG*)((ULONG)Portable_Executable + 0x78) + (ULONG)Mod);
        PULONG RVAPointer = (ULONG*)(EXPORT_DIRECTORY->AddressOfNames + (ULONG)Mod);
        PUSHORT oTb_RVA = (USHORT*)(EXPORT_DIRECTORY->AddressOfNameOrdinals + (ULONG)Mod);
        PULONG dwTbRVA = (ULONG*)(EXPORT_DIRECTORY->AddressOfFunctions + (ULONG)Mod);

        ULONG size_CNT = (EXPORT_DIRECTORY->NumberOfNames > EXPORT_DIRECTORY->NumberOfFunctions) ? EXPORT_DIRECTORY->NumberOfNames : EXPORT_DIRECTORY->NumberOfFunctions;

        for (USHORT i = 0; i < size_CNT; i++)
        {

            if (i < EXPORT_DIRECTORY->NumberOfNames)
            {
                tmpName = (char*)(RVAPointer[i] + (ULONG)Mod);
                tmpINDEX = oTb_RVA[i];
                Adress = dwTbRVA[tmpINDEX] + (ULONG)Mod;

                t3Vector.push_back(new _export_data(reinterpret_cast<FARPROC>(Adress), tmpName));
            }
            else
            {
                tmpName = 0;
                tmpINDEX = i;
            }
            
        }
    }
    return t3Vector;
}
Примеры использования
Нажмите для раскрытия...
  1. Проверка наличия хука на функции.​
  2. Снятие/возврат хука.​
  3. Сканирование целого модуля.​
  4. Снятие/возврат группы хуков с целого модуля.​
  5. Сканирование группы модулей. (моссивом)​
1. Проверка наличия хука на функции:
Нажмите для раскрытия...
Код: 
Scanner g_pScanner = Scanner(g_pProcess);

_hook_memory_data* DataGetter = g_pScanner._find_data("kernel32.dll", "LoadLibraryA", 5);
if (DataGetter != nullptr)
{
    //стоит хук
}
else
{
    //Хука нет.
}
2. Снятие/возврат хука:
Нажмите для раскрытия...
Код: 
_hook_memory_data* DataGetter = g_pScanner._find_data("kernel32.dll", "LoadLibraryA", 5);
if (DataGetter != nullptr)
{
//стоит хук
if (g_pScanner._change_data(DataGetter, data_restore))
{
//хук снят.
}
if (g_pScanner._change_data(DataGetter, data_reset))
{
//хук возвращен на место.
}
}
else
{
//Хука нет.
}
3. Сканирование целого модуля:
Нажмите для раскрытия...
Код: 
//вывод байт.
void printBuffer(_memory_block* block)
{
    for (int i = 0; i < block->size; i++)
    {
        BYTE data = *(BYTE*)((DWORD)block->buffer + i);
        printf("%X ", data);
    }
}

//source:
std::vector<_hook_memory_data*> Hooks = g_pScanner._find_data_module("kernel32.dll", 5);
printf("\n");

for (_hook_memory_data* Data : Hooks)
{
    printf("hook: [%s] = 0x%X\n", Data->api_data->api_name.c_str(), Data->api_data->api_call);
    printf("Real memory: ");
    printBuffer(Data->internal_memory_block);
    printf("Patched memory: ");
    printBuffer(Data->external_memory_block);
    printf("\n");
    printf("\n");
}

printf("Hooks Len: %d\n", Hooks.size());
Пример вывода (OutPut):
Нажмите для раскрытия...
Код: 
hook: [CreateThread] = 0x75DE3495
Real memory: 8B FF 55 8B EC Patched memory: E9 86 FB D3 DB

hook: [GetProcAddress] = 0x75DE1222
Real memory: 8B FF 55 8B EC Patched memory: E9 D9 2D D4 DB

hook: [GetQueuedCompletionStatus] = 0x75DFD393
Real memory: 8B FF 55 8B EC Patched memory: E9 28 8A EF DA

hook: [LoadLibraryA] = 0x75DE499F
Real memory: 8B FF 55 8B EC Patched memory: E9 3C 1C F1 DA

hook: [LoadLibraryExA] = 0x75DE48DB
Real memory: 8B FF 55 8B EC Patched memory: E9 70 1F F1 DA

hook: [LoadLibraryExW] = 0x75DE4925
Real memory: 8B FF 55 8B EC Patched memory: E9 66 20 F1 DA

hook: [LoadLibraryW] = 0x75DE48F3
Real memory: 8B FF 55 8B EC Patched memory: E9 48 1E F1 DA

Hooks Len: 7
4. Снятие/возврат группы хуков с целого модуля:
Нажмите для раскрытия...
Код: 
void unhook(Scanner g_pScanner, std::vector<_hook_memory_data*> Hooks)
{
    for (_hook_memory_data* Data : Hooks)
    {
        if (!g_pScanner._change_data(Data, data_restore))
        {
            printf("can't unhook: %s\n", Data->api_data->api_name.c_str());
            continue;
        }
    }
}
void rehook(Scanner g_pScanner, std::vector<_hook_memory_data*> Hooks)
{
    for (_hook_memory_data* Data : Hooks)
    {
        if (!g_pScanner._change_data(Data, data_reset))
        {
            printf("can't rehook: %s\n", Data->api_data->api_name.c_str());
            continue;
        }
    }
}
Смысл думаю понятен...
Нажмите для раскрытия...
Далее моя милота с мап листом Сереги.
5. Сканирование группы модулей:
Нажмите для раскрытия...
Код: 
//список модулей, хоть усрись сколько тебе надо проверить
std::vector<std::string> names_of_module_to_scan
{
    "kernel32.dll",
    "user32.dll",
    "ntdll.dll"
};
//сканируем
MapList List_Hooks = g_pScanner._find_data_module_group(names_of_module_to_scan, 5);
//перебираем по имени модуля))
for (std::string Name : names_of_module_to_scan)
{
    //извлекаем
    auto Hooks_from_module = *(std::vector<_hook_memory_data*>*)List_Hooks.get<std::vector<_hook_memory_data*>>(Name);
    //выводим имя модуля
    printf("\n");
    printf("Name module of Scan: %s\n", Name.c_str());
    printf("\n");

    for (_hook_memory_data* Data : Hooks_from_module)
    {
        printf("hook: [%s] = 0x%X\n", Data->api_data->api_name.c_str(), Data->api_data->api_call);
        printf("Real memory: ");
        printBuffer(Data->internal_memory_block);
        printf("Patched memory: ");
        printBuffer(Data->external_memory_block);
        printf("\n");
        printf("\n");
    }

    printf("Hooks Len: %d\n", Hooks_from_module.size());
}
Пример вывода: (OutPut)
Нажмите для раскрытия...
Код: 
Name module of Scan: kernel32.dll

hook: [CreateThread] = 0x75DE3495
Real memory: 8B FF 55 8B EC Patched memory: E9 86 FB D3 DB

hook: [GetProcAddress] = 0x75DE1222
Real memory: 8B FF 55 8B EC Patched memory: E9 D9 2D D4 DB

hook: [GetQueuedCompletionStatus] = 0x75DFD393
Real memory: 8B FF 55 8B EC Patched memory: E9 28 8A EF DA

hook: [LoadLibraryA] = 0x75DE499F
Real memory: 8B FF 55 8B EC Patched memory: E9 3C 1C F1 DA

hook: [LoadLibraryExA] = 0x75DE48DB
Real memory: 8B FF 55 8B EC Patched memory: E9 70 1F F1 DA

hook: [LoadLibraryExW] = 0x75DE4925
Real memory: 8B FF 55 8B EC Patched memory: E9 66 20 F1 DA

hook: [LoadLibraryW] = 0x75DE48F3
Real memory: 8B FF 55 8B EC Patched memory: E9 48 1E F1 DA

Hooks Len: 7

Name module of Scan: user32.dll

hook: [GetClassInfoA] = 0x76546ADE
Real memory: 8B FF 55 8B EC Patched memory: E9 AD 8 60 DB

hook: [GetClassInfoExA] = 0x7654695F
Real memory: 8B FF 55 8B EC Patched memory: E9 6C A 60 DB

hook: [GetClassInfoExW] = 0x7653B238
Real memory: 8B FF 55 8B EC Patched memory: E9 13 C2 60 DB

hook: [GetClassInfoW] = 0x7653B422
Real memory: 8B FF 55 8B EC Patched memory: E9 E9 BF 60 DB

hook: [GetClassLongA] = 0x765486F9
Real memory: 6A 8 68 38 87 Patched memory: E9 A2 EB 5F DB

hook: [GetClassLongW] = 0x765383A8
Real memory: 6A 8 68 E8 83 Patched memory: E9 A3 EE 60 DB

hook: [GetWindowLongA] = 0x7653D156
Real memory: 6A 8 68 98 D1 Patched memory: E9 55 A0 60 DB

hook: [GetWindowLongW] = 0x76536FFE
Real memory: 6A 8 68 40 70 Patched memory: E9 FD 1 61 DB

hook: [RegisterClassA] = 0x7654434B
Real memory: 8B FF 55 8B EC Patched memory: E9 10 23 60 DB

hook: [RegisterClassExA] = 0x7653DB98
Real memory: 8B FF 55 8B EC Patched memory: E9 D3 85 60 DB

hook: [RegisterClassExW] = 0x7653B17D
Real memory: 8B FF 55 8B EC Patched memory: E9 BE B2 60 DB

hook: [RegisterClassW] = 0x76538A65
Real memory: 8B FF 55 8B EC Patched memory: E9 C6 DE 60 DB

hook: [SetClassLongA] = 0x7654D5F9
Real memory: 8B FF 55 8B EC Patched memory: E9 42 9D 5F DB

hook: [SetClassLongW] = 0x76545483
Real memory: 8B FF 55 8B EC Patched memory: E9 68 1E 60 DB

hook: [SetWindowLongA] = 0x76546110
Real memory: 8B FF 55 8B EC Patched memory: E9 FB F 60 DB

hook: [SetWindowLongW] = 0x76538332
Real memory: 8B FF 55 8B EC Patched memory: E9 29 EE 60 DB

hook: [SetWindowsHookExW] = 0x76547603
Real memory: 8B FF 55 8B EC Patched memory: E9 D8 FE 5F DB

hook: [gSharedInfo] = 0x765A04E0
Real memory: 70 A 80 0 0 Patched memory: 70 A F1 1 0

Hooks Len: 18

Name module of Scan: ntdll.dll

hook: [DbgBreakPoint] = 0x7718000C
Real memory: CC C3 90 90 8B Patched memory: C3 C3 90 90 8B

hook: [DbgUiRemoteBreakin] = 0x7720F8EA
Real memory: 6A 8 68 60 BA Patched memory: E9 D2 DC FA FF

hook: [DbgUserBreakPoint] = 0x77180008
Real memory: CC 90 C3 90 CC Patched memory: CC 90 C3 90 C3

hook: [LdrLoadDll] = 0x771AC4DD
Real memory: 8B FF 55 8B EC Patched memory: E9 AE 72 97 DA

hook: [LdrUnloadDll] = 0x771B1287
Real memory: 6A 14 68 D8 BC Patched memory: E9 64 2B 97 DA

hook: [NlsAnsiCodePage] = 0x77270010
Real memory: E3 4 3F 0 D Patched memory: E3 4 3F 0 F8

Hooks Len: 6
Что непонятно спрашивайте.
​
 
iDReeM
Я лучше тебя
iDReeM
Участник
Статус
Оффлайн
Регистрация
31 Июл 2017
Сообщения
383
Реакции[?]
448
Поинты[?]
1K
Войдите или зарегистрируйтесь для ответа.
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Сверху Снизу