Простая прокси-DLL своими руками

в 13:54, , рубрики: Delphi, dll, proxy, windows, системное программирование, метки: , , , ,

Понадобилось мне перехватывать вызовы GDS32.DLL. Решил написать прокси-dll.

Пишем исследовательский стенд

Первое, что нам нужно — это получить список всех экспортируемых функций из настоящей dll.
Сделаем это следующим кодом:

1.	program GetFuncsDll;
2.	  {$APPTYPE CONSOLE}
3.	  uses   Windows;
4.	  var
5.	    ImageBase: DWORD;                  //адрес образа dll
6.	    pNtHeaders: PImageNtHeaders;       // PE заголовок dll
7.	    IED: PImageExportDirectory;        // адрес таблицы экспорта
8.	    ExportAddr: TImageDataDirectory;   // таблица экспорта
9.	    I: DWORD;                          // переменная для цикла
10.	    NamesCursor: PDWORD;               // указатель на адрес имени функции
11.	    OrdinalCursor: PWORD;              // указатель на адрес номера функции
12.	    LIB_NAME:AnsiString;               // имя dll
13.	BEGIN
14.	  LIB_NAME:='MiniLib.dll';
15.	  loadlibraryA(PAnsiChar(LIB_NAME));
16.	  ImageBase := GetModuleHandleA(PAnsiChar(LIB_NAME));
17.	  pNtHeaders := Pointer(ImageBase + DWORD(PImageDosHeader(ImageBase)^._lfanew));
18.	  ExportAddr := pNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
19.	  IED := PImageExportDirectory(ImageBase+ExportAddr.VirtualAddress);
20.	  NamesCursor := Pointer(ImageBase + DWORD(IED^.AddressOfNames));
21.	  OrdinalCursor := Pointer(ImageBase + DWORD(IED^.AddressOfNameOrdinals));
22.	  For I:=0 to Integer(IED^.NumberOfNames-1) do begin
23.	    WriteLn(output,PAnsiChar(ImageBase + PDWORD(NamesCursor)^),'=',OrdinalCursor^ + IED^.Base);
24.	    Inc(NamesCursor);
25.	    Inc(OrdinalCursor);
26.	  end;
27.	Readln;
28.	end.
Листинг 1

Здесь трудностей вроде нет. Добираемся последовательно до таблицы экспорта (строка 19) указателей на массив имен(NamesCursor) и массива номеров(OrdinalCursor) и читаем функцию за функцией, имена и номера. Количество функций находится в поле NumberOfNames. Этот код был добыт на просторах интернета, потом доработан и упрощён.

Рассмотрим нашу тестовую dll.

1.	Library MiniLib;
2.	  function myAdd(a,b:integer): integer; stdcall;
3.	  begin
4.	    result:=a+b;
5.	  end;
6.	  function mySub(a,b:integer): integer; stdcall;
7.	  begin
8.	    result:=a-b;
9.	  end;
10.	  exports
11.	    myAdd,
12.	    mySub;
13.	  begin
14.	  end.
Листинг 2

Здесь трудностей тоже вроде нет. Экспортируем две функции — сложения и вычитания.
список экспортируемых функций и номеров у нас будет такой:

myAdd=2
mySub=1
Листинг 3

Такие номера присвоил компилятор. Почему именно такие? Этого я не знаю.
Теперь сосредоточимся на функции сложения. Посмотрим в какой код откомпилировался её вызов, для этого вызовем её и посмотрим в отладчике.

1.	program TestCall;
2.	  {$APPTYPE CONSOLE}
3.	  uses  Windows;
4.	  var
5.	    myAdd: function (a,b:integer): integer; stdcall;
6.	    Handle:HMODULE;
7.	    N:Integer;
8.	begin
9.	  Handle := loadlibrary('MiniLib.dll');
10.	  @myAdd := GetProcAddress(Handle, 'myAdd');
11.	  //пример получения адреса функции по индексу
12.	  //@myAdd := GetProcAddress(Handle, PChar(2));
13.	  N:=myAdd(1,2);
14.	  writeLn(N);
15.	  readln;
16.	end.
Листинг 4

