Перехват системных вызовов windows

Время на прочтение8 мин

Количество просмотров52K

Что такое хук?
Что такое хук функций и для чего он нужен? В переводе с английского «hook» — ловушка. Поэтому о назначении хуков функции в Windows можно догадаться — это ловушка для функции. Иными словами, мы ловим функцию и берем управление на себя. После этого определения нам открываются заманчивые перспективы: мы можем перехватить вызов любой функции, подменить код на свой, тем самым изменив поведение любой программы на то, которое нам нужно (конечно, в рамках определенных ограничений).

Целью данной статьи является демонстрация установки хука и его непосредственная реализация.

— Нельзя поверить в невозможное!
— Просто у тебя мало опыта, – заметила Королева. – В твоем возрасте я уделяла этому полчаса каждый день! В иные дни я успевала поверить в десяток невозможностей до завтрака!

Где мне реально пригодились эти знания

Эти знания являются очень узкоспециализированными, и в повседневной практике разработки маловероятно, что они пригодятся, но знать о них, на мой взгляд, крайне желательно, даже если эти знания чисто теоретические. На моей практики же мне пригодились эти знания для решения следующих задач:

• Контроль входящего http-траффика и подмена «взрослого» контента на более безобидный.
• Логирование информации в случае копирования каких-либо файлов с подконтрольной сетевой папки.
• Незначительная модификация кода в проекте, от которого были утеряны исходники (да, и такое тоже случается)

Методы установки хуков

Давайте перейдем от общих фраз к более детальному рассмотрению хуков. Мне известно несколько разновидностей реализации хука:

● Использование функции SetWindowsHookEx. Это весьма простой, оттого и ограниченный, метод. Он позволяет перехватывать только определенные функции, в основном связанные с окном (например, перехват событий, которые получает окно, щелчков мышкой, клавиатурного ввода). Достоинством этого метода является возможность установки глобальных хуков (например, сразу на все приложениях перехватывать клавиатурный ввод).
● Использование подмены адресов в разделе импорта DLL. Суть метода заключается в том, что любой модуль имеет раздел импорта, в котором перечислены все используемые в нем другие модули, а также адреса в памяти для экспортируемых этим модулем функций. Нужно подменить адрес в этом модуле на свой и управление будет передано по указанному адресу.
● Использование ключа реестра HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_Dlls. В нем необходимо прописать путь к DLL, но сделать это могут только пользователи с правами администратора. Этот метод хорош, если приложение не использует kernel32.dll (нельзя вызвать функцию LoadLibrary).
● Использование инъектирования DLL в процесс. На мой взгляд, это самый гибкий и самый показательный способ. Его-то мы и рассмотрим более подробно.

Метод инъектирования

Инъектирование возможно, потому что функция ThreadStart, которая передается функции CreateThread, имеет схожую сигнатуру с функцией LoadLibrary (да и вообще структура dll и исполняемого файла очень схожи). Это позволяет указать метод LoadLibrary в качестве аргумента при создании потока.

Алгоритм инъектирования DLL выглядит так:

1. Находим адрес функции LoadLibrary из Kernel32.dll для потока, куда мы хотим инжектировать DLL.
2. Выделяем память для записи аргументов этой функции.
3. Создаем поток и в качестве ThreadStart функции указываем LoadLibrary и ее аргумент.
4. Поток идет на исполнение, загружает библиотеку и завершается.
5. Наша библиотека инъектирована в адресное пространство постороннего потока. При этом при загрузке DLL будет вызван метод DllMain с флагом PROCESS_ATTACH. Это как раз то место, где можно установить хуки на нужные функции. Далее рассмотрим саму установку хука.

Установка хука

Подход, используемый при установке хука, можно разбить на следующие составные части:

1. Находим адрес функции, вызов которой мы хотим перехватывать (например, MessageBox в user32.dll).
2. Сохраняем несколько первых байтов этой функции в другом участке памяти.
3. На их место вставим машинную команду JUMP для перехода по адресу подставной функции. Естественно, сигнатура функции должна быть такой же, как и исходной, т. е. все параметры, возвращаемое значение и правила вызова должны совпадать.
4. Теперь, когда поток вызовет перехватываемую функцию, команда JUMP перенаправит его к нашей функции. На этом этапе мы можем выполнить любой нужный код.

Далее можно снять ловушку, вернув первые байты из п.2 на место.

Итак, теперь нам понятно, как внедрить нужную нам DLL в адресное пространство потока и каким образом установить хук на функцию. Теперь попробуем совместить эти подходы на практике.

Тестовое приложение

Наше тестовое приложение будет довольно простым и написано на С#. Оно будет содержать в себе кнопку для показа MessageBox. Для примера, установим хук именно на эту функцию. Код тестового приложения:

public partial class MainForm : Form
{
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);
 
public MainForm()
{
InitializeComponent();
 this.Text = "ProcessID: " + Process.GetCurrentProcess().Id;
}
 private void btnShowMessage_Click(Object sender, EventArgs e)
{
MessageBox(new IntPtr(0), "Hello World!", "Hello Dialog", 0);
}
}

