Здравствуйт.У меня есть устройство с WinCE 6.0(MIPSII) и приложение Х, которое работает с портами. Хочу снять лог, что приложение считывает с портов и что пишет в них. А потом динамически преобразовывать информацию в нужную. Хочу сделать таким способом подсоединиться к процессу, добавить свою ДЛЛ в которой бууду перехватывать API CreateFileW, ReadFile и WriteFile и с помощью переопределения этих функци буду писать лог... У меня есть ряд вопросов. Всем заранее спасибо.Пишу в VS2008 C++.
1. Как создать ДЛЛ? Имею в виду какой проект создавать (MFC, ATL... )?
2. Как и где перехватывать API CreateFileW, ReadFile и WriteFile, чтобы подложить свои функции? Прочитал кучу всякой полезной информации...
3. Выдаёт ошибку вот на этот кусок кода, как победить?

typedef std::map<HANDLE, CStringA> Files;
Files files;

Здравствуйте, urban1981, Вы писали:

U>Здравствуйт.У меня есть устройство с WinCE 6.0(MIPSII) и приложение Х, которое работает с портами. Хочу снять лог, что приложение считывает с портов и что пишет в них. А потом динамически преобразовывать информацию в нужную. Хочу сделать таким способом подсоединиться к процессу, добавить свою ДЛЛ в которой бууду перехватывать API CreateFileW, ReadFile и WriteFile и с помощью переопределения этих функци буду писать лог... У меня есть ряд вопросов. Всем заранее спасибо.Пишу в VS2008 C++.
U>1. Как создать ДЛЛ? Имею в виду какой проект создавать (MFC, ATL... )?
U>2. Как и где перехватывать API CreateFileW, ReadFile и WriteFile, чтобы подложить свои функции? Прочитал кучу всякой полезной информации...
U>3. Выдаёт ошибку вот на этот кусок кода, как победить?
U>

U>typedef std::map<HANDLE, CStringA> Files;
U>Files files;
U>

1. да в принципе какой хотите, хоть Empty project
2. http://habrahabr.ru/post/90377/
3. Какую ошибку? #include <map> есть?

Здравствуйте, SаNNy. Выдаёт много ошибок — 16 вот первая :

error LNK2001: неразрешенный внешний символ ""const type_info::`vftable'" (??_7type_info@@6B@)"

это всё из за этого куска и из за использовании его в дальнейшем в функциях куклах:

typedef std::map<HANDLE, CStringA> Files;
Files files;




HANDLE __stdcall APIHook_CreateFileW( 
    LPWSTR lpFileName,
    unsigned long int dwDesiredAccess,
    unsigned long int dwShareMode,
    LPSECURITY_ATTRIBUTES lpsa,
    unsigned long int dwCreationDisposition,
    unsigned long int dwFlagsAndAttributes,
    LPVOID hTemplateFile)
{
    HANDLE hFile = CreateFileW (
        lpFileName,
        dwDesiredAccess,
        dwShareMode,
        lpsa,
        dwCreationDisposition,
        dwFlagsAndAttributes,
        hTemplateFile);


        if(hFile != INVALID_HANDLE_VALUE && wcsstr(lpFileName, L"COM") == lpFileName)
        {
                files[hFile] = lpFileName;
                logger.write(files[hFile], "CreateFileW");
        }
    return hFile;
}




BOOL __stdcall APIHook_ReadFile( 
    LPVOID hFile,
    LPVOID lpBuffer,
    unsigned long int nNumberOfBytesToRead,
    unsigned long int * lpNumberOfBytesRead,
    LPOVERLAPPED lpOverlapped)
{
    BOOL result = ReadFile (
        hFile,
        lpBuffer,
        nNumberOfBytesToRead,
        lpNumberOfBytesRead,
        lpOverlapped);


        Files::iterator it = files.find(hFile);
        if(result == TRUE && it != files.end())
        {
                logger.write(it->second, "ReadFile", lpBuffer, *lpNumberOfBytesRead);
        }
    return result;
}




BOOL __stdcall APIHook_WriteFile( 
    LPVOID hFile,
    LPVOID lpBuffer,
    unsigned long int nNumberOfBytesToWrite,
    unsigned long int * lpNumberOfBytesWritten,
    LPOVERLAPPED lpOverlapped)
{
    BOOL result = WriteFile (
        hFile,
        lpBuffer,
        nNumberOfBytesToWrite,
        lpNumberOfBytesWritten,
        lpOverlapped);


        Files::iterator it = files.find(hFile);
        if(it != files.end())
        {
                logger.write(it->second, result == TRUE ? "WriteFile OK" : "WriteFile ERROR", lpBuffer, nNumberOfBytesToWrite);
        }
    return result;
}

Здравствуйте, urban1981, Вы писали:

U>Здравствуйте, SаNNy. Выдаёт много ошибок — 16 вот первая :
U>

U>error LNK2001: неразрешенный внешний символ ""const type_info::`vftable'" (??_7type_info@@6B@)"
U>

