Скачать
код к статье
Вы читали мою
первую статью на эту тему?
Надеюсь, что нет. Она мне страшно не нравилась уже
сразу после опубликования. К тому же, я получил
немало откликов на тему "мало информации",
которые, конечно, считаю справедливыми. Я многое
упустил из виду, исходя из мысли "так, это
понятно, объяснять не нужно". Настало время
всё-таки написать что-то относительно более
полное. К тому же, название той статьи было
"Ассемблер в VB", что не совсем (совсем не)
соответствовало её содержанию. Теперь название
правильное
При написании я предполагал только одно: вы
знаете, что такое указатель.
Введение
Как известно,
прямой работы с указателями в VB нет. Однако есть
функции для почти прямой работы с ними – частично
скрытые (VarPtr, ObjPtr, StrPtr) и скрытые
посильнее (см. статью про GetMem и PutMem). А вот
вызова функций по указателю нет вообще, в то время
как это мощнейший инструмент, очень удобный и
простой. И привнести его в VB – деяние приятное и
полезное. Многое из описанного в этой статье
является весьма и весьма спорным с точки зрения
переносимости, может, непереносимым вообще. Но
возгласы "эй, а это будет работать в следующей
версии VB?" не имеют силы: VB 7 уже вышел. VB 7 –
это совсем не VB 6, это другой язык. Так что мы
знаем, что VB 6 останется именно таким, какой он
есть сейчас. И поэтому мы можем использовать даже
самые непереносимые и несовместимые методики. При
написании этой статьи я придерживался определённой
хронологии и описывал решения в том порядке, в
котором к ним приходил. Копирайт: сама идея вызова
через CallWindowProc с использованием некоей
ассемблерной вставки принадлежит не мне. Но
реализация именно в таких вот видах и именно с
такими вставками – моя. Взгляд изнутри Прежде
всего, необходимо разобраться, что такое вызов
функции на самом низком уровне, с точки зрения
процессора. Как известно, у процессора есть набор
инструкций, заложенных в него проектировщиками,
которые он и исполняет. "Вызов" (функции) – это
тоже просто одна из команд процессора. Их на самом
деле несколько, но мы не будет углубляться в
изучение ассемблера (во-первых, это выходит за
рамки статьи, а во-вторых, я сам в этом не очень
силён
. Запомним пока, что есть такая команда. Теперь
стек... Что такое стек? Это часть памяти
(обыкновенной, оперативной), которая резервируется
при запуске программы (нужный размер этой стековой
памяти записывается компилятором прямо в exe при
создании оного). Особенность работы со стеком
описывается буквосочетанием LIFO (Last In, First
Out; последним пришёл, первым вышел). Образно стек
можно представить как трубу с одним открытым
концом (а другой запаян). Можно положить что-то
внутрь (при этом оно окажется на самом верху),
если есть место, конечно. Можно убрать что-то
(только самое верхнее, снизу нельзя). Можно
посмотреть, что уже наличествует (смотреть можно и
сверху, и глубже – представьте, что вся труба
стеклянная). Принцип стека используется в
программах (во всех программах) по двум причинам.
Во-первых, память резервируется сразу при запуске
программы, а значит, не будет расходов на её
выделение в процессе работы (это обеспечивает
высокую скорость). Во-вторых, это самый простой и
удобный способ сохранения предыдущего состояния,
чтобы сделать что-то другое и потом вернуться.
Когда что-то помещается в верхушку стека, всё
остальное остаётся неизменным, и потому после
удаления верхнего элемента всё как-то само собой
возвращается в исходное состояние, совершенно без
лишних движений. Думаю, теперь можно переходить к
описанию того, как на самом деле происходит вызов
функции. Вызов функции – это помещение параметров
в стек и выполнение процессорной команды call. Вот
и всё. Существует несколько соглашений вызова (они
определяют, как именно помещаются параметры в
стек). Мы будем рассматривать только одно
соглашение – StdCall. Во-первых, именно его
используют все функции Windows, во-вторых, именно
его использует VB. В соответствии с этим
соглашением, параметры помещаются в стек в
обратном порядке (справа налево), а функция сама
удаляет их из стека по завершении работы.
Допустим, у нас есть функция
Function Sum (ByVal p1 As Long, ByVal p2 As Long, ByVal p3 As Long) As Long
которая возвращает сумму своих аргументов.
Когда мы вызываем её, выполняется такой код:
push p3
push p2
push p1
после чего происходит вызов
функции Sum.
Как вы
догадались, команда процессора push означает
"поместить в верхушку стека". Как нетрудно видеть,
первый аргумент окажется в самой верхушке стека,
ведь он помещён туда последним. Функция Sum всё
это знает, и свои аргументы оттуда берёт (она пока
не удаляет их! она пользуется тем, что труба
стеклянная). Закончив работу, функция Sum должна
вернуть управление туда, откуда её вызвали (иначе
программа остановится… вернее, она рухнет, но это
детали…). Но КУДА должна вернуть управление
функция Sum?
Я написал "после чего происходит
вызов функции Sum", но я не написал, как именно он
происходит. Очень просто - выполняется
единственная команда процессора Call. Эта команда
передаёт управление функции Sum, но перед этим
помещает в верхушку стека адрес, по которому
должна вернуться эта самая Sum! В результате
непосредственно перед передачей управления в
функцию Sum стек приобретает вид:
Адрес возврата
Параметр p1
Параметр p2
Параметр p3
[всё, что глубже, помещено не нами и нас не интересует...]
Закончив работу, функция Sum
вернёт управление по тому адресу, который лежит в
самой верхушке стека. Непосредственно перед этим
она удалит (на сей раз именно удалит, а не
просмотрит) из стека и этот адрес, и все свои
параметры.
Ну вот, теперь, кажется, мы знаем
достаточно
Ну что, поехали…
Напрямую...
А зачем нам
это всё? Ну писали бы на ассемблере, а из VB-то мы
не можем вызвать конкретные команды процессора...
Да, не могли бы, если бы не одна единственная
API-функция CallWindowProc (собственно, ей нужно
ставить памятник, она действительно ОДНА...). Эта
функция предназначена для вызова обработчика
оконных сообщений, но суть её работы сводится к
простой упаковке параметров в стек и передаче
управления! Иными словами, она не проверяет, что
именно её заставляют вызвать (да и не смогла бы
проверить при всём желании). А раз она обычная
API-функция, то мы можем её Declare. Ну и всё,
можете вызывать что хотите, спасибо за внимание...
Нет, на самом деле проблемы только начинаются.
Проблема первая –
количество параметров. Нетрудно видеть, что у
CallWindowProc параметров ровно пять, из них один
– адрес функции (или указатель на функцию; что-то
давно не упоминалось мною это славное слово).
Значит, вызываемая функция должна иметь ровно 4
параметра. Ведь у нас соглашение StdCall, помните?
А оно требует, чтобы функция удаляла свои
параметры из стека сама. Если функция была
откомпилирована для работы с 3 параметрами, она
удалит из стека ровно 3 параметра, и вы даже не
можете себе представить, насколько ей безразлично,
сколько их было туда помещено на самом деле.
Результат – нарушение структуры стека (вызывающая
сторона в недоумении, она-то уверена, что удалены
4 параметра, а тут...) и немедленный crash. Так
что использовать функцию CallWindowProc напрямую
можно лишь в одном случае: если вы уверены, что
вызываемый код завершается командой процессора ret
0x0010 (это команда "возврат" с удалением из стека
&H10 байт. &H10 – это 16, а 16 – это 4*4,
то есть 4 параметра по 4 байта каждый. Они все 4
байта, параметры-то). В этом можно быть уверенным
у в двух случаях: вы знаете, что у функции 4
параметра или же вы сами написали некий код,
завершающийся командой ret 0x0010. Чувствуете,
куда клоню? ;)
Даже если
чувствуете, всё равно запомним промежуточный
результат (промежуточных результатов будет
несколько, и каждый имеет полное право на
самостоятельное и независимое существование и
использование):
Можно
напрямую использовать функцию CallWindowProc для
вызова другой функции. Для этого в качестве
первого параметра нужно передать указатель на эту
функцию, а в качестве остальных – параметры этой,
вызываемой, функции. Жёсткое ограничение: у
вызываемой функции должно быть ровно 4 параметра.
Приведём маленький код в подтверждение
сказанного.
Option Explicit
Private Declare Function CallWindowProc Lib "user32.dll" _
Alias "CallWindowProcA" (ByVal lpPrevWndFunc _
As Long, ByVal hwnd _
As Long, ByVal msg As Long, ByVal wParam _
As Long, ByVal lParam As _
Long) As Long
Private Declare Function _
FreeLibrary Lib "kernel32.dll" (ByVal _
hLibModule As Long) As Long
Private Declare Function GetProcAddress Lib "kernel32.dll"_
(ByVal _
hModule As Long, ByVal lpProcName As String) As Long
Private Declare Function LoadLibrary Lib "kernel32.dll" _
Alias "LoadLibraryA" (ByVal _
lpLibFileName As String) As Long
Private Sub Form_Load()
Dim user As Long
user = LoadLibrary("user32.dll")
CallWindowProc GetProcAddress(user, "MessageBoxA"), _
Me.hwnd, StrPtr(StrConv("Ну что, работает!", vbFromUnicode)), _
StrPtr(StrConv("Заголовок", vbFromUnicode)), 0
FreeLibrary user
End Sub
Пока не обращайте внимания на StrPtr и StrConv,
потом всё скажу
И в обход…
Вспомним
те два случая, в которых можно быть уверенными
Не случай номер 1 мы повлиять не можем (на самом
деле, при известном шаманстве возможно всё, но я
не буду соблазнять вас на модификацию самой
команды Ret в теле откомпилированной вызываемой
функции; да и что если параметров больше 4, а не
меньше?), так что вплотную займёмся вариантом
номер два.
Да, мы будем писать код. Но мы
будем писать машинный код. Не бойтесь, это
несложно
Машинные коды, соответствующие инструкциям Push,
Call и Ret легко посмотреть в соответствующих
мануалах от Intel или ещё от кого. И их всего три!
Поехали.
Задача: мы
должны создать в памяти (а больше негде) участок
готового машинного кода, который бы завершался
командой ret 0x0010, и при этом был бы способен
вызывать функцию с любым количеством параметров.
Тогда мы сможем передать управление на этот
участочек с помощью CallWindowProc, участочек
вызовет функцию, управление вернётся на участочек,
а он вернёт его в CallWindowProc, выпихнув из
стека правильное количество параметров (четыре,
четыре...). Делов-то!
Всё это должно выглядеть так:
push параметрN
push параметр(N-1)
...
push параметр2
push параметр1
call function
ret 0x0010
Как видно, нам
не удастся сделать участочек неизменяемым: он
будет зависеть от количества параметров.
Где-то я прочитал, что начало функции должно быть
на границе двойного слова... Честно говоря, я не
знаю, так ли это, и не знаю, зачем это нужно
Но я следую этому правилу, и потому память для
участочка выделяю через GlobalAlloc – эта функция
выделяет память сразу по искомой границе.
Обращение к этой памяти реализовано через GetMem и
PutMem (вы ведь знаете про них, правда?). Итак:
выделяем участок памяти, заносим в нужные места
этого участка команды push (это просто байт
&H68), заносим после каждого байта push один
параметр (четыре байта), добавляем команду Call
(это байт &HE8) и команду Ret 0x0010 (это три
байта: C2 10 00).
Что получаем?
Private Const GMEM_FIXED As Long = &H0
Private Const MAX_PARAMS As Long = 10
Public Function CallFunction(ByVal FuncPointer As Long, _
ParamArray p()) As Long
Dim i As Long
Dim hGlobal As Long, hGlobalOffset As Long
'Учтём совпадение числа параметров:
If UBound(p) - LBound(p) + 1 = 4 Then
CallFunction = CallWindowProc(FuncPointer, _
CLng(p(0)), CLng(p(1)), CLng(p(2)), CLng(p(3)))
Else
hGlobal = GlobalAlloc(GMEM_FIXED, 5 * MAX_PARAMS + _
5 + 3 + 1) 'Заполняем всё подряд, ZEROINIT не нуно.
If hGlobal = 0 Then Err.Raise 7 'insuff. memory
hGlobalOffset = hGlobal
For i = LBound(p) To UBound(p)
'если параметров нет, то ubound<lbound, и цикл не выполнится вообще
PutMem2 hGlobalOffset, &H68 'asmPUSH_imm32
hGlobalOffset = hGlobalOffset + 1
PutMem4 hGlobalOffset, CLng(p(i))
hGlobalOffset = hGlobalOffset + 4
Next
'Добавляем вызов функции
PutMem2 hGlobalOffset, &HE8 ' asmCALL_rel32
hGlobalOffset = hGlobalOffset + 1
PutMem4 hGlobalOffset, FuncPointer - hGlobalOffset - 4
hGlobalOffset = hGlobalOffset + 4
PutMem4 hGlobalOffset, &H10C2& 'ret 0x0010
CallFunction = CallWindowProc(hGlobal, 0, 0, 0, 0)
GlobalFree hGlobal
End If
End Function
'Вызывающий код. Я его больше не буду повторять, ладно?
Private Sub Form_Load()
Dim user As Long
user = LoadLibrary("user32.dll")
MsgBox CallFunction(GetProcAddress_
(user, "GetWindowTextLengthA"), Me.hwnd)
FreeLibrary user
End Sub
Вот и ещё один промежуточный
результат. В принципе, это готовое решение для
вызова чего угодно с любым числом параметров. Мы,
конечно, пойдём дальше, но в такой форме оно тоже
может использоваться, а порой и удобнее всего.
Далеко в обход...
Что может заставить нас идти
дальше? Так это же интересно! Кому не интересно,
остаётся на только что достигнутом результате, а
мы продолжаем.
Что бросается в глаза - так это
ParamArray. Вот если бы можно было задать его тип,
чтобы не Variant... А так приходится делать CLng,
да и вообще, Variant работает медленно. Жёстким
волевым решением постановляем: Variant убрать,
перейти на Long. Правда, придётся ввести
дополнительный параметр, определяющий количество
остальных параметров.
А как же удобно получать
эти остальные параметры, спросит внимательный
читатель, ведь теперь мы не можем обращаться к ним
в цикле! Неужели многочисленные If ParamsCount
< ... ? Конечно же нет! Вспомним, ведь наша
"вызывалка" - это тоже функция! А раз так, она
тоже подчиняется StdCall! А раз так, её параметры
идут в стеке в обратном порядке! А раз так, мы
можем их получить, если будем иметь "точку опоры"!
А она у нас есть - это VarPtr первого параметра!
Именно это великое число и показывает положение в
стеке первого нашего "значимого" параметра.
Последовательно прибавляя к нему 4, мы будем
получать указатель на второй параметр, на
третий...
В объектно-ориентированный обход...
Кто-то ещё в чём-то сомневается?
Нет? Правильно. Возможно всё.
Знатоки
технологии OLE наверняка уже в задумчивости.
Функциональность любого объекта OLE определяется
списком интерфейсов, которые реализует этот
объект. А интерфейс – это что? Интерфейс – это
указатель на таблицу указателей на функции. А
вызывать функции по указателю мы уже худо-бедно
умеем, разве нет? Следовательно, модифицировать
CallFunction в CallInterface мы сможем очень
легко. Для этого надо учесть лишь две вещи:
-
указатель на интерфейс – это только первый шаг.
Нужно найти, куда он указывает (а указывает он на
таблицу функций), сместиться по этой таблице на
нужное количество ячеек (одна ячейка – один
указатель на метод) и посмотреть, что же в этой
ячейке. Это и будет указатель на искомый метод.
- у каждого интерфейсного метода есть неявный
первый параметр – указатель на сам интерфейс.
Теперь у нас снова достаточно информации
Располагаем параметр pInterface непосредственно
перед параметром p1, передаём ассемблерной
вставочке не ParamsCount, а ParamsCount + 1, и не
VarPtr(p1), а VarPtr(pInterface). Ну и указатель
на функцию находим описанным выше способом. См.
код!
"А зачем это нужно? Ведь VB может
работать с объектами и просто так. Просто создаём
объект через CreateObject, ставим точку и пишем
имя метода – пусть списочка методов и нет, но VB
разберётся!" VB, конечно, разберётся, но только
если этот объект поддерживает интерфейс IDispatch.
А если не поддерживает, то для работы с таким
объектом позднее связывание (да, это оно работает,
когда вы вызываете методы из ниоткуда) не
работает. Для работы с таким объектом нужно иметь
его описание – Type Library, библиотеку типов.
Иметь её должен только разработчик, после
компиляции она не нужна. Если же нет и библиотеки,
то вызвать метод объекта можно только таким вот
способом.
Ещё один промежуточный вариант.
Теперь мы можем вызвать любой метод любого
интерфейса, даже не имея его type library. Для
этого нужно иметь указатель на интерфейс (это
ObjPtr), а также знать номер вызываемого метода.
Номера методов можно посмотреть в файлах .h или в
документации. Лучше, конечно, иметь tlb, благо
создать его не так уж сложно, но об этом я здесь
не буду.
Слушайте! Идея пришла только
что... А пусть получением параметров занимается
сама ассемблерная вставочка! Во-первых, получится
гораздо быстрее, во-вторых, можно будет сделать
вставочку фиксированного размера (там будет
цикл!). Подставляем только кол-во повторений,
указатель на параметры и указатель на функцию!
Ну-ка... Ну надо же... Нет, идея правда пришла
только что!
И давайте, наконец-то, вынесем это
дело в класс. Во-первых, у нас теперь есть
необходимость в инициализации (вставочка-то теперь
постоянного размера), а во-вторых, так мы сможем
привязать экземпляр класса к библиотеке. Я не буду
приводить полный код здесь, но в аттаче вы его
найдёте и во всём разберётесь. А здесь - только
обновлённый код CallFunction:
Public Function CallFunction(ByVal FuncName As String,_
ByRef FuncPointer As Long, ByVal ParamsCount As Long,
_ Optional ByVal p1 As Long = 0,_
Optional ByVal p2 As Long = 0, Optional _
ByVal p3 As Long = 0, _
Optional ByVal p4 As Long = 0, Optional _
ByVal p5 As Long = 0, Optional _
ByVal p6 As Long = 0, Optional _
ByVal p7 As Long = 0, Optional ByVal _
p8 As Long = 0, Optional_
ByVal p9 As Long = 0, Optional ByVal _
p10 As Long = 0) As Long
'Сделаем так:
' - если FuncPointer = 0, то проиходит вызов FuncName, а через
' FuncPointer возвращается указатель на эту функцию.
' - если FuncPointer <> 0, то происходит вызов этого самого FuncPointer,
' а FuncName игнорируется.
If ParamsCount < 0 Then Err.Raise 5 'invalid call
If FuncPointer = 0 Then
FuncPointer = GetProcAddress(m_hLib, FuncName)
If FuncPointer = 0 Then Err.Raise 453 'function not found
End If
If ParamsCount = 4 Then
CallFunction = CallWindowProc(FuncPointer, p1, p2, p3, p4)
Else
PutMem4 hGlobal + 1, ParamsCount
PutMem4 hGlobal + 6, VarPtr(p1)
PutMem4 hGlobal + 22, FuncPointer - (hGlobal + 22) - 4
CallFunction = CallWindowProc(hGlobal, 0, 0, 0, 0)
End If
End Function
Вот и ещё один промежуточный
результат. Для вызова нужно явно указать число
параметров, а затем и перечислить их. Параметры
помещаются в стек ассемблерным циклом, поэтому их
количество может быть любым. Если вам не хватит
10, добавляйте ещё (в форме "optional byval p# as
long", где # - номер очередного параметра). Ни код
функции, ни инициализация класса от этого не
изменятся.
Большинство команд заполнения
ассемблерной вставки перенесено в инициализацию
класса, благодаря чему возросла скорость
вызова.
Запомним и этот вариант; а какой где
использовать, разберёмся в конце.
Сусанин отдыхает...
Что, можно придумать что-то ещё?!
А вы как думали!Согласитесь, вызов функции через
CallFunction довольно удобен, а поначалу просто
шикарен... Но когда попривыкнешь, начинаешь думать
о чём-то ещё более удобном... Вот если бы
совместить обычный синтаксис VB с вот этим всем...
Ну так в чём же дело?
Помещаем в модуль
функцию. Задаём ей список параметров,
соответствующий списку параметров вызываемой по
указателю функции. В тело функции помещаем
единственную команду – возвращение нуля. Берём
адрес этой функции (AddressOf). Адрес функции –
это место в памяти, где расположена первая команда
функции. Так вот пишем в это место совсем другую
команду, а именно команду безусловного перехода на
нужный адрес – jmp. Команда jmp не меняет
содержимого стека. В результате цепочка будет
такой:
- мы пишем по адресу VB-функции команду
jmp. Мы делаем это 1 раз, потом будем пользоваться
сколько угодно
- вызываем эту VB-функцию
(обычным синтаксисом VB, как обычную функцию
модуля)
- VB думает, что мы правда хотим
именно эту функцию, упаковывает параметры в стек
(сам, без нас) и передаёт управление на свой
модуль
- а там команда jmp! Сразу и без
вопросов получается переход на тот адрес, который
нам на самом деле нужен. Очень быстрый переход.
- управление переходит в действительно нужную
нам функцию. С её точки зрения всё прекрасно:
параметры упакованы в стек как нужно, а команда
jmp не поменяла ни их, ни адрес возврата. Поэтому
при завершении работы управление будет возвращено
не в модульную функцию VB, а в то место, откуда
была вызвана модульная функция
- VB вообще об
этом не подозревает. Он думает, что модульная
функция успешно завершилась.
Позвольте, а почему я решил, что в AddressOf
функции хватит места для записи команды перехода и
адреса перехода? А потому что я скомпилировал
проект с пустой функцией с одним параметром,
возвращающей ноль, и нашёл её в exe. Код
следующий:
xor eax, eax
ret 4
Кто-то ещё сомневается в крутизне
компилятора VB?
Но не отвлекаемся: указанные две команды занимают
ровно 5 байт. Именно столько нам и нужно.
Фантастика. Даже лишних растрат памяти на
функции-пустышки не будет.
Вот! Наконец-то!
Вызов любых функций по указателю синтаксисом VB!
Единственная проблема – работает это только в
exe по причинам, которые выходят за рамки этой
статьи. Раз так, провести отладку не сможем.
Потеря отладки – серьёзный недостаток, и мириться
с ним я бы не стал. Но позвольте! Первые варианты
прекрасно работают и в exe, и в IDE. Но они
существенно медленнее и не позволяют осуществлять
вызов синтаксисом VB... Но это не имеет значения,
потому что мы объединим их через условную
компиляцию. При работе из IDE будет использоваться
медленный, но совместимый с IDE способ, а при
компиляции в exe будет записан быстрый.
А как
же права записи? PutMem4 тут не поможет, нет права
на запись в эту часть кода. А вот
WriteProcessMemory пофигист куда больший.
А
как же синтаксис вызова? Он же разный? Шерстить
всю программу? Ну уж нет... Тут пришлось немного
постараться, но в результате вызов "совместимым"
способом стал с точки зрения внешнего пользователя
неотличим от вызова "несовместимым". Для настройки
функции на нужный указатель используется
SetFunction, а вызов настроенной функции – как
всегда вызывали функцию модуля.
Логика тут
такая.
Если #ReleaseBuild = False, то:
-
модуль содержит коллекцию, хранящую служебную
информацию, а также функцию CallFunction.
-
вызов SetFunction приводит к занесению в коллекцию
адреса реального вызова, ключом для которого
является строковое представление адреса
функции-пустышки. Переписывание тела пустышки не
производится.
- Будучи вызванной,
функция-пустышка извлекает из коллекции тот адрес,
с которым она ассоциирована, и вызывает
CallFunction по этому адресу.
- Код пустышки
несколько усложняется, писать его вручную уже не с
руки (об этом ниже). Не огорчайтесь, в exe попадёт
единственная команда xor eax, eax...
- Да, всё
это очень медленно! Но это только для отладки.
Если #ReleaseBuild = True, то:
-
Модуль не содержит ничего, кроме пустышек.
Пустышки не содержат ничего, кроме команды
возвращения нуля.
- Вызов SetFunction приводит
к прямой записи по указанному адресу, без всяких
проверок (предполагается, что всё уже отлажено. Вы
же не будете отлаживать в режиме ReleaseBuild =
True? А раз вы всё уже отладили, зачем проверки?).
- Максимальная скорость! Серьёзно.
Вот
такая вот логика
Спокойно пишем свой рулезный софт, используем
вызов по указателю, всё тестируем, и т.д. и т.п.
Убедившись в работоспособности, ставим
ReleaseBuild = True и компилируем. Всё,
опять-таки, работает, но на гораздо большей
скорости.
Самые ленивые, однако, уже отметили,
что придётся писать усложнённый код пустышек.
Придётся! Не хотите – пожалуйста, с потерей
отладки... Ну ладно, ладно
В конце концов, можно переложить эту работу на
IDE. Для этого нужно всего лишь написать add-in
(стандартный шаблон оной есть в окне создания
нового проекта). Используя события среды,
надстройка будет отслеживать активное окно с
кодом. Если это окно является модулем (а пустышки
могут быть только там), начинается сабклассинг
оного (дело в том, что у кодовых окон нет нужных
нам событий). Перехватывается нажатие Enter. Если
Enter нажат на строке, содержащей кодовую
последовательность
#func MyFunction(paramlist)
то происходит замена этой
последовательности на тело соответствующей
пустышки! Paramlist – список параметров функции,
по тем же правилам, что и всегда. Код пустышки
будет сгенерирован с подстановкой VarPtr, ObjPtr и
StrPtr в тех местах, где это необходимо. Обратите
внимание – используется полное имя функции в форме
ИмяМодуля.ИмяФункции. Это связано с тем, что иначе
нельзя получить адрес функции из самой этой
функции.
Применимость
Применять при вызове функций по
указателю!
Теперь чуть более подробно. Все параметры должны
быть размером 4 байта. Целые числа можно
передавать по значению. Целые и нецелые числа
можно передавать по указателю (т.е. в качестве
параметра нужно указать VarPtr).
Строки нужно
передавать либо по значению (StrPtr), либо по
ссылке (VarPtr). На самом деле, в обоих случаях
будет передан указатель, в первом случае – на
строковые данные, во втором – на переменную VB,
содержащую указатель на эти строковые данные.
Объекты нужно передавать по значению (ObjPtr)
или по ссылке (VarPtr). Правила те же, что и со
строкой.
Неявное конвертирование из Unicode в
Ansi не происходит! Поэтому если вы вызываете
функцию, ожидающую Ansi, вы должны передать ей
что-то вроде StrPtr(StrConv("string",
vbFromUnicode)). Если же функция ожидает Unicode,
передавайте StrPtr("string").
Используйте
прямой вызов CallWindowProc, если у вызываемой
функции ровно 4 параметра, а больше ничего вы и не
вызываете. Ну бывают такие совпадения.
Используйте CallFunction с ParamArray в том
случае, когда вы не хотите включать в проект
модуль с пустышками, когда для вас не критична
скорость, и когда вы не хотите каждый раз
указывать число параметров явно.
Используйте
CallFunction с явным указанием числа параметров в
том случае, когда вы не хотите включать в проект
модуль с пустышками, когда скорость гораздо более
важна (тогда почему вы пустышки-то не хотите?) и
когда вам нужна большая жёсткость при передаче
параметров. В предыдущем варианте вы могли
передать любое выражение в качестве параметра, а
здесь – только Long. Теперь вы не забудете о том,
что строки передаются через StrPtr, переменные по
ссылке – через VarPtr. Иначе просто не будет
компилироваться. В принципе, этот метод
предпочтительнее, во избежание ошибок.
Используйте функции-пустышки, когда вы хотите
вызывать что угодно по указателю синтаксисом VB
или когда для вас критична скорость вызова. Не
обращайте внимания на медленный вызов из IDE, он
всё равно не попадёт в exe. Надстройка, следящая
за вводом кодовой последовательности шаблона,
будет генерировать код пустышек, подставляя
VarPtr, StrPtr и ObjPtr там, где это нужно.
Главное – перед компиляцией не забудьте установить
ReleaseBuild = True.
И последнее
Я писал всё это в расчёте на
понимающего читателя, который не будет пытаться
передать пустышке Variant ByVal, или Double тем же
способом. Параметры размером 4 байта все. Для
работы с API этого более чем достаточно, а для
передачи больших данных используются указатели
(передать Variant ByRef – всегда пожалуйста).
Генератор кода пустышек будет стараться исправлять
ваши возможные ошибки.
Автор: Сергей
Гергерт
Комментарии
Статья замечательная, однако, есть ряд
неучтённых нюансов, которые делают предложенный
метод не очень удобным.
Начнём с мелочей.
В качестве инструкции ветвления автор
предлагает использовать инструкцию ветвления
- безусловный переход по относительному
адресу:
jmp rel32
Однако, очевидно, что данный метод весьма
неудобен по ряду причин. Если вдруг захочется
изменить адрес, придётся заново обращаться к
SetFunction, а это не очень удобно. Да и зачем это
делать зазря ,
если можно и вовсе обойтись без повторного
обращения к SetFunction? Достаточно лишь
использовать безусловный переход по адресу,
содержащемуся в таком-то месте адресного
пространства. Под <таким-то местом адресного
пространства> я подразумеваю наибанальнейшую
(глобальную) переменную. Ладно,
от разговора на языке жестов перейдём к
инструкции:
Public vCallAddress as Long, Ia() as Byte
ReDim Ia(1 to 6)
'jmp dword ptr
ds:[imm32=VarPtr(vCallAddress)]
Ia(1)=&HFF: Ia(2)=&H25: PutMem4
VarPtr(Ia(3)), VarPtr(vCallAddress)
Массив объявлен условно, лишь для того, чтобы
показать, как это выглядит в машинных кодах.
На самом деле, чтобы адекватно заменить
инструкцию в примере Сергея необходимо учитывать,
что его инструкция занимает пять байт. Она
устанавливается из SetFunction в
PlaceholderFor1ParamFunction вместо находящихся
там после линковки инструкций
xor eax,eax
ret 4
которые тоже занимают пять байт. А наша
инструкция занимает шесть байт. Но это очень
просто поправить, достаточно переписать
PlaceholderFor1ParamFunction в виде
Public Function
PlaceholderFor1ParamFunction(ByVal p As Long) As
Long
#If ReleaseBuild Then
PlaceholderFor1ParamFunction
= 1&
#Else
Dim a As Long
On Error Resume Next
a =
mCol(CStr(ReturnMe(AddressOf
modFuncCall.PlaceholderFor1ParamFunction)))
On Error GoTo 0
If a Then
PlaceholderFor1ParamFunction = CallFunction(a, 1,
p)
#End If
End Function
тогда при линковке туда будут записаны
инструкции
mov eax,imm32
ret 4
занимающие восемь байт, теперь перезаписываемый
фрагмент будет выглядеть
ReDim Ia(1 to 8)
'jmp dword ptr
ds:[imm32=VarPtr(vCallAddress)]
Ia(1)=&HFF: Ia(2)=&H25: PutMem4
VarPtr(Ia(3)), VarPtr(vCallAddress)
'nop
'nop
Ia(7)=&H90: Ia(8)=&H90
Теперь, чтобы сделать переадресацию, не нужно
больше обращаться к SetFunction, а достаточно
всего лишь:
vCallAddress=vNewValue
и можно опять обращаться к
PlaceholderFor1ParamFunction.
Это были мелкие замечания, так сказать, <по
процедурному вопросу>. Теперь хотелось бы
поговорить об упущенных нюансах, имеющих, тем не
менее, глобальный характер.
Не очень верным является мажорное высказывание
автора в адрес CallWindowProc. Да, безусловно,
чем-то эта функция хороша, однако, мне не кажется,
что это удобный метод переадресации, тем более под
IDE.
Какие будут мои аргУменты? Да очень простые!
Давайте сначала вспомним, как вообще процессор
<понимает> из какого места адресного
пространства необходимо исполнять инструкцию. Для
указания адреса исполняемой инструкции
используется регистр eip. Причём, нет инструкций
явных чтения/записи из этого регистра. А в
качестве неявно изменяющих содержимое регистра eip
используются jmp, jxx и пары call-ret,
enter-leave. VB'эшные компилятор и интерпретатор
обычно используют jmp, jxx и пару call-ret.
Последняя, как раз, нас и интересует. Выполнение
инструкции
call operand
сводится.
push eip
jmp operand
или ещё подробнее к
mov dword ptr ds:[esp-4],eip
sub esp,4
mov eip,operand
После того, как старое значение eip сохраняется
в стеке (в регистре esp находится указатель на
начало стека), а значение operand'а загружается в
eip, процессор <сам по себе> переходит к
выполнению инструкции, находящейся по этому
адресу.
Итак <на вершине стека> у нас находится
указатель на то место, куда будет необходимо
вернуться после выполнения вызываемой функции.
Возврат осуществляется инструкцией
ret optional imm16
optional imm16 используется для очистки стека,
если это необходимо.
Развёрнутая интерпретация
этой инструкции выглядит
add esp,optional imm16+4
mov eip,dword ptr ds:[esp-optional
imm16-4]
Причём, если прочее содержимое стека не
меняется, то место по адресу [esp-optional
imm16-4] после этого уже не содержит адрес
возврата. Теперь после маленького ликбеза
<вернёмся к нашим баранам>.
В среде VB из любой процедуры, независимо от
того IDE это или откомпилированный файл, возврат
ВСЕГДА осуществляется с помощью инструкции
ret imm16
Таким образом, если внутри нашей процедуры
изменить значение <на вершине
стека>, то
вместо возврата произойдёт передача управления на
тот адрес,
который мы запишем по адресу,
содержащемуся в esp. Но как узнать значение
регистра esp, как узнать адрес начала стека?
Заметьте, сам автор пишет:
<перед передачей
управления в функцию : стек приобретает
вид:>
Но как будто он ничего при этом не замечает.
Заметьте, что первым параметром в стеке является
адрес возврата! Тот самый, по которому происходит
возврат из функции при выполнении инструкции
ret imm16
А где у нас находится начало стека при передаче
управления, скажем, в такую
функцию:
Private Function Test(byval vP1 as Long)as
Long
:
End Function
Ну, разумеется, в откомпилированном виде начало
стека будет находиться по
адресу:
vESP = VarPtr(vP1) - 4
А в IDE, спросите вы, где будет начало стека
при вызове функции в IDE? Ну, здесь всё очень
просто. По ряду причин, которые я не хотел бы
здесь обсуждать, вызов процедуры <из под>
IDE осуществляется почти так же, как
осуществляется в откомпилированном виде вызов
функции из чужого ActiveX (кстати, думаю, что
самые сметливые уже догадались, почему так
происходит в IDE). Что это значит? Да вот что:
начало стека и первый параметр разделяет ещё один
параметр (указатель на адреса ObjTable). То есть
начало стека находится следующим образом:
vESP = VarPtr(vP1) - 8
Теперь достаточно сохранить этот адрес в
<какой-нибудь> (специально для этого
предназначенной)
переменной
Public pRet as Long
CopyMem VarPtr(pRet), vESP, 4
после этого по адресу vESP можно записать новый
(необходимый нам) адрес.
И далее, процессор <сам по себе>
переходит на адрес, скажем, на следующий
переключатель в маш. кодах:
Public RDa() as Byte, pRD as Long
Private Sub InitRD()
ReDim RDa(1 to 16)
'восстанавливаем значение регистра
esp
'sub esp,imm8=4
RDa(1)=&H83: RDa(2)=&HEC:
RDa(3)=4
'заново прописываем адрес возврата,
предварительно сохранённый нами в pRet
'push dword
ptr ds:[imm32=VarPtr(pRet)]
RDa(4)=&HFF: RDa(5)=&H34:
RDa(6)=&H25: PutMem4 VarPtr(RDa(7)),
VarPtr(pRet)
'ну, теперь, наконец, можно перейти по
интересующему нас адресу
'предварительно записанному нами в
vCallAddress
'jmp dword ptr
ds:[imm32=VarPtr(vCallAddress)]
RDa(11)=&HFF: RDa(12)=&H25:
PutMem4 VarPtr(RDa(13)), VarPtr(vCallAddress)
pRD=VarPtr(RDa(1))
End Sub
А тело функции Test необходимо оформить так,
чтобы у нас внутри неё вычислялось значение pRet и
вместо адреса возврата записывался указатель на
наш переключатель. Тело функции должно выглядеть
следующим образом:
Private Function Test(byval vP1 as Long)as
Long
#If ReleaseBuild Then
'вычисляем адрес начала стека
vESP = VarPtr(vP1) - 4
#Else
'вычисляем адрес начала стека
vESP = VarPtr(vP1) - 8
#End If
'сохраняем адрес возврата в переменной
pRet
CopyMem VarPtr(pRet), vESP, 4
'прописываем в начало стека новый адрес
pRD
PutMem4 vESP, pRD
End Function
И всё! И не нужны никакие CallWindowProc! Всё
работает и под IDE, и в откомпилированном
виде.
Теперь поговорим немного <о Сусанине>.
Если по каким-либо причинам переадресация,
предложенная мною в откомпилированном виде кажется
нежелательной (например, требуется большая
скорость и не хочется терять даже десятка полтора
тактов процессора на приведенный выше вариант,
которые при частом обращении (например, в цикле!)
могут сыграть значительную роль).
Тогда можно
пойти как тем поправленным вариантом предложенным
выше мною, так и авторским. И всё же. Если уж
многократное обращение происходит в цикле (а
<потерянное> время бывает критичным только в
этом случае), тогда можно извратиться несколько
больше, чем предложил автор.
Дело в том, что для обращения к какой-либо
<собственной> функции используется
стандартная инструкция:
call rel32
Если взять авторский вариант, то у нас
получится последовательность вызовов
call rel32=Offset
PlaceholderFor1ParamFunction
jmp rel32=Offset <Вызываемая
функция>
или в поправленном мною выше варианте
call rel32=Offset
PlaceholderFor1ParamFunction
jmp dword ptr
ds:[imm32=VarPtr(vCallAddress)] функция>
Ну, почему бы нам вообще не избавиться от
<лишнего> jmp, коли уж так сильно поджимает
нас время? И избавимся! Да ещё и будем ходить по
условному адресу.
Для этого немного напишем
функцию переключателя
#If ReleaseBuild Then
Private Ra() as Byte
Public Function ReDirect(Optional ByVal vP0 As
Long, Optional ByVal vP1 As
Long) As Long
vESP=VarPtr(vP0)-4
CopyMem VarPtr(pRet), vESP, 4
ReDim Ra(1 to 7)
'call dword
ptr ds:[imm32=VarPtr(vCallAddress]
Ra(1)=&H3E: Ra(2)=&HFF:
Ra(3)=&H15: PutMem
VarPtr(Ra(4)),
VarPtr(vCallAddress)
WriteProcessMemory GetCurProcess, pRet-7,
VarPtr(Ra(1)), 7, 0&
PutMem4 vESP, pRD
End Function
#End If
а обращаться к этой функции будем
vCallAddress=vNewAddress
vReturnValue=ReDirect(,vParamValue)
<концовка> подобного обращения (из любого
места VB-программы!) в маш. кодах выглядит
push imm8=0
call rel32
что занимает семь байт. Но инструкция
call dwrod ptr ds:[imm32]
На самом деле занимает шесть байт. Что делать?
Не вставлять же nop'ы в конце? Ведь это опять
получится дополнительная, хотя и пустая (один
такт) операция процессора. Есть простое решение
указанная выше инструкция по умолчанию адресуется
относительно регистра ds, достаточно приписать
перед этой инструкцией <уточняющий> префикс
&H3E, который будет делать тоже самое, но в
явном виде.
Что в итоге? В итоге имеем те самые семь байт.
Что же на самом деле делает функция ReDirect?
При обращении к этой функции, она вычисляет адрес
возврата уже описанным выше способом. Затем меняет
предшествующие адресу возврата семь байт. Таким
образом, если обращение из этого места происходит
либо в цикле, либо просто часто, то в следующий
раз обращение по нужному адресу (vCallAddress)
будет происходить прямо оттуда!
Кстати говоря,
несмотря на то, что функция ReDirect, вроде бы
имеет два параметра, при повторных обращениях
задержки из-за пустого параметра всё равно не
происходит, так как
push imm8=0
мы затираем при первом обращении.
Есть ещё один не менее изящный, на мой взгляд,
вариант.
#If ReleaseBuild Then
Private REa() as Byte
Public Function REx(ByVal vP0 As Long, ByVal
vP1 As Long) As Long
vESP=VarPtr(vP0)-4
CopyMem VarPtr(pRet), vESP, 4
ReDim REa(1 to 5)
'pop
eax
REa(1)=&H67: REa(2)=&H58
'call
eax
REa(3)=&H67: REa(4)=&HFF:
REa(5)=&HD0
WriteProcessMemory GetCurProcess, pRet-5,
VarPtr(REa(1)), 5, 0&
PutMem4 vESP, pRD
End Function
#End If
В этом случае обращение к функции REx должно
выглядеть следующим образом:
vReturnValue=REx(vCallAddress,vParamValue)
То есть теперь инструкция
call rel32
заменяется инструкциями
pop eax
call eax
Как мы помним инструкция
call rel32
занимает пять байт, в то время, как наша замена
- всего три. Как и выше, <недостающие байты>
мы <добираем> за счёт <уточняющих>
префиксов. В данном случае это префикс &H67.
Его <безболезненно> можно ставить перед
любой из наших инструкций. В итоге получаем
искомые пять байт. Заметьте, что последний вариант
при передаче управления по условному адресу
выполняется максимально быстро. Если же, мы знаем,
что обращение будет происходить на один и тот же
адрес, то максимально быстро будет работать вот
такой вариант
#If ReleaseBuild Then
Public vNewAddress as Long
Private Function GetPA(ByVal vProcAddress as
Long)as Long
GetPA=vProcAddress
End Function
Public Function ReD(ByVal vP1 As Long) As
Long
vESP=VarPtr(vP0)-4
CopyMem VarPtr(pRet), vESP, 4
'до обращения в vNewAddress должен
содержаться <абсолютный> адрес
'после вычисления там будет содержаться
относительный
vNewAddress=pRet-GetPA(AddressOf
ReD)+vNewAddress
WriteProcessMemory GetCurProcess, pRet-4,
VarPtr(vNewAddress), 4, 0&
PutMem4 vESP, pRD
End Function
#End If
Теперь обращение к этой функции обычное.
vNewAddress=<адрес вызываемой
процедуры>
:
vReturnValue=ReD(vParamValue)
А что происходит в функции ReD? Просто в
инструкции
call rel32
перезаписывается само значение rel32.
Вот, собственно говоря, и все замечания. В
прочих случаях, не требующих столь изощрённых
методов оптимизации предлагаю пользоваться
переадресацией альтернативной (если честно, то не
очень-то поворачиваются пальцы на клавиатуре
их сравнивать) CallWindowProc.
Approximator