Инъектор

В качестве инъектора рассмотрим два варианта. Инъекторы, написанные на С++ и С#. Почему на двух языках? Дело в том, что многие считают, что С# — это язык, в котором нельзя использовать системные вещи, — это миф, можно :). Итак, код инъектора на С++:

#include "stdafx.h"
#include <iostream>
#include <Windows.h>
#include <cstdio>
 
int Wait();
 
int main()
{
                // Пусть до библиотеки, которую хотим инъектировать.
                DWORD processId = 55;
                char* dllName = "C:\\_projects\\CustomHook\\Hooking\\Debug\\HookDll.dll";
 
                // Запрашиваем PID процесса куда хотим инъектировать.
                printf("Enter PID to inject dll: ");
                std::cin >> processId;
 
                // Получаем доступ к процессу.
                HANDLE openedProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
                if (openedProcess == NULL)
                {
                                printf("OpenProcess error code: %d\r\n", GetLastError());
                                return Wait();
                }
 
                // Ищем kernel32.dll
                HMODULE kernelModule = GetModuleHandleW(L"kernel32.dll");
                if (kernelModule == NULL)
                {
                                printf("GetModuleHandleW error code: %d\r\n", GetLastError());
                                return Wait();
                }
 
                // Ищем LoadLibrary (Суффикс A означает что работаем в ANSI, один байт на символ)
                LPVOID loadLibraryAddr = GetProcAddress(kernelModule, "LoadLibraryA");
                if (loadLibraryAddr == NULL)
                {
                                printf("GetProcAddress error code: %d\r\n", GetLastError());
                                return Wait();
                }
 
                // Выделяем память под аргумент LoadLibrary, а именно - строку с адресом инъектируемой DLL
                LPVOID argLoadLibrary = (LPVOID)VirtualAllocEx(openedProcess, NULL, strlen(dllName), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
                if (argLoadLibrary == NULL)
                {
                                printf("VirtualAllocEx error code: %d\r\n", GetLastError());
                                return Wait();
                }
 
                // Пишем байты по указанному адресу.
                int countWrited = WriteProcessMemory(openedProcess, argLoadLibrary, dllName, strlen(dllName), NULL);
                if (countWrited == NULL)
                {
                                printf("WriteProcessMemory error code: %d\r\n", GetLastError());
                                return Wait();
                }
 
                // Создаем поток, передаем адрес LoadLibrary и адрес ее аргумента
                HANDLE threadID = CreateRemoteThread(openedProcess, NULL, 0, (LPTHREAD_START_ROUTINE)loadLibraryAddr, argLoadLibrary, NULL, NULL);
 
                if (threadID == NULL)
                {
                                printf("CreateRemoteThread error code: %d\r\n", GetLastError());
                                return Wait();
                }
                else
                {
                                printf("Dll injected!");
                }
 
                // Закрываем поток.
                CloseHandle(openedProcess);
 
                return 0;
}
 
int Wait()
{
                char a;
                printf("Press any key to exit");
                std::cin >> a;
                return 0;
}

Теперь тоже самое, но только на С#. Оцените, насколько код более компактен, нет буйства типов (HANDLE, LPVOID, HMODULE, DWORD, которые, по сути, означают одно и тоже).

public class Exporter
{
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr OpenProcess(ProcessAccessFlags processAccess, bool bInheritHandle, int processId);
 
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr GetModuleHandle(string lpModuleName);
 
[DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
 
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
 
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, UIntPtr nSize, out IntPtr lpNumberOfBytesWritten);
 
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out IntPtr lpThreadId);
 
[DllImport("kernel32.dll", SetLastError = true)]
public static extern Int32 CloseHandle(IntPtr hObject);
}
 public class Injector
{
public static void Inject(Int32 pid, String dllPath)
{
IntPtr openedProcess = Exporter.OpenProcess(ProcessAccessFlags.All, false, pid);
IntPtr kernelModule = Exporter.GetModuleHandle("kernel32.dll");
IntPtr loadLibratyAddr = Exporter.GetProcAddress(kernelModule, "LoadLibraryA");
 
Int32 len = dllPath.Length;
IntPtr lenPtr = new IntPtr(len);
UIntPtr uLenPtr = new UIntPtr((uint)len);
 
IntPtr argLoadLibrary = Exporter.VirtualAllocEx(openedProcess, IntPtr.Zero, lenPtr, AllocationType.Reserve | AllocationType.Commit, MemoryProtection.ReadWrite);
 
IntPtr writedBytesCount;
 
Boolean writed = Exporter.WriteProcessMemory(openedProcess, argLoadLibrary, System.Text.Encoding.ASCII.GetBytes(dllPath), uLenPtr, out writedBytesCount);
 
IntPtr threadIdOut;
IntPtr threadId = Exporter.CreateRemoteThread(openedProcess, IntPtr.Zero, 0, loadLibratyAddr, argLoadLibrary, 0, out threadIdOut);
 
Exporter.CloseHandle(threadId);
}
}