Похоже на это http://support.microsoft.com/kb/191663/en-us?wa=wsignin1.0

Здравствуйте, SаNNy, Вы писали:
SNN>2. http://habrahabr.ru/post/90377/
Да читаю вновь и вновь эту статью но там ничего про WinCe...буду проникаться ей дальше

Здравствуйте, SаNNy, Вы писали:

SNN>Здравствуйте, urban1981, Вы писали:

U>Хочу сделать таким способом подсоединиться к процессу, добавить свою ДЛЛ в которой бууду перехватывать API CreateFileW, ReadFile и WriteFile и с помощью переопределения этих функци буду писать лог... У меня есть ряд вопросов. Всем заранее спасибо.Пишу в VS2008 C++.
U>>1. Как создать ДЛЛ? Имею в виду какой проект создавать (MFC, ATL... )?
U>>2. Как и где перехватывать API CreateFileW, ReadFile и WriteFile, чтобы подложить свои функции? Прочитал кучу всякой полезной информации...

SNN>2. http://habrahabr.ru/post/90377/

У товарища же WinCE на MIPSе, и значит, описанное на хабре, тут, и еще в массе мест в интернете не подойдет чуть менее, чем совсем.

PS MS Detours интересно, есть для MIPS? Глянул по верхам, вроде нету

PPS Microsoft Research Detours v3 Professional &mdash; 325 000,00 руб

Огого. Писал в свое время аналог Detours, тут на форуме сказали, что я зря это делал, раз есть Detours, а тут вот оно как выходит. Оформить что ли, да начать продавать?

У>Огого. Писал в свое время аналог Detours, тут на форуме сказали, что я зря это делал, раз есть Detours, а тут вот оно как выходит. Оформить что ли, да начать продавать?
Детурс хорош тем что сама микрософт будет по возможности поддерживать с ним совместимость, поскольку сама им пользуется. Ваш аналог врядли этим сможет похвастаться.
ЗЫ Я тоже писал аналоги детурса

Здравствуйте, ononim, Вы писали:

У>>Огого. Писал в свое время аналог Detours, тут на форуме сказали, что я зря это делал, раз есть Detours, а тут вот оно как выходит. Оформить что ли, да начать продавать?
O>Детурс хорош тем что сама микрософт будет по возможности поддерживать с ним совместимость, поскольку сама им пользуется. Ваш аналог врядли этим сможет похвастаться.
O>ЗЫ Я тоже писал аналоги детурса

Ну, я думаю, что вполне совместимо получилось. Лет семь уже работает, пока никто не жаловался
МС не будет думаю ничего кардинально менять, чтобы не поломать детурс, а значит, что и мое будет работать. схема думаю одна и та же )