Тут всё просто. Получаем адрес функции и вызываем её. Поясню лишь, что во втором параметре GetProcAddress указатель на имя функции, но это в том случае, если он больше $FFFF, если меньше или равен, то он воспринимается как номер функции в таблице экспорта. То есть мы можем вызвать функцию по номеру или по имени.

Теперь посмотрим как происходит занесение результата сложения в переменную, а именно работа строки 13.

1. TestCall.dpr.13: N:=myAdd(1,2);
2. push $02
3. push $01
4. call dword ptr [$0040cba4]
5. mov [$0040cbac],eax
Листинг 5

И тут всё просто, помещаем в стек, двойку(2) и единицу(3), вызываем нашу функцию (4), результат сложения помещен компилятором в регистр еах, и потом из регистра копируем результат в переменную N(5).

Вот он перед вами распространенный вызов функции из Dll. Аргументы помещаются в стек, делается call, и из регистров (или стека) считываются результаты.

Идея

Моя идея заключается в том, что когда вместо настоящей лежит моя фейковая dll, то сначала она перехватывает входы функции и имя функции, потом вызывает настоящую функцию и как будто бы ничего не было.

Пишем фейковую Dll.

Итак список функций и номеров у нас есть, но каждой экспортируемой функции должен соответствовать какой-то код. Какой. Вот ради этого всё и пишется. Те примеры, которые я видел на просторах интернета, в них полезный код для каждой перехватываемой функции клонируется, и причем еще надо знать параметры экспорта функции, чтобы вызвать настоящую с теми же самыми параметрами. Мне стало лень проводить такую кропотливую работу(по поиску описания всех функций GDS32 и дублирования на делфи) это раз. И все-таки клонировать полезный код — это «не наш метод». Идея в следующем — мы хотим, чтобы после вызова функции приложением отработал наш код. Раз код один и тот же ну вот и сделаем отдельную процедуру с полезным кодом — ProxyProc. А каждая фейковая процедура должна будет просто вызвать ProxyProc. Дальше прокси-процедура должна как-то узнать какая именно процедура вызвала её. После раздумий пришел к выводу, что идеальный вариант — это поместить в стек номер функции. Также нам надо сохранить состояние регистров и флагов, потому что они могут влиять на выполнение процедуры в настоящей DLL. Итого получаем на каждую экспортируемую функцию четыре строчки кода. И да, раз мы вмешиваемся в глубинные механизмы работы Windows, дабы быть уверенными чего и где мы запортили, писать будем на ассемблере.

1. pushfd //одно и то же для каждой функции
2. pushad //одно и то же для каждой функции
3. push 2 // меняется номер для каждой функции
4. call ProxyProc // одно и то же для каждой функции
Листинг 6

Реализуем идею

А вот и код.

1.	Library minilib2;
2.	
3.	  Uses Windows;
4.	
5.	  Procedure ProxyProc; assembler;
6.	  asm
7.	  end;
8.	
9.	  Procedure FakeProc0001; assembler;
10.	  asm
11.	    pushfd
12.	    pushad
13.	    push 000000001
14.	    call ProxyProc
15.	  end;
16.	
17.	  Procedure FakeProc0002; assembler;
18.	  asm
19.	    pushfd
20.	    pushad
21.	    push 000000002
22.	    call ProxyProc
23.	  end;
24.	
25.	  Exports
26.	    FakeProc0001 index 1  name 'mySub',
27.	    FakeProc0002 index 2  name 'myAdd';
28.	Begin
29.	End.
Листинг 7

Тут всё просто. Экспортируем две фейковые процедуры, а имена и номера им даем такие же как в настоящей dll.
Дальше самая хитрая часть — это сама прокси-процедура. Из чего она должна состоять.

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

Соответственно её код может быть следующим.