Инъектируемая библиотека

Теперь самое интересное — код библиотеки, которая устанавливает хуки. Эта библиотека написана на С++, пока без аналога на C#.

// dllmain.cpp : Defines the entry point for the DLL application.
#include "stdafx.h"
#include <Windows.h>
 #define SIZE 6
 // Объявления функций и кастомных типов
typedef int (WINAPI *pMessageBoxW)(HWND, LPCWSTR, LPCWSTR, UINT);
int WINAPI MyMessageBoxW(HWND, LPCWSTR, LPCWSTR, UINT);
 void BeginRedirect(LPVOID);
 pMessageBoxW pOrigMBAddress = NULL;
BYTE oldBytes[SIZE] = { 0 };
BYTE JMP[SIZE] = { 0 };
DWORD oldProtect, myProtect = PAGE_EXECUTE_READWRITE;
 BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
                                                                                )
{
                switch (ul_reason_for_call)
                {
                                case DLL_PROCESS_ATTACH:
                                                // Уведомим пользователя что мы подключились к процессу.
                                                MessageBoxW(NULL, L"I hook MessageBox!", L"Hello", MB_OK);
 
                                                // Идем адрес MessageBox
                                                pOrigMBAddress = (pMessageBoxW)GetProcAddress(GetModuleHandleW(L"user32.dll"), "MessageBoxW");
                                                if (pOrigMBAddress != NULL)
                                                {
                                                                BeginRedirect(MyMessageBoxW);
                                                }
 
                                                break;
                                case DLL_THREAD_ATTACH:
                                                break;
                                case DLL_THREAD_DETACH:
                                                break;
                                case DLL_PROCESS_DETACH:
                                                break;
                }
                return TRUE;
}
 
void BeginRedirect(LPVOID newFunction)
{
                // Массив-маска для записи команды перехода
                BYTE tempJMP[SIZE] = { 0xE9, 0x90, 0x90, 0x90, 0x90, 0xC3 };
                memcpy(JMP, tempJMP, SIZE);
                // Вычисляем смещение относительно оригинальной функции
                DWORD JMPSize = ((DWORD)newFunction - (DWORD)pOrigMBAddress - 5);
                // Получаем доступ к памяти
                VirtualProtect((LPVOID)pOrigMBAddress, SIZE, PAGE_EXECUTE_READWRITE, &oldProtect);
                // Запоминаем старые байты
                memcpy(oldBytes, pOrigMBAddress, SIZE);
                // Пишем 4байта смещения. Да, код рассчитан только на x86
                memcpy(&JMP[1], &JMPSize, 4);
                // Записываем вместо оригинальных
                memcpy(pOrigMBAddress, JMP, SIZE);
                // Восстанавливаем старые права доступа
                VirtualProtect((LPVOID)pOrigMBAddress, SIZE, oldProtect, NULL);
}
 
int WINAPI MyMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uiType)
{
                // Получаем доступ к памяти
                VirtualProtect((LPVOID)pOrigMBAddress, SIZE, myProtect, NULL);
                // Возвращаем старые байты (иначе будет переполнение стека)
                memcpy(pOrigMBAddress, oldBytes, SIZE);
                // Зовем оригинальную функцию, но подменяем заголовок
                int retValue = MessageBoxW(hWnd, lpText, L"Hooked", uiType);
                // Снова ставим хук
                memcpy(pOrigMBAddress, JMP, SIZE);
                // Восстанавливаем старые права доступа
                VirtualProtect((LPVOID)pOrigMBAddress, SIZE, oldProtect, NULL);
                return retValue;
}

Ну и несколько картинок напоследок. До установки хука:

Картинка с сайта: habr.com

И после установки:

Картинка с сайта: habr.com

В следующем нашей материале мы постараемся написать код библиотеки, которая устанавливает хуки на C#, т. к. механизм инъектирования управляемого кода заслуживает отдельной статьи.

Авторы статьи: nikitam, ThoughtsAboutProgramming

Что такое EDR?

EDR-системы (Endpoint Detection and Response) состоят из нескольких компонентов (см. рис. 1).

Картинка с сайта: ptresearch.media

Endpoint — конечное устройство: компьютер пользователя, виртуальная машина, сервер организации и т. д. Словом, любое устройство, которое необходимо защитить.

Агент EDR — приложение, которое анализирует события операционной системы и может вынести вердикт, является ли тот или иной объект вредоносным. Плюс осуществляет действия по реагированию, отправляет телеметрию на сервер и получает от него команды.

Сервер EDR — управляющий сервер, который отвечает за администрирование и настройку агентов, отображение событий с Endpoint’ов, генерацию отчетов по инцидентам, управление расследованиями и реагированием.

