Внимание! Настоятельно рекомендую ознакомиться с материалом http://rcrrad.com/2009/06/27/tstringgrid-datagrabber/, если Вы озадачены получением данных из этой таблицы 
На этом форуме и на многих других не раз возникал вопрос о том, как получить данные из компонента TStringGrid, созданного в "чужом" процессе. API-функция GetWindowText не дает нужного результата, поскольку текстовые данные таблицы хранятся в памяти обособленно от каких-либо оконных API. Более того, все, что мы можем получить о таблице в "чужом" процессе, это лишь её дескриптор (Handle). Задача подобного рода является достаточно сложной, и стандартного её решения не существует. Хочу предложить Вам одно нестандартное, но эффективное решение.
Задача о получении данных из TStringGrid прямым инжектом
[align=justify]Особенности метода:
1) Используется прямое внедрение в процесс (без DLL) с запуском удаленного потока. Обычно данная техника обнаруживается антивирусами (практика показывает, что для людей, которым нужно получить данные из TStringGrid, это не является проблемой). Если мы откажемся от CreateRemoteThread, то перед нами встанет еще одна проблема - мы не сможем напрямую получить доступ к необходимым данным (которые могли бы передать через параметр CreateRemoteThread). Данная проблема имеет эффективное решение, о котором говорится во второй части статьи.
2) Для обеспечения универсальности в некоторых местах мы не можем использовать код Delphi, только ассемблер. Это связано с тем, что, во-первых, я стремился сделать код как можно более компактным (его можно портировать на WinAPI с минимальными модификациями), а во-вторых, что самое главное, сделать его работоспособным для разных версий Delphi. Код (работоспособность) зависим от версии Delphi, на котором скомпилировано целевое приложение.
Что это значит? Дело в том, что от версии к версии в Delphi вносятся модификации не только в компилятор и IDE, но и в VCL. Стандартные классы расширяются, появляются новые методы и свойства. Используя знания анатомии класса Delphi, можно получить доступ ко многим членам класса без ограничений, но все это возможно только через ассемблер.
Некоторые сведения об устройстве классов в Delphi
В ассемблерном представлении классы почти ничем не отличаются от записей (records). Отличия следующие - каждая такая запись вбирает в себя не только свои собственные поля, но и поля всех предков. Также добавляется поле с адресом таблицы VMT - оно всегда первое по счёту. Рассмотрим пример:
| Код |
type
TMyClass = class(TObject)
private
FField1: Integer;
FField2: Integer;
end;
{ Наследник }
TMyClassEx = class(TMyClass)
public
FField3: Integer;
end;
|
Эквивалентная запись для класса TMyClassEx будет выглядеть следующим образом:
| Код |
TMyClassEx = record
VMT: Pointer;
FField1: Integer;
FField2: Integer;
FField3: Integer;
// В Delphi 2009 появилось поле FMonitor: Pointer;
end;
|
Для доступа к полям Вам будет необходим "указатель на класс". Загрузив его в регистр (скажем, EAX), можно организовать доступ к полям, учитывая порядок их объявления:
[EAX + 0] - первое поле (VMT)
[EAX + 4] - второе поле FField1
[EAX + 8] - третье поле FField2
[EAX + 12] - четвертое поле FField3
Здесь используются непосредственные значения при адресации (hard-coded values). При работе со встроенным ассемблером так делать не рекомендуется, но при работе с классами у нас нет другого выхода.
Как видите, секций private и public больше нет - они имеют только высокоуровневую реализацию. Это касается всех секций класса.
Реализация метода получения данных
Давайте рассмотрим, как можно получить данные из удаленного процесса. У нас есть лишь только дескриптор целевой TStringGrid. Зная его, мы сможем определить PID процесса через функцию GetWindowThreadProcessId. Открыв процесс, мы сможем записать в него функцию (выделив память), и запустить ее на исполнение через создание удаленной нити (будем считать, что процесс разрешает нам выполнять все описанные действия). Нам также понадобятся дополнительные данные (см. ниже), которые можно передать через указатель в параметр функции. Следует учесть, что на момент создания нити данные для параметра уже должны быть подготовлены и размещены в чужом процессе (для этого используется функция VirtualAllocEx).
Что следует размещать в данных? Ну, во-первых, дескриптор TStringGrid, так как он у нас один известный и будет использоваться Далее - все адреса API-функций, которые будут использоваться в "чужом" процессе. Для многих API-функций адреса можно получить непосредственно в нашем процессе, потому что модули ntdll.dll, kernel32.dll и user32.dll для user-mode приложений, в которых используется TStringGrid, загружаются по одинаковым адресам. Все строки, которые будут использоваться для вызовов API, также следует передавать удаленной функции (для удобства через массив символов, если это возможно). Последнее, что нужно передать - это данные, определяющие особенности работы функции. В нашем случае - это смещения 4-х свойств и одного метода StringGrid для получения данных в программах, написаных на разных версиях Delphi. Об этом см. ниже.
Как работает функция DataGrabber
Так называется удаленная функция, которая осуществляет всю работу по получению данных и их передаче. Получить данные - дело одно, а передать - совсем другое. Дело в том, что функция работает не в нашем процессе, но получает там строки, которые нужно передать в наш процесс. TStringGrid может быть очень большим, и для непрерывной передачи данных я выбрал такое средство IPC, как именованные каналы (Named Pipes).
Работает функция в несколько этапов:- Открывает уже созданный нами именованный канал;
- Этап 1 (STAGE_1). Сначала посылаются свойства ColCount, RowCount, FixedCols, FixedRows для копирования внешнего вида "чужой" StringGrid. Как получить эти свойства, зная лишь дескриптор StringGrid? Нужно каким-то образом получить указатель на экземпляр класса "чужой" TStringGrid, а затем работать с ним на ассемблере. Выход есть, и он универсален. В VCL для любого потомка TWinControl вызывается следующая функция при создании:
| Код |
SetProp(FHandle, MakeIntAtom(WindowAtom), THandle(Self));
|
Вот то, что касается WindowAtom:
| Код |
...
WindowAtomString := Format('Delphi%.8X', [GetCurrentProcessID]);
WindowAtom := GlobalAddAtom(PChar(WindowAtomString));
...
|
Получается, что мы можем получить Self, просто прочитав нужное нам свойство. ID "чужого" процесса получить очень легко. Это свойство в сформированном виде передается через данные.
Здесь есть некоторые проблемы. Как я уже говорил, от Delphi к Delphi разработчики иногда меняют код VCL, и это, как Вы понимаете, влияет на то, какие смещения полей следует использовать в данном конкретном случае. Для примера я использовал смещения для версии Delphi 2009 (C++Builder 2009). Если Вам требуется другая версия - рассчитайте сами (можно посмотреть в дизассемблере или в окне CPU). Универсальности здесь особой ждать не следует - адреса могут "плавать" и меняться даже от режима компиляции. Это плата за быстроту метода. http://wmsdk.com/2009/06/27/tstringgrid-datagrabber/ лишен перечисленных выше недостатков, но работает намного медленнее прямого внедрения.
- Этап 2 (STAGE_2). После посылки необходимых свойств мы посылаем текст в цикле, подобном этому:
| Код |
var
I, J: Integer;
S: String;
...
for I := StringGrid.ColCount - 1 downto 0 do
for J := StringGrid.RowCount - 1 downto 0 do
S := StringGrid.Cells[I, J];
...
// Отправка текста
|
Здесь нас подстерегает очередная проблема - дело в том, что свойства классов - это не поля, и прямой доступ из ассемблера к ним невозможен. Решение состоит в ручном вызове "геттера" для данного свойства. Вот он:
| Код |
function TStringGrid.GetCells(ACol, ARow: Integer): string;
var
ssl: TStringSparseList;
begin
ssl := TStringSparseList(TSparseList(FData)[ARow]);
if ssl = nil then Result := '' else Result := ssl[ACol];
end;
|
Допустим, мы знаем его адрес. По соглашению параметр ACol нужно передать в EDX, а параметр ARow - в ECX. EAX должен содержать указатель на экземпляр StringGrid - Self. Мы его уже получили ранее из оконного свойства. Результат будет помещен на стек, мы должны будем обязательно проинициализировать в nil место для результата. Это соглашение по получению результата от функций, возвращающих строки (помещаемых на стек).
На самом деле мы не знаем адреса TStringGrid.GetCells - это private-метод. Но можно рассчитать этот адрес относительно адреса любого другого метода, если таковой известен. В примере я рассчитывал смещение относительно деструктора - его адрес "зашит" в VMT по смещению vmtDestroy (-4). От версии к версии смещение может также меняться. Следует учесть, что деструктор у TStringGrid виртуальный, поэтому подобный приём применим.
- При каждой итерации этапа 2 происходит отправка полученного текста в канал с информацией о том, какой ячейке принадлежит текст (по координатам - счетчикам цикла).
- Когда весь текст отправлен, мы отправляем пакет с информацией о том, что канал можно закрывать, и закрываем его дескриптор через CloseHandle. Принимающая сторона обновляет наш StringGrid.
Проект находится в аттаче. На форме MainForm лежит поле ввода EdHandle для ввода дескриптора "чужой" StringGrid, кнопка BGetData, которая получит данные, заполнив ими нашу StringGrid1
Вот часть кода главного модуля:
</div>
| Код |
type
{ Дефиниции }
TGetProp = function (hWnd: HWND; lpString: PWideChar): THandle; stdcall;
TCreateFile = function (lpFileName: PWideChar; dwDesiredAccess,
dwShareMode: DWORD; lpSecurityAttributes: PSecurityAttributes;
dwCreationDisposition, dwFlagsAndAttributes: DWORD;
hTemplateFile: THandle): THandle; stdcall;
TWriteFile = function (hFile: THandle; const Buffer;
nNumberOfBytesToWrite: DWORD; var lpNumberOfBytesWritten: DWORD;
lpOverlapped: POverlapped): BOOL; stdcall;
TRtlZeroMemory = procedure (Destination: Pointer; Length: DWORD); stdcall;
TCopyString = function (lpString1, lpString2: PWideChar;
iMaxLength: Integer): PWideChar; stdcall;
TCloseHandle = function (hObject: THandle): BOOL; stdcall;
{ Удаленные данные }
PInjectData = ^TInjectData;
TInjectData = packed record
{ Закрытие объекта }
FCloseHandle: TCloseHandle;
{ Работа с памятью на API }
FZeroMemory: TRtlZeroMemory;
{ Копирование строки }
FCopyString: TCopyString;
{ Получение свойства окна }
FGetProp: TGetProp;
{ Для подключения к каналу }
FCreateFile: TCreateFile;
{ Для записи в канал }
FWriteFile: TWriteFile;
{ Окно TStringGrid в "чужом" процессе }
FGridWnd: HWND;
{ Нужное свойство окна }
FProperty: array[0..14] of WideChar;
{ Имя канала - PIPE_NAME }
FPipeName: array[0..23] of WideChar;
{ Смещения }
FColOffset: Integer;
FRowOffset: Integer;
FFixedRowOffset: Integer;
FFixedColOffset: Integer;
FGetCellsOffset: Integer;
end;
const
{ Максимальная длина строки }
BUF_SIZE = 1024;
type
{ Для Pipe }
PPipeDataStruct = ^TPipeDataStruct;
TPipeDataStruct = packed record
{ Текущий этап }
FStage: Byte;
{ Флаг конца передачи данных }
FTerminate: Boolean;
{ Число фиксированных колонок }
FFixedCols: Integer;
{ Число фиксированных столбцов }
FFixedRows: Integer;
{ Число колонок }
FColCount: Integer;
{ Число рядов }
FRowCount: Integer;
{ Текущая колонка }
FColPos: Integer;
{ Текущий ряд }
FRowPos: Integer;
{ Данные }
FString: array [1..BUF_SIZE] of WideChar;
end;
TPipeThread = class(TThread)
private
{ Переданные данные }
FColCount, FRowCount: Integer;
FFixedCols, FFixedRows: Integer;
{ Ячейки }
FCells: array of array of WideString;
FPipe: THandle;
Data: TPipeDataStruct;
protected
procedure Execute; override;
public
{ Обновление TStringGrid - после приема всех данных }
procedure Update;
end;
const
InjectSize = SizeOf(TInjectData);
PipeDataSize = SizeOf(TPipeDataStruct);
{ Этапы передачи данных }
STAGE_1 = $00000001; // Передача числа строк и столбцов
STAGE_2 = $00000002; // Передача текстовых данных
{ Имя канала в формате UNC }
PIPE_NAME = '\\.\PIPE\StringGridPipe';
var
MainForm: TMainForm;
{ Для определения конца инициализации }
FEvent: THandle = 0;
implementation
{$R *.dfm}
{ Функция, которая будет передавать данные из "чужого" процесса }
{ На входе получает локально заполненные данные }
procedure DataGrabber(Data: PInjectData); stdcall;
var
SendData: TPipeDataStruct;
BytesWritten: DWORD;
{ Адрес TStringGrid.GetCells(EDX, ECX); }
MethodAddress: Pointer;
{ GetCells возвращет результат на стек в эту переменную }
S: PWideChar;
{ StringGrid Self }
Prop: DWORD;
asm
PUSH ESI
PUSH EDI
PUSH EBX
PUSH 0 { hTemplateFile }
PUSH 0 { dwFlagsAndAttributes }
PUSH OPEN_EXISTING { dwCreationDisposition }
PUSH 0 { lpSecurityAttributes }
MOV EDX, FILE_SHARE_READ
OR EDX, FILE_SHARE_WRITE
PUSH EDX { dwShareMode }
PUSH GENERIC_WRITE { dwDesiredAccess }
MOV EBX, [Data]
LEA EDX, (TInjectData)[EBX].FPipeName
PUSH EDX { lpFileName }
CALL (TInjectData)[EBX].FCreateFile { CreateFile }
CMP EAX, INVALID_HANDLE_VALUE { EAX - Result }
JZ @@Quit
MOV ESI, EAX { ESI <= Pipe Handle }
PUSH 0 { lpOverlapped }
MOV BytesWritten, 0
LEA EDX, BytesWritten
PUSH EDX { lpNumberOfBytesWritten }
MOV EDX, PipeDataSize
PUSH EDX { nNumberOfBytesToWrite }
{ Подготовка данных - этап 1 }
MOV SendData.FTerminate, False
MOV SendData.FStage, STAGE_1
{ Получение экземпляра класса TStringGrid }
LEA EDX, (TInjectData)[EBX].FProperty
PUSH EDX { lpString }
PUSH (TInjectData)[EBX].FGridWnd { hWnd }
CALL (TInjectData)[EBX].FGetProp { GetProp }
MOV ECX, EAX
MOV Prop, ECX
{ Получение необходимых свойств TStringGrid }
MOV EDX, (TInjectData)[EBX].FColOffset
MOV EAX, [EAX + EDX]
MOV SendData.FColCount, EAX
MOV EDX, (TInjectData)[EBX].FRowOffset
MOV EAX, [ECX + EDX]
MOV SendData.FRowCount, EAX
MOV EDX, (TInjectData)[EBX].FFixedColOffset
MOV EAX, [ECX + EDX]
MOV SendData.FFixedCols, EAX
MOV EDX, (TInjectData)[EBX].FFixedRowOffset
MOV EAX, [ECX + EDX]
MOV SendData.FFixedRows, EAX
{ Расчёт адреса GetCells (ECX = Self) }
MOV ECX, [ECX] { ECX <= VMT }
MOV ECX, [ECX - 4]
ADD ECX, (TInjectData)[EBX].FGetCellsOffset
MOV MethodAddress, ECX { MethodAddress = GetCells }
LEA EDX, SendData
PUSH EDX { Buffer }
PUSH ESI { hFile }
CALL (TInjectData)[EBX].FWriteFile { WriteFile }
{ Пересылка текста - этап 2 }
MOV SendData.FStage, STAGE_2
{ Установка счетчиков EDI и EBX }
MOV EDI, SendData.FColCount
DEC EDI
{ Цикл 1 }
@@Cycle1:
{ Восстанавливаем второй счётчик }
MOV EBX, SendData.FRowCount
DEC EBX
{ Цикл 2 - получение и отправка данных }
@@Cycle2:
{ Очищаем поле FString }
PUSH BUF_SIZE { Length }
MOV ECX, [Data]
LEA EAX, SendData.FString { Buffer }
PUSH EAX
CALL (TInjectData)[ECX].FZeroMemory { RtlZeroMemory }
{ Заполняем позицию текущей ячейки }
MOV SendData.FColPos, EDI
MOV SendData.FRowPos, EBX
{ Получаем текст }
MOV EDX, EDI { ACol }
MOV ECX, EBX { ARow }
{ Инициализация обязательна }
MOV S, 0 { S := nil }
LEA EAX, S
PUSH EAX { Push @S }
MOV EAX, Prop { EAX <= Self }
CALL MethodAddress { GetCells }
{ Копируем текст }
MOV EAX, [Data]
PUSH BUF_SIZE { iMaxSize }
PUSH S { Source }
LEA EDX, SendData.FString
PUSH EDX { Destination }
CALL (TInjectData)[EAX].FCopyString { lstrcpyn }
{ Отправляем текст }
MOV EAX, [Data]
PUSH 0 { lpOverlapped }
LEA EDX, BytesWritten
PUSH EDX { lpNumberOfBytesWritten }
MOV EDX, PipeDataSize
PUSH EDX { nNumberOfBytesToWrite }
LEA EDX, SendData
PUSH EDX { Buffer }
PUSH ESI { hFile }
CALL (TInjectData)[EAX].FWriteFile { WriteFile }
DEC EBX
JNS @@Cycle2
DEC EDI
JNS @@Cycle1
{ Сообщаем о завершении работы }
MOV SendData.FTerminate, True
PUSH 0 { lpOverlapped }
MOV BytesWritten, 0
LEA EDX, BytesWritten
PUSH EDX { lpNumberOfBytesWritten }
MOV EDX, PipeDataSize
PUSH EDX { nNumberOfBytesToWrite }
LEA EDX, SendData
PUSH EDX { Buffer }
PUSH ESI { hFile }
MOV EBX, [Data]
CALL (TInjectData)[EBX].FWriteFile { WriteFile }
{ Закрываем канал }
PUSH ESI { hObject }
CALL (TInjectData)[EBX].FCloseHandle { CloseHandle }
POP EBX
POP EDI
POP ESI
@@Quit: { Exit }
end;
{ Получаем данные, заполняя ими нашу таблицу через Pipe }
procedure GetRemoteStringGridData(Wnd: HWND);
var
FPID: DWORD;
hUser32, hKernel32, hNtDll, hProcess, hThread: THandle;
LocalData: TInjectData;
RemoteData, RemoteDataGrabberFunc: Pointer;
dwPageSize: DWORD;
SystemInfo: TSystemInfo;
begin
GetSystemInfo(SystemInfo);
dwPageSize := SystemInfo.dwPageSize;
hNtDll := GetModuleHandle('ntdll.dll');
hUser32 := GetModuleHandle('user32.dll');
hKernel32 := GetModuleHandle('kernel32.dll');
if (hNtDll <> 0) and (hUser32 <> 0) and (hKernel32 <> 0) then
begin
GetWindowThreadProcessId(Wnd, @FPID);
if FPID = 0 then
Exit;
hProcess := OpenProcess(PROCESS_CREATE_THREAD or PROCESS_QUERY_INFORMATION
or PROCESS_VM_OPERATION or PROCESS_VM_WRITE or PROCESS_VM_READ,
False, FPID);
if hProcess <> 0 then
try
RemoteData := VirtualAllocEx(hProcess, nil, dwPageSize,
MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if Assigned(RemoteData) then
try
{ Рассчитываем адрес, по которому запишем функцию }
RemoteDataGrabberFunc := RemoteData;
Inc(PByte(RemoteDataGrabberFunc), InjectSize);
{ Записываем функцию }
if WriteProcessMemory(hProcess, RemoteDataGrabberFunc,
@DataGrabber, dwPageSize - InjectSize, PDWORD(nil)^) then
begin
{ Заполняем локальные данные}
with LocalData do
begin
@FGetProp := GetProcAddress(hUser32, 'GetPropW');
@FCreateFile := GetProcAddress(hKernel32, 'CreateFileW');
@FWriteFile := GetProcAddress(hKernel32, 'WriteFile');
@FZeroMemory := GetProcAddress(hNtDll, 'RtlZeroMemory');
@FCopyString := GetProcAddress(hKernel32, 'lstrcpynW');
@FCloseHandle := GetProcAddress(hKernel32, 'CloseHandle');
{ StringGrid Handle }
FGridWnd := Wnd;
StringToWideChar(Format('Delphi%.8X', [FPID]), FProperty,
SizeOf(FProperty));
lstrcpyW(FPipeName, PIPE_NAME);
{ Смещения Delphi/C++ Builder 2009 }
FColOffset := $274;
FRowOffset := $29C;
FFixedRowOffset := $28C;
FFixedColOffset := $288;
FGetCellsOffset := $484;
end;
{ Копируем данные в "чужой" процесс }
if WriteProcessMemory(hProcess, RemoteData, @LocalData,
SizeOf(TInjectData), PDWORD(nil)^) then
begin
{ Создание события в занятом состоянии }
FEvent := CreateEvent(nil, True, False, nil);
if FEvent <> 0 then
try
{ Создание канала }
with TPipeThread.Create(False) do
begin
FreeOnTerminate := True;
{ Ждем конца инициализации }
WaitForSingleObject(FEvent, INFINITE);
end;
finally
CloseHandle(FEvent);
end;
{ Запуск удаленного кода на исполнение }
hThread := CreateRemoteThread(hProcess, nil, 0,
RemoteDataGrabberFunc, RemoteData, 0, PDWORD(nil)^);
if hThread <> 0 then
try
WaitForSingleObject(hThread, INFINITE);
finally
CloseHandle(hThread);
end;
end;
end;
finally
VirtualFreeEx(hProcess, RemoteData, 0, MEM_RELEASE);
end;
finally
CloseHandle(hProcess);
end;
end;
end;
end.
|
|