1.	const LibName:pAnsiChar = 'MiniLib_.DLL'#0;
2.	Procedure DeveloperProc;
3.	  // процедура разработчика
4.	begin
5.	end;
6.	Procedure ProxyProc; assembler;
7.	asm
8.	  call DeveloperProc;     // Взываем процедуру, в которой читаем в стеке
// и регистрах, всё что хотели перехватить
9.	  add esp,4               // убираем адрес возврата в фейковую функцию
10.	  push LibName           // помещаем адрес имени истинной dll
11.	  call LoadLibraryA     // загружаем dll в память, узнаем адрес
12.	  push eax              // помещаем этот адрес в стек
13.	  call GetProcAddress   // номер функции же уже в стеке. узнаем адрес функции
14.	  mov [esp-4], eax     // отмечаем в стеке этот адрес,
// хотя моя версия винды уже его там отметила
15.	  popad                // восстанавливаем регистры
16.	  popfd                // восстанавливаем флаги
17.	  jmp [esp-40]      // сделали свое грязное дело,
// регистры и стек вернули к исходному состоянию
// передаем управление настоящей функции
18.	end;
Листинг 8

Теперь когда мы откомпилируем этот код, то получим «minilib2.dll'. Переименуем его на „minilib.dll“ и подменим, а „minilib.dll“ переименуем соответственно в „minilib_.dll“

Теперь посмотрим как это работает

TestCall.dpr.13: N:=myAdd(1,2);
1. push $02
2. push $01
3. call dword ptr [$0040cba4] // вызываем myAdd, но попадаем в фейк
4. mov [$0040cbac],eax
Листинг 9
В листинге 9 часть уже виденного кода, который вызывает функцию из Dll и в таблице ниже состояние стека и регистров после попадания в фейковую процедуру, то есть после вхождения в call на строке 3

EAX 00364434
EBX 7FFDA000
ECX 00000000
EDX 00000003
ESI 16A1F224
EDI 13D84260
EBP 0012FFC0
ESP 0012FFA4
EIP 00364434
EFL 00000246
Листинг 10
0012FFAC 00000002 // второй аргумент
0012FFA8 00000001 // первый аргумент
->0012FFA4 0040811A // адрес возврата в экзешник
Листинг 11

Дальше видим слева код нашей четырехстрочной фейковой процедуры и справа состояние стека после попадания в proxyproc, то есть после вхождения в call на строке 4

minilib2.myAdd: // она же fakeProc0002
1. pushfd
2. pushad
3. push $02
4. call $00364408 // вызываем proxyProc
Листинг 12
0012FFAC 00000002 // второй аргумент
0012FFA8 00000001 // первый аргумент
0012FFA4 0040811A // адрес возврата в экзешник
0012FFAO 00000346 // регистр флага
0012FF9C 00364434 // регистр ЕАХ
0012FF98 00000000 // регистр ЕСХ
0012FF94 00000003 // регистр EDX
0012FF90 7FFDA000 // регистр EBX
0012FF8C 0012FFAO // регистр ESP
0012FF88 0012FFC0 // регистр EBP
0012FF84 16A1F224 // регистр ESI
0012FF80 13D84260 // регистр EDI
0012FF7C 00000002 // номер функции (02)
->0012FF78 0036443D // адрес возврата в фейковую процедуру fakeProc0002
Листинг 13

Дальше видим слева код прокси-процедуры и справа состояние стека после получения адреса истинной процедуры после выполнения строки 6. Видим что из стека убран адрес возврата в фейковую процедуру fakeProc0002 и убран номер функции из стека, зато в стеке появился адрес настоящей функции.