Драйвер — компонент, работающий в ядре ОС. В системе может быть один или несколько драйверов EDR. Они регистрируют callback-функции для получения нотификаций о старте процессов, загрузке библиотек и других событиях. Для этого используются функции PsSetCreateProcessNotifyRoutine, PsSetCreateThreadNotifyRoutine и PsSetLoadImageNotifyRoutine. Для получения событий файловой системы используется драйвер — мини-фильтр. Также драйверы выполняют функцию самозащиты агента.

Системные журналы — Windows Event Log состоит из множества системных журналов и журналов приложений. Для удобного просмотра в Windows есть утилита Event Viewer.

ETW — Event Tracing for Windows, механизм ОС для трассировки событий приложений и драйверов.

Edr.dll — библиотека, внедряемая в каждый процесс при его запуске (для упрощения повествования назовем ее edr.dll, хотя в реальности она может называться по-разному). Осуществляет перехват (хукинг) вызовов функций Windows API для получения сведений об активности процессов.

Event Tracing for Windows

Механизм Event Tracing for Windows выглядит следующим образом (см. рис. 2).

Картинка с сайта: ptresearch.media

Сессии (сеансы) — предоставляют потребителям события от одного или нескольких провайдеров либо записывают события в лог.

Контроллеры — приложения, которые управляют сессиями. Определяют путь к логу и выявляют, какие провайдеры поставляют события в ту или иную сессию, запускают и останавливают сеансы трассировки.

Провайдеры — приложения, которые занимаются поставкой событий в сессии.

Потребители — приложения, использующие события.

Еще один способ скрыться от EDR — восстановить исходные прологи функций в ntdll.dll. Это можно сделать двумя способами:

• Еще раз загрузить в память процесса ntdll.dll и перезаписать прологи функций.
• Запустить дочерний процесс в Suspended-режиме и перезаписать прологи функций (при запуске дочернего процесса в Suspended-режиме ntdll еще не будет переписана EDR’ом, поскольку драйвер не получит нотификации о старте процесса, пока не будет вызвана функция ResumeThread).

Отметим, что оба подхода содержат аномальное поведение. В первом случае это повторная загрузка ntdll, во втором — запуск процесса в Suspended-режиме (наличие флага CREATE_SUSPENDED можно проверить с помощью перехвата функции CreateProcess).

4. Идем дальше: чтобы обойти EDR’ные хуки, можно вызвать Syscall напрямую. Системный вызов или Syscall — это вызов кода ядра, в ассемблере он выглядит так (см. рис. 3).

Картинка с сайта: ptresearch.media

В регистр EAX помещается номер системного вызова, после этого вызывается инструкция Syscall, которая передает управление на ядерный код. В разных версиях ОС номера системных вызовов могут отличаться, поэтому легитимный софт не использует Syscall напрямую, а вызывает экспорты, предоставляемые системными библиотеками.

В свою очередь, ВПО может выполнять системные вызовы напрямую, чтобы не обращаться к системным библиотекам, функции которых могут быть перехвачены EDR. Но подобное поведение является аномалией, и его можно выявить путем анализа стека вызовов на стороне драйвера EDR. Если системный вызов выполняется не из ntdll.dll, вызывающий процесс нужно завершить.

Общие рекомендации:

• Периодически проверяйте работоспособность хуков (healthcheck).
• Анализируйте стек вызовов в драйвере: детект чтения системных библиотек с диска (вне LoadLibrary), вызовы Syscall не из ntdll.
• Обеспечьте отправку нотификаций на сервер при попытке копирования системных библиотек в произвольные директории.
• Выполняйте отправку нотификаций на сервер при запуске Suspended-процессов.
• Убедитесь в том, что EDR использует несколько источников событий.

Скрытие/мимикрия

Скрытие — это мимикрия вредоносного процесса под легитимный, которая не нарушает работу EDR. Рассмотрим два способа ее реализации.

Спуфинг родительского процесса

В этом случае злоумышленники подменяют родительский процесс, чтобы придать вредоносному более легитимный вид. Если вредоносный процесс запущен доверенным (подписанным Microsoft) приложением, аналитик может не обратить на него внимания.  

Мы уже упоминали структуру STARTUP_INFO, которая передается в функцию CreateProcess. В этой структуре есть поле PROC_THREAD_ATTRIBUTE_PARENT_PROCESS — в него можно записать pid существующего легитимного процесса. При этом и драйвер, и Task Manager будут отображать внедренный pid как родительский.

Обнаружить это довольно легко: смотрим на событие eventid: 1 провайдера Kernel-Process — это событие о запуске процесса. В нем есть поля ParentProcessId (содержит внедренный pid) и Execution ProcessID (содержит pid реального родительского процесса). Если они не совпадают, запущенный процесс и процесс с Execution ProcessID следует завершить.

Также обнаружить подмену родительского процесса можно на уровне драйвера EDR: путем сопоставления значения ParentProcessId с CreatingThreadId –> UniqueProcess из структуры PS_CREATE_NOTIFY_INFO (драйвер EDR выдаст нотификацию о запуске процесса). В обычной ситуации ParentProcessId и CreatingThreadId –> UniqueProcess будут указывать на один и тот же процесс, а в случае спуфинга родительского процесса — на разные (см. рис. 4). 