Здравствуйте, утпутуук.
По моей задаче есть вот чего :
[url=http://progandhack.blogspot.ru/2011/08/shim-dll-com.html][/url]
Это тоже полезная инфа...
PC Помню в дедстве ребята завидовали тем кто может делать велосипед...

Счастливая библиотека для тех кому интерсно пока компилирую только не запускаю:

// Dll777.cpp: определяет точку входа для приложения DLL.
//
#undef UNICODE
//#include "stdafx.h"
#include <windows.h>
//#include <map>
//#include <atlbase.h>
//#include <atlstr.h>
#include "Logger.h"
#include <Tlhelp32.h>
#include "DeepIATHook.h"
//#include <cstdio>

//typedef std::map<HANDLE, CStringA> Files;
//Files files; 

#pragma comment ( lib , "toolhelp.lib" )

#ifdef UNDER_NT
#      include <tchar.h>
#endif

typedef struct _CALLBACKINFO 
{
    HANDLE  hProc;      //Процесс назначения
    FARPROC pfn;        //функция, которая вызывается в процессе назначения
    PVOID   pvArg0;     //arg0 data
} 
CALLBACKINFO;

typedef CALLBACKINFO *PCALLBACKINFO;

extern "C" 
{
    BOOL SetKMode ( BOOL fMode );
    DWORD SetProcPermissions ( DWORD );
    LPVOID MapPtrToProcess ( LPVOID lpv, HANDLE hProc );
    DWORD PerformCallBack4 ( PCALLBACKINFO pcbi, ... );//Выполнить функцию внутри процесса    
    HLOCAL LocalAllocInProcess ( DWORD, DWORD, HPROCESS );
    VOID LocalFreeInProcess ( HLOCAL, HPROCESS );
}

#define SIZE 6 //Number of bytes needed to redirect

typedef int (WINAPI* MESSAGEBOXW)( HWND, LPCWSTR, LPCWSTR, UINT);
typedef HANDLE (WINAPI* CREATEFILEW) ( LPWSTR , unsigned long int , unsigned long int , LPSECURITY_ATTRIBUTES , unsigned long int , unsigned long int , LPVOID );
typedef BOOL (WINAPI* READFILE) ( LPVOID  , LPVOID  , unsigned long int  , unsigned long int *  , LPOVERLAPPED );
typedef BOOL (WINAPI* WRITEFILE) ( LPVOID  , LPVOID  , unsigned long int  , unsigned long int *  , LPOVERLAPPED  ); 

MESSAGEBOXW g_pfnOldMessageBoxW = NULL;
CREATEFILEW g_pfnOldCreateFileW = NULL;
READFILE g_pfnOldReadFile = NULL;
WRITEFILE g_pfnOldWriteFile = NULL;

//typedef HANDLE ( WINAPI *pCreateFileW )( LPWSTR lpFileName, unsigned long int dwDesiredAccess, unsigned long int dwShareMode, LPSECURITY_ATTRIBUTES lpsa, unsigned long int dwCreationDisposition, unsigned long int dwFlagsAndAttributes, LPVOID hTemplateFile );
//typedef BOOL ( WINAPI *pReadFile ) ( LPVOID hFile, LPVOID lpBuffer, unsigned long int nNumberOfBytesToRead, unsigned long int * lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped );
//typedef BOOL ( WINAPI *pWriteFile ) ( LPVOID hFile, LPVOID lpBuffer, unsigned long int nNumberOfBytesToWrite, unsigned long int * lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped ); 

int WINAPI MyMessageBoxW(
                         HWND hWnd, 
                         LPCWSTR lpText, 
                         LPCWSTR lpCaption, 
                         UINT uType
                         );


HANDLE __stdcall MyCreateFileW( 
                                     LPWSTR lpFileName, 
                                     unsigned long int dwDesiredAccess, 
                                     unsigned long int dwShareMode, 
                                     LPSECURITY_ATTRIBUTES lpsa, 
                                     unsigned long int dwCreationDisposition, 
                                     unsigned long int dwFlagsAndAttributes, 
                                     LPVOID hTemplateFile 
                                     );

BOOL __stdcall MyReadFile ( 
                                 LPVOID hFile, 
                                 LPVOID lpBuffer, 
                                 unsigned long int nNumberOfBytesToRead, 
                                 unsigned long int * lpNumberOfBytesRead, 
                                 LPOVERLAPPED lpOverlapped 
                                 );

BOOL __stdcall MyWriteFile ( 
                                  LPVOID hFile, 
                                  LPVOID lpBuffer, 
                                  unsigned long int nNumberOfBytesToWrite, 
                                  unsigned long int * lpNumberOfBytesWritten, 
                                  LPOVERLAPPED lpOverlapped 
                                  );


HWND x;
BOOL APIENTRY DllMain ( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved )
{
    switch ( ul_reason_for_call )
    {
        case DLL_PROCESS_ATTACH:

            g_pfnOldMessageBoxW = (MESSAGEBOXW)DeepHookImportedFunction(L"coredll.dll", L"MessageBoxW", (PROC)MyMessageBoxW, NULL);
            MessageBoxW  (x, L"XXX", L"XXX", MB_OK);
            DeepHookImportedFunction(L"coredll.dll", L"MessageBoxW", (PROC)g_pfnOldMessageBoxW, NULL);            

            g_pfnOldCreateFileW = (CREATEFILEW)DeepHookImportedFunction(L"coredll.dll", L"CreateFileW", (PROC)MyCreateFileW, NULL);
            g_pfnOldReadFile = (READFILE)DeepHookImportedFunction(L"coredll.dll", L"ReadFile", (PROC)MyReadFile, NULL);
            g_pfnOldWriteFile = (WRITEFILE)DeepHookImportedFunction(L"coredll.dll", L"WriteFile", (PROC)MyWriteFile, NULL);

            break;
        case DLL_PROCESS_DETACH:
                DeepHookImportedFunction(L"coredll.dll", L"CreateFileW", (PROC)g_pfnOldCreateFileW, NULL);
                DeepHookImportedFunction(L"coredll.dll", L"ReadFile", (PROC)g_pfnOldReadFile, NULL);
                DeepHookImportedFunction(L"coredll.dll", L"WriteFile", (PROC)g_pfnOldWriteFile, NULL);
            break;
        case DLL_THREAD_ATTACH:
            break;
        case DLL_THREAD_DETACH:
            break;
        default:
            return FALSE;
        break;
    }
    return TRUE;
}

int WINAPI MyMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType)
{
    return g_pfnOldMessageBoxW(hWnd, L"!!!", L"!!!", uType);
}