minilib2.ProxyProc:
1. add esp,$04
2. push dword ptr [$0036782c]
3. call $00364394 // это LoadLibrary
4. push eax
5. call $00364384 // это GetProcAdress
6. mov [esp-$04],eax
7. popad
8. popfd
9. jmp dword ptr [esp-$28]
Листинг 14
0012FFAC 00000002 // второй аргумент
0012FFA8 00000001 // первый аргумент
0012FFA4 0040811A // адрес возврата в экзешник
0012FFAO 00000346 // регистр флага
0012FF9C 00364434 // регистр ЕАХ
0012FF98 00000000 // регистр ЕСХ
0012FF94 00000003 // регистр EDX
0012FF90 7FFDA000 // регистр EBX
0012FF8C 0012FFAO // регистр ESP
0012FF88 0012FFC0 // регистр EBP
0012FF84 16A1F224 // регистр ESI
->0012FF80 13D84260 // регистр EDI
0012FF7C 0037437C // адрес настоящей процедуры в настоящей dll
Листинг 15

Дальше видим в таблице слева состояние регистров и справа состояние стека перед jmp на истинную процедуру, то есть перед тем как выполнить строку 9 листинга 14. Как видим состояние стека и регистров идентично состоянию сразу после вхождению в фейковую процедуру(листинги 10 и 11), и надеемся истинная процедура DLL не почувствует разницы. (28 в шестнадцатеричной — это 40 в десятичной, то есть 10 раз по 4 байта это как раз то место в стеке, где у нас лежит адрес истинной процедуры (листинг 17)).

EAX 00364434
EBX 7FFDA000
ECX 00000000
EDX 00000003
ESI 16A1F224
EDI 13D84260
EBP 0012FFC0
ESP 0012FFA4
EIP 00364422
EFL 00000246
Листинг 16
0012FFAC 00000002 // второй аргумент
0012FFA8 00000001 // первый аргумент
->0012FFA4 0040811A // адрес возврата в экзешник
1. 0012FFAO 00000346 // регистр флага
2. 0012FF9C 00364434 // регистр ЕАХ
3. 0012FF98 00000000 // регистр ЕСХ
4. 0012FF94 00000003 // регистр EDX
5. 0012FF90 7FFDA000 // регистр EBX
6. 0012FF8C 0012FFAO // регистр ESP
7. 0012FF88 0012FFC0 // регистр EBP
8. 0012FF84 16A1F224 // регистр ESI
9. 0012FF80 13D84260 // регистр EDI
10. 0012FF7C 0037437C // адрес настоящей процедуры в настоящей dll
Листинг 17

И наконец процедура разработчика.

В этой процедуре уже не обязательно писать на ассемблере. Здесь мы собственно и можем сделать перехват, без вреда содержимому регистров и стека.

Например простым кодом, чтобы выводить в файл все номера вызываемых функций может быть такой.

1. Procedure DeveloperProc;
2. var
3.      F:text;
4.    _ebp:PAnsiChar;   //указатель на стек
5.begin
6.	asm
7.	  mov _ebp,ebp;
8.	end;
9.	assignfile(F,'G:Projectsdllproxylogdll.txt');
10.	append(F);
11.	writeln(F,DateTimeToStr(now),': ',PDWORD(_ebp+3*4)^);
12.  closefile(F);
13.end;
Листинг 18

На строке 7 в переменную _ebp занесли указатель базы
на строке 9 связали переменную F с файлом
на строке 10 открыли файл для добавления
На строке 11 записали текущие дату и время, и номер вызванной функции
К указателю базы мы должны прибавить три раза по 4 байта, потому что в стеке после номера функции лежат три указателя: 1. Указатель на возврат в фейковую процедуру, 2. Указатель на возврат в прокси-процедуру и 3. Помещенный компилятором указатель на стек(push ebp). Тип указателя PAnsiChar был выбран, потому что к нему допускаются операции сложения и вычитания с числами.
На строке 12 закрыли файл.

Примеры качать здесь.

P.S. Прокси-GDS32.Dll удачно скомпилировалась, программа её использующая никаких ошибок в работе не выдала, все вызовы были перехвачены в лог-файл, неудачные sql-запросы пойманы и оптимизированы.
P.P.S. Автор данной статьи не несет ответственности за использование информации и материала в этой статье. Вся информация дана исключительно в образовательных целях.

Автор: imrimat

Источник

Поделиться

* - обязательные к заполнению поля