Картинка с сайта: ptresearch.media

Допустим необходимо выполнить перехват API не только в текущем процессе, но и в всех последующих запущенных процессах.
Это можно сделать с помощью получения списка процессов и заражения новых процессов, но этот метод далеко не идеален, так как процесс до заражения сможет обращаться к оригинальной функции, также такой поиск приводит к лишнему расходованию системных ресурсов.
Из других недостатков данного метода можно отметить то, что глобализатор будет привязан к одному конкретному процессу, а значит, при его завершении весь перехват накроется.
Другой метод состоит в том, чтобы перехватывать функции создания процессов и внедрять обработчик в созданный процесс еще до выполнения его кода.
Процесс может быть создан множеством функций: CreateProcessA, CreateProcessW, WinExec, ShellExecute, NtCreateProcess. При создании нового процесса обязательно происходит вызов функции ZwCreateThread.

Теперь кратко поговорим о возможных применениях перехвата API:
Широчайшее применение подобная технология может найти в троянских программах.
Например можно создать невидимый процесс, скрыть какие-либо файлы на диске, скрыть записи в реестре и скрыть сетевые соединения.
Можно легко обойти персональные фаерволлы. Можно делать с системой все, что угодно.
К примеру, для скрытия файлов на диске нам нужно перехватить функцию ZwQueryDirectoryFile из ntdll.dll. Она является базовой для всех API перечисления файлов.

Рассмотрим прототип этой функции:

Функция записывает набор этих структур в буфер FileInformation.

Во всех этих типах структур для нас важны только три переменных:

NextEntryOffset — размер данного элемента списка.
Первый элемент
расположен по адресу FileInformation + 0, а второй элемент по адресу
FileInformation + NextEntryOffset первого элемента. У последнего элемента
поле NextEntryOffset содержит нуль.
FileName — это полное имя файла.
FileNameLength — это длина имени файла

Для скрытия файла, необходимо сравнить имя каждой возвращаемой записи
и имя файла, который мы хотим скрыть.
Если мы хотим скрыть первую запись,
нужно сдвинуть следующие за ней структуры на размер первой записи. Это приведет
к тому, что первая запись будет затерта. Если мы хотим скрыть другую запись,
мы можем просто изменить значение NextEntryOffset предыдущей записи. Новое
значение NextEntryOffset будет нуль, если мы хотим скрыть последнюю запись,
иначе значение будет суммой полей NextEntryOffset записи, которую мы хотим
скрыть и предыдущей записи. Затем необходимо изменить значение поля Unknown
предыдущей записи, которое предоставляет индекс для последующего поиска.
Значение поля Unknown предыдущей записи должно равняться значению поля Unknown
записи, которую мы хотим скрыть.

Если нет ни одной записи, которую можно видеть, мы должны вернуть ошибку
STATUS_NO_SUCH_FILE.

Скрытие процессов:
Список процессов можно получить различными методами: EnumProcesses, CreateToolHelp32Snapshot и.др., но все эти API обращаются к базовой функции ZwQuerySystemInformation.

Рассмотрим прототип этой функции:

В общем, мы кратко рассмотрели способ скрытия файлов и процессов.

В завершении, приведу пример программы перехватывающей пароли на вход в Windows и при запуске программ от имени пользователя.
Для начала немного теории: при входе пользователя в систему процесс Winlogon.exe проводит его авторизацию через функции библиотеки msgina.dll. Конкретно, нас интересует функция WlxLoggedOutSAS вызывающаяся при входе пользователя в систему.
Вот прототип этой функции:

В одном из номеров нашего журнала в рубрике FAQ был задан вопрос: «Как можно перехватить данные, отправляемые сетевым приложением?». В ответе Step порекомендовал использовать функцию WinSock hook из пакета сетевых утилит – IP Tools. Возможности WinSock hooker мне настолько понравились, что я решил написать свой вариант подобной программы. И в этой статье хочу поделиться с тобой опытом, полученным при разработке.

Теория перехвата WinAPI

Начнем с теории, которую, правда, и так знает большинство наших читателей. Все API функции определены в динамических библиотеках. Сразу возникает вопрос: «Откуда приложение знает, в какой библиотеке объявлена нужная функция?». Ответ прост – в любом PE файле есть область, называемая таблицей импорта. В ней перечислена информация обо всех импортированных функциях, необходимых для корректной работы. Загрузчик PE считывает эту инфу и подгружает необходимые библиотеки в адресное пространство процесса программы. Например, чтобы узнать список всех DLL, подгруженных в адресное пространство процесса, можно воспользоваться утилитой от Марка Руссиновича «Process Explorer». Взгляни на рисунок, на нем отображен список dll процесса Opera.exe.