HANDLE __stdcall MyCreateFileW( LPWSTR lpFileName, unsigned long int dwDesiredAccess, unsigned long int dwShareMode, LPSECURITY_ATTRIBUTES lpsa, unsigned long int dwCreationDisposition, unsigned long int dwFlagsAndAttributes, LPVOID hTemplateFile )
{
    HANDLE hFile = CreateFileW ( lpFileName, dwDesiredAccess, dwShareMode, lpsa, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
    if ( hFile != INVALID_HANDLE_VALUE && wcsstr ( lpFileName, L"COM" ) == lpFileName )
    {
        //files[hFile] = lpFileName;
        //logger.write(files[hFile], "CreateFileW");
        logger.write (  lpFileName , "CreateFileW" );
    }
    return g_pfnOldCreateFileW ( lpFileName, dwDesiredAccess, dwShareMode, lpsa, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
    //return hFile;
}

BOOL __stdcall MyReadFile ( LPVOID hFile, LPVOID lpBuffer, unsigned long int nNumberOfBytesToRead, unsigned long int * lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped )
{
    BOOL result = ReadFile ( hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped );         
    //Files::iterator it = files.find(hFile);
    //if(result == TRUE && it != files.end())
    if ( result == TRUE )
    {
        //logger.write(it->second, "ReadFile", lpBuffer, *lpNumberOfBytesRead);
        logger.write ( ( LPWSTR ) hFile , "ReadFile", lpBuffer, *lpNumberOfBytesRead );
    }
    return g_pfnOldReadFile ( hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped );
    //return result;
}

BOOL __stdcall MyWriteFile ( LPVOID hFile, LPVOID lpBuffer, unsigned long int nNumberOfBytesToWrite, unsigned long int * lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped )
{
    BOOL result = WriteFile ( hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped );
    //Files::iterator it = files.find( hFile);
    //if(it != files.end())
    {
        //logger.write(it->second, result == TRUE ? "WriteFile OK" : "WriteFile ERROR", lpBuffer, nNumberOfBytesToWrite);
        logger.write( ( LPWSTR ) hFile , result == TRUE ? "WriteFile OK" : "WriteFile ERROR", lpBuffer, nNumberOfBytesToWrite);
    }
    return g_pfnOldWriteFile ( hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped );
    //return result;
}

Логер:

#include "stdafx.h"
#include "Logger.h"




#ifndef min
#       define min(a,b) (((a) < (b)) ? (a) : (b))
#endif




Logger logger;
const char* logFilename = "\\com_log.txt";
//const char* logFilename = "\\Storage Card\\com_log.txt";




Logger::Logger()
: file(NULL)
{
        init();
}


Logger::~Logger()
{
        close();
}


bool Logger::init()
{
        return true;
}


void Logger::close()
{
}


//void Logger::write(LPCSTR filename, LPCSTR func)
void Logger::write(LPWSTR filename, LPCSTR func)
{
        SYSTEMTIME st;
        GetSystemTime(&st);
        FILE* file = fopen(logFilename, "a");
        fprintf(file, "\n%.2d:%.2d.%.2d  %s (%s)\n", st.wMinute, st.wSecond, st.wMilliseconds, func, filename);
        fclose(file);
}


//void Logger::write(LPCSTR filename, LPCSTR func, LPVOID data, DWORD size)
void Logger::write(LPWSTR filename, LPCSTR func, LPVOID data, DWORD size)
{
    if(size)
        {
                SYSTEMTIME st;
                GetSystemTime(&st);
                FILE* file = fopen(logFilename, "a");
                fprintf(file, "\n%.2d:%.2d.%.2d  %s (%s) size=%i\n", st.wMinute, st.wSecond, st.wMilliseconds, func, filename, size);
                for(DWORD i=0; i<size;)
                {
                        char hex[49];
                        char str[17];
                        DWORD len = min(size - i, 16);
                        for(DWORD j=0; j<len; ++j, ++i)
                        {
                                BYTE ch = ((LPBYTE)data)[i];
                                sprintf(&hex[j*3], "%.2X ", ch);
                                str[j] = ch > 0x20 && ch < 0x80 ? ch : '.';
                        }
                        str[len] = '\0';
                        fprintf(file, "\t%-48s\t%s\n", hex, str);
                }
                fclose(file);
        }
}

H:

#pragma once
#include <windows.h>




class Logger
{
public:
        Logger();
        ~Logger();


        bool init();
        void close();
        //void write(LPCSTR filename, LPCSTR func);
        //void write(LPCSTR filename, LPCSTR func, LPVOID data, DWORD size);
        void write(LPWSTR filename, LPCSTR func);
        void write(LPWSTR filename, LPCSTR func, LPVOID data, DWORD size);


private:
        FILE* file;
};


extern Logger logger;

Здравствуйте. Всем кто в теме нашёл один сайт с готовым кодом но пояснениями на кмтайском покурю код переведу выложу...

Здравствуйте, urban1981, Вы писали:

U>Здравствуйте. Всем кто в теме нашёл один сайт с готовым кодом но пояснениями на кмтайском покурю код переведу выложу...

Давай, будем ждать. Пригодится.

Здравствуйте, утпутуук, Вы писали:
У>Давай, будем ждать. Пригодится.
Пока всё на стадии компиляции на устройстве не тестил пока выкладываю остальной код файловDeepIATHook.h, DeepIATHook.cpp кроме undoc.h И сразу вопрос к форумчанам у меня есть undoc.h но он для ARM а как и где его взять для MIPS есть некоторые домыслы но буду рад выслушать советы:

#ifdef __cplusplus
extern "C"
{
#endif

// Returns: Original address of intercepted function (for chaining on)
PROC WINAPI DeepHookImportedFunction(    LPCWSTR        pwszModuleToHook,    // Module to intercept calls to
                                        LPCWSTR        pwszFunctionToHook,    // Function to intercept calls to
                                        PROC        pfnNewProc,            // New function (replaces old function)
                                        LPWSTR*        ppwszExcludeList    // List of module names to exclude from the hook
                                    );

#ifdef __cplusplus
};
#endif

#include "stdafx.h"
#include "undoc.h"
#include "DeepIATHook.h"


// Macro for adding pointers/DWORDs together without C arithmetic interfering
#define MakePtr( cast, ptr, addValue ) (cast)( (DWORD)(ptr)+(DWORD)(addValue))

BOOL HookImportTable(PIMAGE_THUNK_DATA pThunk, PROC pfnOriginalProc, PROC pfnNewProc)
{
    // iterate through imported functions
    while ( pThunk->u1.Function )
    {
        // check against GetProcAddress pointer
        if( pThunk->u1.Function == (PDWORD)pfnOriginalProc )
        {
            // found it, hook the function
            pThunk->u1.Function = (PDWORD)pfnNewProc;
            return (TRUE);
        }
        
        // next pointer
        pThunk++;
    }
    return (FALSE);
}

PIMAGE_IMPORT_DESCRIPTOR GetImportDesc(LPCWSTR pwszModuleToHook, LPVOID BasePtr, DWORD rva)
{
    // We know have a valid pointer to the module's PE header.  Now go
    // get a pointer to its imports section

    PIMAGE_IMPORT_DESCRIPTOR pImportDesc = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, BasePtr, rva);
    
    // Iterate through the array of imported module descriptors, looking
    // for the module whose name matches the pwszModuleToHook parameter
    while ( pImportDesc->Name )
    {
        TCHAR wszMainExclude[1024];
        char* pszModName = MakePtr(char*, BasePtr, pImportDesc->Name);
        MultiByteToWideChar(CP_ACP, 0, pszModName, -1, wszMainExclude, 1024);
        
        // found the import descriptor we are looking for?
        if( wcsicmp(wszMainExclude, pwszModuleToHook) == 0 )
            break;
        
        pImportDesc++;  // Advance to next imported module descriptor
    }
    
    // end of list == Import Descriptor not found :(
    if( pImportDesc->Name == 0 )
        return (NULL);
    
    return (pImportDesc);
}


LPDWORD GetProcAddress(LPVOID BasePtr, DWORD rva, LPCWSTR lpProcName)
{
    
    PIMAGE_EXPORT_DIRECTORY pExportDir = MakePtr(PIMAGE_EXPORT_DIRECTORY, BasePtr, rva);

    LPDWORD pdwAddressRVATable    = MakePtr(LPDWORD, BasePtr, pExportDir->AddressOfFunctions);
    LPWORD pwOrdinalTable        = MakePtr(LPWORD, BasePtr, pExportDir->AddressOfNameOrdinals);
    LPDWORD pdwNameRVATable        = MakePtr(LPDWORD, BasePtr, pExportDir->AddressOfNames);
    
    
    for(DWORD i = 0; i < pExportDir->NumberOfFunctions; i++) 
    {
        if( pdwNameRVATable[i] == NULL )
            continue;

        // ЗБ·ОЅГАъ АМё§
        char* pszModName = MakePtr(char*, BasePtr, pdwNameRVATable[i]);

        // ЗБ·ОЅГАъ ј­јц
        WORD wOrdinal = pwOrdinalTable[i] + (WORD)pExportDir->Base;

        // ЗБ·ОЅГАъАЗ ЖчАОЕНё¦ АъАеЗП°н АЦґВ БЦјТ
        LPDWORD pdwAddress = pdwAddressRVATable + pwOrdinalTable[i];

        // ЗБ·ОЅГАъ АМё§ єс±і
        TCHAR wszMainExclude[1024];
        MultiByteToWideChar(CP_ACP, 0, pszModName, -1, wszMainExclude, 1024);
        if( wcsicmp(wszMainExclude, lpProcName) == 0 )
        {        
            return pdwAddress;
        }
    }
    return NULL;
}
// JCW_+ 2008.07.18 END

PROC WINAPI DeepHookImportedFunction(    LPCWSTR        pwszModuleToHook,        // Module to intercept calls to
                                        LPCWSTR        pwszFunctionToHook,        // Function to intercept calls to
                                        PROC        pfnNewProc,                // New function (replaces old function)
                                        LPWSTR*        ppwszExcludeList        // List of module names to exclude from the hook
                                     )
{
    PROC pfnOriginalProc;
    PIMAGE_IMPORT_DESCRIPTOR pImportDesc;
    PIMAGE_THUNK_DATA pThunk;
    PPROCESS pProcess;
    struct info inf;
    PMODULE pmods;
    LPVOID baseptr;
    BOOL bHooked = FALSE;
    HMODULE hModule = NULL;
    HMODULE hCore = GetModuleHandle(L"coredll.dll");

#if 1
    SETKMODE pfnSetKMode = (SETKMODE)GetProcAddress(hCore, L"SetKMode");
    pfnSetKMode(TRUE);
#else
    SetKMode(TRUE);
#endif

    // Get current process struct from KData
    pProcess = KData.pCurPrc;
    
    // Get process import descriptor
    inf = pProcess->e32.e32_unit[IMP];
    
    if( IsBadCodePtr(pfnNewProc) ) // Verify that a valid pfn was passed
        goto EXIT;
    
    // First, verify the the module and function names passed to use are valid
    hModule = GetModuleHandle(pwszModuleToHook);
    pfnOriginalProc = GetProcAddress( hModule, pwszFunctionToHook );
    if( !pfnOriginalProc )
        goto EXIT;
    
    // Get process base pointer
    baseptr = pProcess->BasePtr;
    // Get a pointer to the process' imports section
    pImportDesc = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, baseptr, inf.rva);
    
    // find the import descriptor table
    pImportDesc = GetImportDesc(pwszModuleToHook, baseptr, inf.rva);
    if( !pImportDesc )
        goto EXIT;
    
    // Get a pointer to the process'module's import address table (IAT)
    pThunk = MakePtr(PIMAGE_THUNK_DATA, baseptr, pImportDesc->FirstThunk);
    
    // HOOK! :)
    if(HookImportTable(pThunk, pfnOriginalProc, pfnNewProc))
        bHooked = TRUE; // flag to indicate that we hooked at least once
    
    // Iterate through a list of all modules
    for(pmods = (PMODULE)KData.aInfo[KINX_MODULES]; pmods; pmods = pmods->pMod)
    {
        LPWSTR* ppwszTmp = ppwszExcludeList;
        // check to see if our process references this module, if not skip
        if(!HasModRefProcPtr(pmods, pProcess))
            continue;
        
        // check to see if this is the DLL whose function we want to hook if so skip
        if(!wcsicmp(pmods->lpszModName, pwszModuleToHook))
        {
// JCW_+ 2008.07.18 START
            // fix the module's base pointer to a process relative address
            baseptr = (LPVOID)ZeroPtr(pmods->BasePtr);
            
            inf = pmods->e32.e32_unit[EXP];

            // ЗБ·ОЅГАъАЗ ЖчАОЕНё¦ АъАеЗП°н АЦґВ БЦјТё¦ ѕтѕоїВґЩ
            LPDWORD pAddress = GetProcAddress(baseptr, inf.rva, pwszFunctionToHook);
            if(pAddress == NULL)
                continue;

            // АНЅєЖчЖ® ѕоµе·№Ѕє ЕЧАМєнАЗ ЗБ·ОЅГАъ БЦјТё¦ јцБ¤ЗПґВ єОєР
            //==========================================================================================================
            // ЗШґз БЦјТїЎ µйѕоАЦґВ °Є(ЗБ·ОЅГАъ БЦјТ)А» ґЩёҐ °Є(ЗБ·ОЅГАъ БЦјТ)·О №ЩІЩ·Б°н ЗПёй access violation exceptionАМ №Я»эЗХґПґЩ.
            // MapPtrToProcess, SetProcPermissions, VirtualProtectEx ЗФјцµйА» µїїшЗШ єёѕТБцёё ±Чґл·О АФґПґЩ.
            // ЅГЅєЕЫ БцЅДАМ ВЄѕЖј­ °н»эАФґПґЩ. ґ©°Ў ѕЖЅГёй ѕЛ·ББЦјјїд. T^T
            //==========================================================================================================
// JCW_+ 2008.07.18 END
            continue;
        }
        
        if(ppwszTmp)
        {
            while (*ppwszTmp)
            {
                // check the exclusion list to see if we should skip this module
                if(!wcsicmp(pmods->lpszModName, *ppwszTmp))
                    break;
                ppwszTmp++;
            }
            // found an excluded module, so skip
            if(*ppwszTmp)
                continue;
        }

        // fix the module's base pointer to a process relative address
        baseptr = (LPVOID)ZeroPtr(pmods->BasePtr);
        
        // if the base pointer does not change we have arom module, 
        // better skip this, we can only hook user modules.
        if(baseptr == pmods->BasePtr)
            continue;

        // get the import description table for the module
        inf = pmods->e32.e32_unit[IMP];
        pImportDesc = GetImportDesc(pwszModuleToHook, baseptr, inf.rva);
        if( !pImportDesc )
            continue;
        
        pThunk = MakePtr(PIMAGE_THUNK_DATA, baseptr, pImportDesc->FirstThunk);
        if(HookImportTable(pThunk, pfnOriginalProc, pfnNewProc))
            bHooked = TRUE; // flag to indicate that we hooked at least once
    }
    
EXIT:

#if 1
    pfnSetKMode(FALSE);
#else
    SetKMode(FALSE);
#endif

    return bHooked ? pfnOriginalProc : 0;   // 0 == Function not found
}