Обрати внимание на выделенную в нижней части окна «Process Explorer» библиотеку dll с именем WS2_32.dll. В ней определен весь набор сетевых функций WinSock API второй версии. Одну из функций из этой библиотеки нам предстоит сегодня научиться перехватывать. В перехвате нет ничего нетривиального. Все, что требуется от программиста, так это заставить процесс жертвы обращаться не к системной функции, а к нашей – подставной. Дальше остается только командовать. Перехватить API функции можно несколькими способами. Вот самые популярные:

У метода есть как плюсы, так и минусы. Из достоинств можно выделить возможность перехвата абсолютно любых функций, то есть не только тех, что определены в таблице импорта. Среди минусов – вероятность появления ошибок в многопоточных приложениях. Хотя при наличии головы на плечах это достаточно легко обходится. В качестве способа лечения подходит банальная остановка всех потоков приложения и их запуск после установки перехвата. Перехват API удобнее всего осуществлять в контексте процесса «жертвы», поэтому необходимо внедрить свой код в удаленный процесс. Существует несколько «устаканившихся» вариантов вторжения в чужие процессы:

У многих может сложиться впечатление, что перехват – дело объемное и сложное. Действительно, реализовать метод внедрения и перехвата – задача далеко не самая простая, но Delphi программистам сильно повезло. С легкостью организовать перехват функций и внедриться в чужой процесс поможет модуль advHookApi, написанный гениальным программером Ms Rem. Модуль спроектирован качественно, все функции удобно описаны, код оформлен красиво. Единственное разочарование в том, что сегодня уже нельзя выразить респект автору. Этот человек мертв. Очень грустно, что гениальных людей так рано забирает смерть.

Хакерский модуль

Итак, давай посмотрим, какими возможностями может похвастаться данный модуль.

Внедрение Dll в чужой процесс. Метод реализуется с помощью функции InjectDll(), которая описана следующим образом:

function InjectDll(Process: dword; ModulePath: PChar): boolean;

В качестве параметров нужно передать дескриптор процесса, в который будем внедрять dll, и путь к самой библиотеке. В случае успешного внедрения результат будет true. Скрытое внедрение Dll. Функция InjectDllEx() внедряет dll и производит шаманские действия над образом Dll в памяти. После таких настроек многие программы (антивирусы, персональные firewall) начинают нервно курить и не замечать черных дел твоей программы. Внедрение произвольного Exe файла. Осуществляется при помощи функции InjectExe().

function InjectExe(Process: dword; Data: pointer): boolean;

Для работы функции требуется передать два параметра: Дескриптор (handle) процесса, в который будем внедряться и адрес образа файла в текущем процессе.

Инъекция образа текущего процесса. Функция InjectThisExe() будет полезна, когда не хочется или нет возможности юзать библиотеки dll. Описание функции и параметров приводить не стану, так как они стандартные и ничем не отличаются от описания предыдущей.

function InjectThread(Process: dword; Thread: pointer; Info: pointer;
InfoLen: dword; Results: boolean): THandle;

У функции пять входных параметров: 1. Process – дескриптор процесса. 2. Thread – указатель на процедуру, которую будем внедрять. 3. Info – адрес данных для процедуры. 4. InfoLen – размер передаваемых данных. 5. Results – необходимость возврата результата (если true, то функция вернет переданные данные).

function HookCode(TargetProc, NewProc: pointer; var OldProc: pointer): boolean;

Функция устанавливает перехват нужной функции. В качестве параметров просит: 1. TargetProc – адрес перехватываемой функции. 2. NewProc – адрес функции, которая будет вызываться вместо перехватываемой. 3. OldProc – переменная, в которой будет сохранен адрес моста к оригинальной функции (пригодится, когда потребуется остановить перехват и вернуть все на место). Для перехвата функций экспортируемых из DLL в текущем процессе предусмотрена отдельная функция:

function HookProc(lpModuleName, lpProcName: PChar; NewProc: pointer; var OldProc: pointer): boolean;

Входных параметров четыре: 1. Имя модуля (dll). 2. Имя функции; будь внимателен, регистр в указании имени функции играет роль. 3. Указатель на функцию-замену. 4. Адрес к оригинальной функции.

Перехватывать функцию без передышки не имеет смысла, поэтому рано или поздно нужно останавливать процесс перехвата. Для этого в AdvApiHook реализована функция UnhookCode(), которая в качестве единственного параметра принимает указатель на адрес моста к оригинальной функции.

Отключение защиты системных файлов. В ОС Windows, базирующихся на ядре NT, нельзя просто взять и изменить системные файлы – защита System File Protection трогать их не даст. Для решения этой задачи в модуле определена функция DisableSFC(). Передавать параметры ей не требуется. В качестве результата возвращает булевское значение.

Завершение процесса через режим отладки. Наверняка, ты сталкивался с процессами, которые тяжело «убить». Стандартные функции вроде TerminateProceess() не помогают. Для устранения этой проблемы принято использовать так называемые отладочные функции. Сначала процесс переводится в отладочный режим, а потом уничтожается. Таким образом можно завершить практически любой «вредный» процесс. Автор AdvApiHook реализовал простую надстройку для завершения процесса через отладочный режим.

function DebugKillProcess(ProcessId: dword):Boolean;

В качестве единственного параметра функции нужно передать pid процесса. В случае успешного завершения процесса функция вернет true.

Колбасим WinSock Hooker

Довольно теории, пора переходить к практике. Сейчас я расскажу, как написать приложение для перехвата функции send(). Для начала создай в Delphi новый проект и нарисуй форму, хотя бы отдаленно похожую на мою. Как закончишь творческую часть, вставляй наш DVD диск, копируй с него модуль AdvApiHook и немедленно подключай к своему проекту.

Первое, что нам необходимо сделать – научить программу получать список всех запущенных процессов и их дескрипторов. Все эти данные будут отображаться в компоненте ListView. Именно из этого списка мы будем выбирать процесс-жертву. Для получения списка текущих процессов существует несколько способов. Рассмотрим наиболее простой из них – использование модуля tlHelp32, входящего в стандартную поставку Delphi. Ради получения процессов я завел отдельную процедуру – GetAllProcess(). Ее код ты увидишь на врезке.

Код процедуры GetAllProcess()

var
_SnapList : THandle;
_ProcEntry : TProcessEntry32;
begin
If NOT (EnableDebugPrivilege()) Then
begin
reLog.SelAttributes.Color := clMaroon;
reLog.Lines.Add('Не удалось получить привилегии отладчика!');
End;
lvProcessList.Items.Clear;
_ProcEntry.dwSize := SizeOf(TProcessEntry32);
_SnapList := CreateToolHelp32SnapShot(TH32CS_SNAPPROCESS, 0);
If (Process32First(_SnapList, _ProcEntry)) Then
begin
Repeat
with lvProcessList.Items.Add Do
begin
Caption :=IntToStr(_ProcEntry.th32ProcessID);
SubItems.Add(ExtractFileName(_ProcEntry.szExeFile));
end;
Until not (Process32Next(_SnapList, _ProcEntry));
end;
CloseHandle(_SnapList);
End;

В самом начале этой процедуры я вызываю функцию EnableDebugPrivilige(). Функция эта самописная и ее вид ты можешь посмотреть, открыв исходники с диска. Скажу лишь, что она требуется для получения отладочных привилегий. С этими привилегиями появляется возможность получать handle даже у системных процессов. Если функция вернула false, то я просто сообщаю об этом в лог и продолжаю выполнение процедуры. Получение списка процессов сводится к нескольким шагам. Первый этап знаменуется использованием API функции CreateToolHelp32SnapShot(). Она получает снимок объектов, определенных в первом параметре. Я указал константу TH32CS_SNAPPROCESS, которая подразумевает получение снимка одних лишь процессов, так как для сегодняшнего примера этого вполне достаточно. Помимо процессов ты можешь получить:

Если функция CreateToolHelp32SnapShot() выполнилась успешно, значит, нужно пробежаться по списку полученных объектов и вывести их в ListView. Для «пробежки» я использую функции Process32First() и Process32Next(). Параметры у обеих функций одинаковые:

Итак, список процессов у нас есть. Повесь вызов GetAllProcess() на событие OnCreate формы и запусти программу. Если ты не допустил в листинге ошибок, то после запуска ListView должен заполниться списком процессов.

Делаем захват

Теперь, когда у нас есть список процессов, можно приступать к реализации самой главной части – перехвату функций. Перехватывать функции удобнее всего из библиотеки dll. Принцип такой: внедряем библиотеку в чужой процесс, методом сплайсинга делаем перехват. Сейчас все кажется сложным и запутанным, но на самом деле все просто. Создавай в Delphi новый проект типа DLL и потихоньку перекатывай в него бездушные строчки кода из врезки «Код DLL».

Код DLL

library project1;
uses
Windows,
advApiHook,
Messages,
SysUtils;
type
TSocket=integer;
TSendProcedure=function (s: TSocket; var Buf; len, flags: Integer): Integer; stdcall;
var
_pOldSend: TSendProcedure;
_hinst, _h:integer;
procedure SendData(data:string; funcType:integer; Buff:pointer; len:integer);
var
d:TCopyDataStruct;
begin
case funcType of
10:
begin
d.lpData := Buff;
d.cbData := len;
d.dwData := 10;
end;
30:
begin
d.lpData := pchar(data);
d.cbData := length(data);
d.dwData := 30;
end;
end;
SendMessage(_h, WM_COPYDATA, 0, LongInt(@d));
End;
function xSend(s: TSocket; var Buf; len, flags: Integer): Integer; stdcall;
begin
SendData('', 10, addr(string(buf)), len);
result:=_pOldSend(s,buf,len,flags);
end;
procedure DLLEntryPoint(dwReason: DWord);
begin
case dwReason of
DLL_PROCESS_ATTACH:
begin
SendData('Библиотека загружена. Начинается подготовка к перехвату...', 30, nil, 0);
_hinst:=GetModuleHandle(nil);
StopThreads;
HookProc('WS2_32.dll','send',@xSend,@_pOldSend);
SendData('Подмена функций завершилась успехом!', 30, nil, 0);
RunThreads;
end;
DLL_PROCESS_DETACH:
begin
 SendData('Снимаем перехват...', 30, nil, 0);
 UnhookCode(@_pOldsend);