/*
typedef struct tagExcludeNode
{
    LPWSTR pwszExcludeModule;
    struct tagExcludeNode* pNext;
    
} EXCLUDE_NODE, *PEXCLUDENODE;


PEXCLUDENODE pRootExclude = NULL;

PEXCLUDENODE createNode(LPWSTR pwszName, PEXCLUDENODE pNext)
{
    PEXCLUDENODE pNode = (PEXCLUDENODE) malloc(sizeof(EXCLUDE_NODE));
    pNode->pNext = pNext;
    pNode->pwszExcludeModule = malloc(wcslen(pwszName) * sizeof(TCHAR) + 1);
    wcscpy(pNode->pwszExcludeModule, pwszName);
    return (pNode);
}


PVOID DeepIATHookBegin(LPWSTR* ppwszExcludeModuleList)
{
    TCHAR wszCurModule[MAX_PATH];
    TCHAR* wszMainExclude;
    GetModuleFileName(NULL, wszCurModule, MAX_PATH);
    wszMainExclude = wcsrchr(wszCurModule, _T('\\'));
    if(wszMainExclude)
    {
        *(wszMainExclude++) = 0;
    }
    else
    {
        wszMainExclude = wszCurModule;
    }
    pRootExclude = createNode(wszMainExclude, NULL);
    while (*ppwszExcludeModuleList)
    {
        pRootExclude = createNode(*ppwszExcludeModuleList, pRootExclude);
    }
    return (pRootExclude);
}
*/

Здравствуйте. Подскажите пожалуйста мне кажется не работает инжект ДЛЛ или точнее PerformCallBack4.Что не так? Люди пишут победили но как ? Код вот: Всем спасибо!

void Inject6 ( void )
{
    PROCESS_INFORMATION pi;
    BOOL bMode = SetKMode(TRUE);
    DWORD dwPerm = SetProcPermissions(0xFFFFFFFF);
    CreateProcess(szApplication,NULL,NULL,NULL,NULL,0,NULL,NULL,NULL,&pi);//excute note process
    Sleep(3000);
    HANDLE hProcess=GetProcessHandle(szApplication);//get handle
    if (hProcess)
    {
        CALLBACKINFO cbi;
        cbi.hProc = hProcess;
        cbi.pfn = (FARPROC)MapPtrToProcess(GetProcAddress(GetModuleHandle(L"coredll.dll"), L"LoadLibraryW"), hProcess);
        cbi.pvArg0 = (LPVOID)MapPtrToProcess(L"Urban81Dll", GetCurrentProcess());
        HINSTANCE hInst = (HINSTANCE)PerformCallBack4(&cbi, 0,0,0);
        CloseHandle (hProcess);
    }
}

Здравствуйте.Сейчас вижу ещё один способ инжекта ДЛЛ-это отредактировать ЕХЕ файл вручную через редактор WinHex или подобный — вписать длл и ее вызов при старте ехе.Инжект получился вышеуказанным способом (PETools->PeEditor).Версию проги только надо брать нормальную. Длл внедрили в DrFish.exe. Этот модуль в устройстве отвечает за считывании данных ЖПС с портов и дальнейшей раздачи их остальным модулям или что то вроде этого...Задача ДЛЛ перехватить вышесказанные АПИ функции с подсунуть мои...делать это она будет при помощи редактирования таблиц импорта...Вот нарыл функцию которая это делает.Подскажите где берётся структура HDATA? Заранее всем спасибо!