end;
end;
end;
begin
_h:=findwindow(nil,'WinSock Sniffer');
if (_h = 0) then
begin
 MessageBox(0, 'Не найдено окно клиентской части программы!', 'Ошибка!', 0);
 ExitThread(0);
end;
 DllProc := @DLLEntryPoint;
 DLLEntryPoint(DLL_PROCESS_ATTACH);
end.

Рассматривать приведенный код удобнее всего с процедуры DLLEntryPoint. Именно в ней происходит реакция на события, связанные с DLL (загрузка/выгрузка библиотеки). Во время загрузки библиотеки возникает событие DLL_PROCESS_ATTACH. Для нас это знак к установке перехвата. Перед тем, как установить перехват, я отправляю клиенту (основному приложению) информацию о текущей ситуации. В своем примере я передавал целые строки, но на практике лучше отправлять коды событий/ошибок, определить которые можно заранее. Процесс передачи инфы из DLL в основную программу осуществляется с помощью самописной функции SendData(). В теоретической части статьи я описывал минусы перехвата методом сплайсинга. Как ты помнишь, они заключались в потоках. Решение проблемы было также озвучено – это временная остановка всех потоков. Для остановки потоков чужого процесса в модуле AdvAPIHook есть функция StopThreads(). Параметров она не требует. Остановив потоки, можно устанавливать перехват. Для этого я использую функцию HookProc(). В качестве параметров я передаю ей:

Имя библиотеки, в которой объявлена перехватываемая функция. Поскольку в примере меня интересовала лишь функция send(), то я указал W32_32.dll (именно в этой библиотеке определены все функции второй версии WinSock API).

Название функции. В примере я указал «send». Это самая распространенная функция для отправки данных по сети, ее используют практически все приложения. Обрати внимание на регистр, используемый в написании имени функции. Имя функции полностью состоит из маленьких букв. Не обратишь на это внимание – попадешь на отладку таинственных ошибок «Access Violаtion».

Указатель на функцию подставы. В качестве функции подставы в моей библиотеке определена функция xSend(). Указатель на переменную, для сохранения моста к оригинальной функции. Я указываю здесь _pOldSend. После выполнения HookProc() в текущем процессе вместо функции send() будет вызывать xsend(). Целью статьи было показать, как можно перехватывать данные, передаваемые каким-либо сетевым приложением, поэтому в подставной функции я просто передаю буфер с данными. Таким образом, мы получаем то, что требуется нам, а приложение-жертва, ни о чем не догадываясь, продолжает выполнять свою работу. Установив перехват, нужно запустить остановленные ранее потоки. Для восстановления работы потоков я использую функции RunThreads(), которой также не требуются параметры.

Тестируем

Можно считать, что простейший пример перехвата сетевых функций готов. Точнее, реализован процесс перехвата одной лишь функции – send(). Перехват остальных ты сможешь реализовать самостоятельно, тем более что принцип будет полностью таким же. Перед тем, как мы начнем тестировать, откомпилируй библиотеку и вернись к нашему основному проекту. Создай обработчик события OnClick() для кнопки, по нажатию которой мы будем внедрять библиотеку, и перепиши в него код из врезки «Обработчик OnClick()». Я не буду расписывать этот код целиком, так как в нем нет ничего сложного. Все, что в нем происходит – получение handle процесса по его pid и внедрение созданной нами библиотеки с помощью функции InjectDll(), описание которой я уже приводил.

Обработчик OnClick()

_h := OpenProcess(PROCESS_ALL_ACCESS, false, StrToInt(lvProcessList.Selected.Caption));
_dllPath := ExtractFilePath(ParamStr(0))+'test.dll';
InjectDll(_h, pchar(_dllPath));

В качестве теста я решил перехватить данные, которые отправляет всем известный TotalCommander при соединении с FTP сервером. Внедрив нашу хакерскую библиотеку в процесс totalcmd.exe и запустив в Total Commander’е процесс соединения с ftp сервером, я наблюдал, как лог начал заполняться командами протокола FTP. Поскольку протокол FTP не является безопасным, то все важные данные, передаваемые серверу, были успешно перехвачены. Результат ты можешь увидеть на рисунке.

Все готово

В простейшем примере я показал перехват только функции send(). Тем не менее, сетевой набор WinSock API содержит и другие функции для отправки данных, а значит, у тебя есть полигон для новых испытаний. Не ленись ставить различные эксперименты, ведь только путем проб и ошибок можно решить любую задачу. Если у тебя возникли вопросы или предложения, то милости прошу, я всегда открыт для общения.

Статья опубликована в журнале «Хакер» (http://xakep.ru). Май 2008 г.

Ссылка на журнал: http://goo.gl/nTsCWW