DWORD XXX ( HANDLE hProc, DWORD dFind, DWORD dReplace )
{
    DWORD ret = 0;
    //GODMODE ON
    BOOL  bOldKMode = SetKMode ( TRUE );
    DWORD dOldPerms = SetProcPermissions ( 0xFFFFFFFF );
    //get process ptr prom handle     
    //Process pr;
    HDATA * hProcHD = ( HDATA * ) ( 0x80000000 | ( ( DWORD ) hProc & HANDLE_ADDRESS_MASK ) );
    PROCESS * prc = ( PROCESS * ) hProcHD->pvObj;
    //get imports sections
    struct ImpHdr * blockptr, * blockstart;

    blockstart = ( struct ImpHdr * ) MapPtrProc ( prc->e32.e32_vbase + prc->e32.e32_unit[IMP].rva, prc );
    //iterate thru imports sections
    for ( blockptr = blockstart; blockptr->imp_lookup; ++blockptr )
    {
        DWORD dOldProtect, tmp;
        //get vectors ptr
        DWORD * vectors = ( DWORD * ) MapPtrProc ( prc->e32.e32_vbase + blockptr->imp_address, prc );
        //count vectors
        DWORD * vptr = vectors;
        while ( * vptr ) ++vptr;
        DWORD vcnt = ( vptr - vectors );
        //try to unlock imports section memory
        if ( VirtualProtect ( vectors, vcnt * sizeof ( DWORD ), PAGE_EXECUTE_READWRITE, &dOldProtect ) )
        {
            //find&replace
            for ( UINT i = 0; i < vcnt; ++i )
            {
                if ( vectors[i] == dFind )
                {
                    vectors[i] = dReplace;
                    ++ret;
                }
            }
            //lock back
            VirtualProtect ( vectors, vcnt * sizeof ( DWORD ), dOldProtect, &tmp );
        }
    }
    //GODMODE OFF
    SetProcPermissions ( dOldPerms );
    SetKMode ( bOldKMode );
    return ret;
}