进程隐藏与进程保护（SSDT Hook 实现）（二）

文章目录：

                 

1. 引子 – Demo 实现效果：

2. 进程隐藏与进程保护概念：

3. SSDT Hook 框架搭建：

4. Ring0 实现进程隐藏：

5. Ring0 实现进程保护：

6. 隐藏进程列表和保护进程列表的维护：

7. 小结：

                

1. 引子 – Demo 实现效果：

                        

上一篇《进程隐藏与进程保护(SSDT Hook 实现)(一)》呢把 SSDT 说得差不多了，

博文地址：

http://www.cnblogs.com/BoyXiao/archive/2011/09/03/2164574.html

不过呢，那也只是些理论的东西，看不到什么实物，估计说来说去把人说晕了后，也没什么感觉，

而这一篇博文的话，给出点新意的，让人头脑清醒点的 ~ 所以先给个 Demo 出来吧 ~

     

(不好意思，本着不喝倒怎出得了好文章这个理由，所以今天又喝多了点，文章有疏忽之处还请见谅 ~

顺便在这里跟朋友们分享一下哈，晚上于这个时间点，比如 2 点的时候啊，喝点小酒，

听点曲子，你会精神振奋，头脑更加清醒，思路也会很清晰，尤其是写起程序来那是唰唰的来の ~ )

      

进程隐藏效果：

应用程序主界面：

               

隐藏进程 taskmgr.exe：

              

取消进程隐藏 taskmgr.exe：

                

进程保护效果：

进程保护(保护自身进程 SSDTProcess.exe)：

         

取消进程保护(这里还是以 SSDTProcess.exe 为例)：

下面的截图表示 SSDTProcess.exe 已经被取消了保护，

此时再到任务管理器中结束 SSDTProcess.exe 时，你可以发现是可以正常结束这个进程的 ~

            

                

2. 进程隐藏与进程保护概念：

                        

在 Ring3 下获取到当前 Windows 操作系统下的所有的进程无外乎以下的几种方法：

第一种：使用 ToolHelp 遍历获取到所有进程，关于这种方式的话，笔者以前写过一篇博文的，

《列举 Windows 所有进程(ToolHelp)》博文地址如下：

http://www.cnblogs.com/BoyXiao/archive/2011/02/27/1966383.html

第二种：使用 PSAPI 下的 EnumProcesses 获取到所有进程的 PID，然后提升进程权限为 SE_DEBUG 权限，

再调用 OpenProcess 即可打开进程，从而获取到进程的基本信息(可以查看 MSDN 的 PSAPI 专题)。

第三种：使用未公开的本地 API 即位于 Ntdll.dll 中的未文档化的 API – NtQuerySystemInformation，

而 Windows 任务管理器就是通过这种方式来获取到所有的进程信息的 ~

而事实上的是，ToolHelp 和 PSAPI 只不过是对 Ntdll.dll 中 NtQuerySystemInformation API 的一个封装，

所以在 Ring3 下获取系统中所有进程信息最终都会回到 Ndll.dll 中 NtQuerySystemInformation API 的调用上。

如果要实现在 Ring3 中对进程进行隐藏的话，只需要 Hook 掉 NtQuerySystemInformation API 即可。

               

而至于进程保护的话，我们需要考虑到两种情况，第一种则是该进程自行终止，第二种情况则是该进程被其他进程给杀掉，

第一种情况基本上对于窗口应用程序来说，一般都是用户点击了右上角的 x 按钮，然后产生 WM_CLOSE 消息，

最后由窗口过程退出进程，这种情况下，我们应该是需要允许退出的，也就是进程是可以正常退出的。

而第二种情况的话，就是进程被别的进程杀掉，比如在任务管理器中就可以杀掉绝大部分的应用程序进程，

而这里的进程保护就是要实现进程不能够被任务管理器或者其他的进程管理工具杀掉。

在 Ring3 中，由一个进程结束其他进程，调用的 API 为 Kernel32.dll 中的 TerminateProcess，

如果追溯这个 TerminateProcess，可以发现，其调用了 Ntdll.dll 中的 NtTerminateProcess API，

然后再追溯下去就可以到 ntoskrnl.exe 中的 ZwTerminateProcess 和系统服务 NtTerminateProcess 了。

而这和我的上一篇博文中介绍 NtQuerySystemInformation 就是一致的了，

所以如果我们要实现进程保护，需要 Hook 的系统服务就是 NtTerminateProcess ~

                

               

3. SSDT Hook 框架搭建：

                        

从上面的介绍中，我们可以知道，要想实现进程隐藏和进程保护，我们需要在 SSDT 中 Hook 两个系统服务，

即 Ring0 下的 NtQuerySystemInformation 和 Ring0 下的 NtTerminateProcess，

既然要实现两个 Hook 的话，我干嘛不将 SSDT Hook 写成一个框架呢，

这样的话，以后我无论是需要 Hook 哪个 SSDT 中的系统服务，我直接调用这个 SSDT 框架不就 OK 了，

免得再去重复造轮子不，所以这里就来简单介绍一下这个 SSDT 框架 ~

当然这里谈得 SSDT Hook 框架可不是大伙眼里的什么 .Net 框架啊，MVC 框架啊之类的，

没那么复杂，算到底也就是一个 .cpp 和一个 .h 的文件而已，然后再在其中对外公开几个 API 即 OK 了 ~

                

这里既是使用了 SSDT 的话，而在前一篇博文中也谈到了在 ntoskrnl.exe 中导出了 KeServiceDescriptorTable，

但是内核中导出归导出，它导出有个屁用啊，别个类型啊什么的都没给你，看你怎么在你代码中使用它 ~

所以我们首先要做的就是如何使用这个 ntoskrnl.exe 中导出的 KeServiceDescriptorTable 了，

不过好在还有 WRK(当然在反汇编，逆向工程里面那些牛的作用也是相当的给力)的帮助，

我们可以定义下面的代码来完成在自己的代码中使用 KeServiceDescriptorTable 这个任务：

//=====================================================================================//
//Name: KSYSTEM_SERVICE_TABLE 和 KSERVICE_TABLE_DESCRIPTOR                             //
//Descripion: 用来定义 SSDT 结构                                                       //
//=====================================================================================//
typedef struct _KSYSTEM_SERVICE_TABLE
{
    PULONG  ServiceTableBase;        // SSDT (System Service Dispatch Table)的基地址
    PULONG  ServiceCounterTableBase; // 包含 SSDT 中每个服务被调用的次数
    ULONG   NumberOfService;     // 服务函数的个数, NumberOfService * 4 就是整个地址表的大小
    ULONG   ParamTableBase;          // SSPT(System Service Parameter Table)的基地址

} KSYSTEM_SERVICE_TABLE, *PKSYSTEM_SERVICE_TABLE;


typedef struct _KSERVICE_TABLE_DESCRIPTOR
{
    KSYSTEM_SERVICE_TABLE   ntoskrnl; // ntoskrnl.exe 的服务函数
    KSYSTEM_SERVICE_TABLE   win32k;   // win32k.sys 的服务函数(GDI32.dll/User32.dll 的内核支持)
    KSYSTEM_SERVICE_TABLE   notUsed1;
    KSYSTEM_SERVICE_TABLE   notUsed2;

} KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;


//导出由 ntoskrnl.exe 所导出的 SSDT
extern PKSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable;

        

既然是个 SSDT Hook 框架的话，自然需要能够安装 Hook，当然也需要能够解除 Hook，

而我们拿什么来解除 Hook 呢，经过前面的介绍，我们可以知道的是，

SSDT Hook 其实就是拿我们自己的 Hook 函数的地址去替换掉原来 SSDT 中保存的系统服务的地址，

如果 Hook 了某个 API，那就意味着在 SSDT 中指定索引处所保存的系统服务的地址被修改为了 Hook 函数的地址，

而如果要解除这个 API 的 Hook，自然就需要将原来系统中原有的系统服务的地址写回 SSDT 指定索引处，

但是我们拿什么来保存 SSDT Hook 之前的系统服务的地址呢 ?

        

由于在 32 位机器上，一个入口地址可以用 32 位来表示，也就可以使用一个 ULONG 类型来保存，

而由于我们这个是 SSDT 框架，也就是能够随意的 Hook SSDT 中的任意系统服务，

自然为了能成功实现 Hook 的解除，就需要将 SSDT 中在 Hook 之前的每一个系统服务的地址保存下来，

根据上面的总结，这可以通过一个 ULONG 数组来保存就可以了 ~

然后再在 Hook 任意的系统服务之前，将 SSDT 中的所有系统服务的地址保存或者说是备份到 ULONG 数组中即可 ~

而后在解除 Hook 时，我们就可以从这个 ULONG 数组中取出原有系统服务的地址，

然后将地址写入到 SSDT 中即可实现 Hook 解除 ~

//定义 SSDT(系统服务描述表) 中服务个数的最大数目
//这里定义为 1024 个，实际上在 XP SP3 是 0x0128 个
#define MAX_SYSTEM_SERVICE_NUMBER 1024

//用来保存 SSDT 中所有的旧的服务函数的地址
ULONG oldSysServiceAddr[MAX_SYSTEM_SERVICE_NUMBER];

                

同时由于要实现安装 Hook，解除 Hook，所以自然也要公开两个 API，一个用来安装 Hook，一个用来解除 Hook，

根据上面的这些呢，我们大致可以确定至少需要三个 API：

//备份 SSDT 中所有系统服务的地址
VOID BackupSysServicesTable();

//安装 Hook
NTSTATUS InstallSysServiceHook(ULONG oldService, ULONG newService);

//解除 Hook
NTSTATUS UnInstallSysServiceHook(ULONG oldService);

             

然后还需要注意的是，SSDT 中保存的地址不是说你想写就可以写的，

SSDT 在内存中是具有只读属性保护的，如果你想修改 SSDT 中的内容，你必须先要解除只读属性，

也就是要赋予 SSDT 所在的这块内存具有可写属性才行，不然回馈你的将是一个无情的蓝屏(内存写入错误) ~

你给了这块内存可写属性后，你他妈的写完后总的把可写属性去掉，把别个恢复到只读属性吧 ~

不然也太不厚道了，用完就不管了 ~ 所以还需要一个恢复只读属性的 API，

综述，在 SSDT Hook 框架中又有了两个 API：

//禁止写入保护，也就是恢复到只读
VOID DisableWriteProtect(ULONG oldAttr);

//允许写入保护，也就是设置为可写
VOID EnableWriteProtect(PULONG pOldAttr);

      

然后呢下面就将上面的这些个 API 的实现代码给贴出来，个人觉得自己的代码风格还算比较好的，

应该还是看得下去吧(当然这只是我现在的观点，说不准再过段时间回头来看这些代码就会感慨这代码是给人看的嘛) ~

#include "SSDTHook.h"

//=====================================================================================//
//Name: VOID DisableWriteProtect()                                                     //
//                                                                                     //
//Descripion: 用来去掉内存的可写属性，从而实现内存只读                                 //
//                                                                                     //
//=====================================================================================//
VOID DisableWriteProtect(ULONG oldAttr)
{
    _asm
    {
        mov eax, oldAttr
        mov cr0, eax
        sti;
    }
}


//=====================================================================================//
//Name: VOID EnableWriteProtect()                                                      //
//                                                                                     //
//Descripion: 用来去掉内存的只读保护，从而实现可以写内存                               //
//                                                                                     //
//=====================================================================================//
VOID EnableWriteProtect(PULONG pOldAttr)
{
    ULONG uAttr;

    _asm
    {
        cli;
        mov  eax, cr0;
        mov  uAttr, eax;
        and  eax, 0FFFEFFFFh; // CR0 16 BIT = 0
        mov  cr0, eax;
    };

    //保存原有的 CRO 属性
    *pOldAttr = uAttr;
}


//=====================================================================================//
//Name: VOID BackupSysServicesTable()                                                  //
//                                                                                     //
//Descripion: 备份 SSDT 中原有服务的地址，因为在解除 Hook 时需要还原 SSDT 中原有地址   //
//                                                                                     //
//=====================================================================================//
VOID BackupSysServicesTable()
{
    ULONG i;

    for(i = 0; (i < KeServiceDescriptorTable->ntoskrnl.NumberOfService) && (i < MAX_SYSTEM_SERVICE_NUMBER); i++)
    {
        oldSysServiceAddr[i] = KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[i];
        //oldSysServiceAddr[i] = *(PULONG)((ULONG)KeServiceDescriptorTable->ntoskrnl.ServiceTableBase + 4 * i);

        KdPrint(("\Function Information { Number: 0x%04X , Address: %08X}", i, oldSysServiceAddr[i]));
    }
}


//=====================================================================================//
//Name: NTSTATUS InstallSysServiceHook()                                               //
//                                                                                     //
//Descripion: 实现 Hook 的安装，主要是在 SSDT 中用 newService 来替换掉 oldService      //
//                                                                                     //
//=====================================================================================//
NTSTATUS InstallSysServiceHook(ULONG oldService, ULONG newService)
{
    ULONG uOldAttr = 0;

    EnableWriteProtect(&uOldAttr);

    SYSCALL_FUNCTION(oldService) = newService;
    //KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[SYSCALL_INDEX(oldService)] = newService;

    DisableWriteProtect(uOldAttr);

    return STATUS_SUCCESS;
}


//=====================================================================================//
//Name: NTSTATUS UnInstallSysServiceHook()                                             //
//                                                                                     //
//Descripion: 实现 Hook 的解除，主要是在 SSDT 中用备份下的服务地址来替换掉 oldService  //
//                                                                                     //
//=====================================================================================//
NTSTATUS UnInstallSysServiceHook(ULONG oldService)
{
    ULONG uOldAttr = 0;

    EnableWriteProtect(&uOldAttr);

    SYSCALL_FUNCTION(oldService) = oldSysServiceAddr[SYSCALL_INDEX(oldService)];

    DisableWriteProtect(uOldAttr);

    return STATUS_SUCCESS;
}

          

可以注意到上面有两个很重要的宏，即 SYSCALL_FUNCTION 和 SYSCALL_INDEX 宏，

关于这两个宏的具体作用，可以看注释的 ~

//根据 Zw_ServiceFunction 获取 Zw_ServiceFunction 在 SSDT 中所对应的服务的索引号
#define SYSCALL_INDEX(ServiceFunction) (*(PULONG)((PUCHAR)ServiceFunction + 1))


//根据 Zw_ServiceFunction 来获得服务在 SSDT 中的索引号，
//然后再通过该索引号来获取 Nt_ServiceFunction的地址
#define SYSCALL_FUNCTION(ServiceFunction)
        KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[SYSCALL_INDEX(ServiceFunction)]

       

          

4. Ring0 实现进程隐藏：

      

有了 SSDT Hook 框架后，其实要实现进程的隐藏是很简单的了，

根据前面的介绍，要想实现进程隐藏，你可以通过 Hook NtQuerySystemInformation 来实现，

所以剩下的任务就只需要在我们自己的 Hook 处理函数中来将进程隐藏掉就 OK 了 ~

由于 NtQuerySystemInformation 这个系统服务在 ntddk.h 中并没有被声明，

虽然这个系统服务在 ntoskrnl.exe 中被导出了，但是没有它的声明，我们仍然是无法使用的，

所以我们就需要手动的声明一下这个函数 ~

还有需要注意的是，我们在前面知道，在 ntoskrnl.exe 中实质上是存在 ZwQuerySystemInformation

以及 NtQuerySystemInformation 这两个 API 的，

而在 SSDT Hook 中我们是根据 ZwQuerySystemInformation

来推算出在 SSDT 中保存有 NtQuerySystemInformation 的地址所在的索引号的 ~

关于这个，你可以查看 SYSCALL_INDEX 这个宏来再次确认一下 ~

然后有了这个索引号，我们才可以进行对 NtQuerySystemInformation 系统服务的 Hook，

所以在声明时，我们需要声明两个 API，当然如果这些 API 在 ntddk.h 中声明了就不需要了，

但是由于 ZwQuerySystemInformation 和 NtQuerySystemInformation 在 ntddk.h 中都没有声明，

所以需要在我们自己的代码中手动声明 ~

NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation (
    __in SYSTEM_INFORMATION_CLASS SystemInformationClass,
    __out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
    __in ULONG SystemInformationLength,
    __out_opt PULONG ReturnLength
    );

typedef NTSTATUS (* NTQUERYSYSTEMINFORMATION)(
    __in SYSTEM_INFORMATION_CLASS SystemInformationClass,
    __out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
    __in ULONG SystemInformationLength,
    __out_opt PULONG ReturnLength
    );

                

(暂停一下，肚子饿了 ~ 吃饭去 ~ )

(好，饭给吃了，酒也喝了，精神亢奋中，现在咱继续哈 ~ 嘿嘿 ~)

       

完成了这些声明后，我们就可以来实现自己的 NtQuerySystemInformation Hook 函数了，

在这个 Hook 函数中，我们需要对我们感兴趣的进程进行隐藏 ~

然后这里需要注意的是，我是如何来实现对进程隐藏的，

首先我是判断这个进程的 ID 是否是需要隐藏的进程 ID，

这是通过 ValidateProcessNeedHide 函数来判断的 ~ 这个函数会在后面给出 ~

注意结合代码中的注释来看(虽然注释比较少 ~ 嘿嘿 ~ )

NTSTATUS HookNtQuerySystemInformation (
    __in SYSTEM_INFORMATION_CLASS SystemInformationClass,
    __out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
    __in ULONG SystemInformationLength,
    __out_opt PULONG ReturnLength
    );

     

//=====================================================================================//
//Name: NTSTATUS HookNtQuerySystemInformation()                                        //
//                                                                                     //
//Descripion: 自定义的 NtQuerySystemInformation，用来实现 Hook Kernel API              //
//                                                                                     //
//=====================================================================================//
NTSTATUS HookNtQuerySystemInformation (
    __in SYSTEM_INFORMATION_CLASS SystemInformationClass,
    __out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
    __in ULONG SystemInformationLength,
    __out_opt PULONG ReturnLength
    )
{
    NTSTATUS rtStatus;

    pOldNtQuerySystemInformation = (NTQUERYSYSTEMINFORMATION)
        oldSysServiceAddr[SYSCALL_INDEX(ZwQuerySystemInformation)];

    rtStatus = pOldNtQuerySystemInformation(SystemInformationClass, SystemInformation,
        SystemInformationLength, ReturnLength);
    if(NT_SUCCESS(rtStatus))
    {
        if(SystemProcessInformation == SystemInformationClass)
        {
            PSYSTEM_PROCESS_INFORMATION pPrevProcessInfo = NULL;
            PSYSTEM_PROCESS_INFORMATION pCurrProcessInfo =
                (PSYSTEM_PROCESS_INFORMATION)SystemInformation;

            while(pCurrProcessInfo != NULL)
            {
                //获取当前遍历的 SYSTEM_PROCESS_INFORMATION 节点的进程名称和进程 ID
                ULONG uPID = (ULONG)pCurrProcessInfo->UniqueProcessId;
                UNICODE_STRING strTmpProcessName = pCurrProcessInfo->ImageName;

                //判断当前遍历的这个进程是否为需要隐藏的进程
                if(ValidateProcessNeedHide(uPID) != -1)
                {
                    if(pPrevProcessInfo)
                    {
                        if(pCurrProcessInfo->NextEntryOffset)
                        {
                            //将当前这个进程(即要隐藏的进程)从 SystemInformation 中摘除(更改链表偏移指针实现)
                            pPrevProcessInfo->NextEntryOffset += pCurrProcessInfo->NextEntryOffset;
                        }
                        else
                        {
                            //说明当前要隐藏的这个进程是进程链表中的最后一个
                            pPrevProcessInfo->NextEntryOffset = 0;
                        }
                    }
                    else
                    {
                        //第一个遍历到得进程就是需要隐藏的进程
                        if(pCurrProcessInfo->NextEntryOffset)
                        {
                            (PCHAR)SystemInformation += pCurrProcessInfo->NextEntryOffset;
                        }
                        else
                        {
                            SystemInformation = NULL;
                        }
                    }
                }

                //遍历下一个 SYSTEM_PROCESS_INFORMATION 节点
                pPrevProcessInfo = pCurrProcessInfo;

                //遍历结束
                if(pCurrProcessInfo->NextEntryOffset)
                {
                    pCurrProcessInfo = (PSYSTEM_PROCESS_INFORMATION)
                        (((PCHAR)pCurrProcessInfo) + pCurrProcessInfo->NextEntryOffset);
                }
                else
                {
                    pCurrProcessInfo = NULL;
                }
            }
        }
    }
    return rtStatus;
}

         

既然有了自己的 Hook NtQuerySystemInformation 了，自然我们就可以通过利用 SSDT 框架来实现 Hook 了，

这部分的代码其实是最简单的，因为我只需要在 DriverEntry 中 Hook 掉 NtQuerySystemInformation 即可，

这里需要注意的是，在执行 Hook 之前需要备份一次 SSDT，即在 DriverEntry 中最先需要备份 SSDT ~

当然为了保证系统的安全以及其他诸多方面，我们在 DriverUnload 中会将 Hook 解除掉 ~

从下面的代码中，我们看到在安装 Hook 和解除 Hook 时参数传递进去的是 ZwQuerySystemInformation，

这样很有可能会让很多朋友认为我们在 Ring0 下的 Hook 的是 ZwQuerySystemInformation，

如果你这样认为的话，那就大错特错了，确实在 Google 上搜索出的一大堆关于 SSDT Hook 中，

很多文章都说是 Hook 的 ZwQuerySystemInformation，而事实上这是大错特错的，

我们这里传入 ZwQuerySystemInformation ，是因为我们需要调用 SYS_INDEX(ZwQuerySystemInformation)

来获得 NtQuerySystemInformation 在 SSDT 中的地址所在的索引号，

然后我们根据这个索引号来 Hook NtQuerySystemInformation，

认识到这一点是非常重要的，因为我一开始也认为是 Hook 的 ZwQuerySystemInformation，

从而导致蓝屏了 n 次，在这里非常鄙视那些把文章从别处拷贝过来也不加验证就乱发表的 ~ 害死人 ~ 当然也要怪自己懒 ~

       

          

         

5. Ring0 实现进程保护：

            

有了上面实现进程隐藏的基础，要再来实现进程保护，其实也就是过过场子了 ~

进程保护呢，上面也说了，是要 Hook NtTermianteProcess 这个系统服务 ~

由于 ZwTerminateProcess 呢，在 ntddk.h 中已经声明了，

所以在我们自己的代码中就不需要声明 ZwTermianteProcess 了，

而只需要声明 NtTerminateProcess 以及 Hook 函数就 OK 了 ~

typedef NTSTATUS (* NTTERMINATEPROCESS)(
    __in_opt HANDLE ProcessHandle,
    __in NTSTATUS ExitStatus
    );

NTSTATUS HookNtTerminateProcess(
    __in_opt HANDLE ProcessHandle,
    __in NTSTATUS ExitStatus
    );

NTTERMINATEPROCESS pOldNtTerminateProcess;

         

至于安装 Hook 以及卸载 Hook ，都可以根据进程隐藏中的代码来完成，因为有了 SSDT Hook 框架，

这一切也就变得很简单了，只要在 DriverEntry 中 InstallHook ，然后再在 DriverUnload 中 UnInstallHook 即 OK ~

下面我们重点来看一看我们自己的 Hook NtTerminateProcess 中是如何实现进程保护的 ~

进程保护呢其实也是比较简单的，因为从上面一层的调用会传递一个进程句柄下来，

而后我们可以根据这个进程句柄来获得进程的 EPROCESS 对象(进程位于执行体层得对象)，

通过这个 EPROCESS 对象，我们就可以获得这个请求被结束的进程的 PID，

我们再判断这个 PID 是否是我们已经保护了的 PID，如果是的话，直接返回一个请求被拒绝即可，

而如果这个 PID 未被保护，自然我们就交给原来的 NtTerminateProcess 处理即可 ~

//=====================================================================================//
//Name: NTSTATUS HookNtTerminateProcess()                                              //
//                                                                                     //
//Descripion: 自定义的 NtTerminateProcess，用来实现 Hook Kernel API                    //
//                                                                                     //
//=====================================================================================//
NTSTATUS HookNtTerminateProcess(
    __in_opt HANDLE ProcessHandle,
    __in NTSTATUS ExitStatus
    )
{
    ULONG uPID;
    NTSTATUS rtStatus;
    PCHAR pStrProcName;
    PEPROCESS pEProcess;
    ANSI_STRING strProcName;

    //通过进程句柄来获得该进程所对应的 FileObject 对象，由于这里是进程对象，自然获得的是 EPROCESS 对象
    rtStatus = ObReferenceObjectByHandle(ProcessHandle,
        FILE_READ_DATA, NULL, KernelMode, &pEProcess, NULL);
    if(!NT_SUCCESS(rtStatus))
    {
        return rtStatus;
    }

    //保存 SSDT 中原来的 NtTerminateProcess 地址
    pOldNtTerminateProcess =
        (NTTERMINATEPROCESS)oldSysServiceAddr[SYSCALL_INDEX(ZwTerminateProcess)];

    //通过该函数可以获取到进程名称和进程 ID，该函数在内核中实质是导出的(在 WRK 中可以看到)
    //但是 ntddk.h 中并没有到处，所以需要自己声明才能使用
    uPID = (ULONG)PsGetProcessId(pEProcess);
    pStrProcName = (PCHAR)PsGetProcessImageFileName(pEProcess);

    //通过进程名来初始化一个 ASCII 字符串
    RtlInitAnsiString(&strProcName, pStrProcName);

    if(ValidateProcessNeedProtect(uPID) != -1)
    {
        //确保调用者进程能够结束(这里主要是指 taskmgr.exe)
        if(uPID != (ULONG)PsGetProcessId(PsGetCurrentProcess()))
        {
            //如果该进程是所保护的的进程的话，则返回权限不够的异常即可
            return STATUS_ACCESS_DENIED;
        }
    }

    //对于非保护的进程可以直接调用原来 SSDT 中的 NtTerminateProcess 来结束进程
    rtStatus = pOldNtTerminateProcess(ProcessHandle, ExitStatus);

    return rtStatus;
}

           

          

6. 隐藏进程列表和保护进程列表的维护：

       

由于需要隐藏的进程以及需要被保护的进程都是由应用程序传递进来的，

也就是说这个内核程序是需要和应用程序通信的，自然就需要创建一个 Device，

然后我就采用了简单的 DeviceIoControl 来实现了内核程序和应用程序的通信，

对于需要隐藏的进程或者是需要保护的进程，其由应用程序通过 DeviceIoControl 来将这个进程的 PID 传递给内核程序，

然后在内核程序中呢，维护了两个数组，一个数组用来存放需要隐藏的进程的 PID，

另外一个数组自然就是用来存放需要保护的进程的 PID，

ULONG g_PIDHideArray[MAX_PROCESS_ARRARY_LENGTH];
ULONG g_PIDProtectArray[MAX_PROCESS_ARRARY_LENGTH];

ULONG g_currHideArrayLen = 0;
ULONG g_currProtectArrayLen = 0;

         

为了维护上面的这两个数组呢，又衍生出了几个 API，即实现对数组中的 PID 进行增删查 ~

//验证 uPID 所代表的进程是否存在于隐藏进程列表中，即判断 uPID 这个进程是否需要隐藏
ULONG ValidateProcessNeedHide(ULONG uPID);

//验证 uPID 所代表的进程是否存在于保护进程列表中，即判断 uPID 这个进程是否需要保护
ULONG ValidateProcessNeedProtect(ULONG uPID);

//往隐藏进程列表中插入 uPID
ULONG InsertHideProcess(ULONG uPID);

//从隐藏进程列表中移除 uPID
ULONG RemoveHideProcess(ULONG uPID);

//往保护进程列表中插入 uPID
ULONG InsertProtectProcess(ULONG uPID);

//从隐藏进程列表中移除 uPID
ULONG RemoveProtectProcess(ULONG uPID);

        

对于前面谈及的 HookNtQuerySystemInformation 和 HookNtTerminateProcess 的话，

需要判断一个进程是否是需要被保护或者需要被隐藏的进程就是通过上面的数组来完成的，

即判断一个进程是否需要被隐藏时，只需要判断这个进程在隐藏列表中是否存在即可，

而对于实现进程保护的话，道理也是一样的 ~

上面说过，应用程序和内核程序的通信是通过 DeviceIoControl 来完成的，

下面我们就来看看 DeviceIoControl 的代码：

//=====================================================================================//
//Name: NTSTATUS SSDT01DeviceIoControlDispatcher()                                     //
//                                                                                     //
//Descripion: 分发函数                                                                 //
//                                                                                     //
//=====================================================================================//
NTSTATUS SSDT01DeviceIoControlDispatcher(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp)
{
    NTSTATUS rtStatus;

    ULONG uPID;
    ULONG uInLen;
    ULONG uOutLen;
    ULONG uCtrlCode;

    PCHAR pInBuffer;

    PIO_STACK_LOCATION pStack;

    uPID = 0;
    rtStatus = STATUS_SUCCESS;
    pStack = IoGetCurrentIrpStackLocation(pIrp);

    uInLen = pStack->Parameters.DeviceIoControl.InputBufferLength;
    uOutLen = pStack->Parameters.DeviceIoControl.OutputBufferLength;
    uCtrlCode = pStack->Parameters.DeviceIoControl.IoControlCode;

    //使用缓冲区方式与应用程序进行通信
    pInBuffer = (PCHAR)pIrp->AssociatedIrp.SystemBuffer;

    if(uInLen >= 4)
    {
        //stdlib.h(atol = Array To LONG)
        uPID = atol(pInBuffer);

        switch(uCtrlCode)
        {
        case IO_INSERT_PROTECT_PROCESS:
            {
                if(InsertProtectProcess(uPID) == FALSE)
                {
                    rtStatus = STATUS_PROCESS_IS_TERMINATING;
                }
                break;
            }
        case IO_REMOVE_PROTECT_PROCESS:
            {
                if(RemoveProtectProcess(uPID) == FALSE)
                {
                    rtStatus = STATUS_PROCESS_IS_TERMINATING;
                }
                break;
            }
        case IO_INSERT_HIDE_PROCESS:
            {
                if(InsertHideProcess(uPID) == FALSE)
                {
                    rtStatus = STATUS_PROCESS_IS_TERMINATING;
                }
                break;
            }
        case IO_REMOVE_HIDE_PROCESS:
            {
                if(RemoveHideProcess(uPID) == FALSE)
                {
                    rtStatus = STATUS_PROCESS_IS_TERMINATING;
                }
                break;
            }
        default:
            {
                rtStatus = STATUS_INVALID_VARIANT;
                break;
            }
        }
    }
    else
    {
        rtStatus = STATUS_INVALID_PARAMETER;
    }

    //输出信息总是为空，即该驱动程序不返回输出信息
    pIrp->IoStatus.Status = rtStatus;
    pIrp->IoStatus.Information = 0;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);

    return rtStatus;
}

              

         

7. 小结：

          

这篇博文呢，是承接前一篇博文《进程隐藏与进程保护(SSDT Hook 实现)(一)》来的，

前面的博文主要介绍了 SSDT 是个什么东西，以及我们做内核 Hook 的一些基础，

而这篇博文则完整的介绍了 SSDT Hook 的具体实现，其中涉及到了很多底层的知识的，

对于绝大部分的代码呢，大伙是可以参考代码来进行理解的，而后我会将内核部分的代码先公开出来 ~

本来呢是打算将这个 SSDT Hook 做两篇博文就给结束得了，

不过第二篇博文写了这么长了，但是在应用程序中的实现都还没有开始介绍，

而今晚真的又太晚了，再写下去天就亮了，还说要尽量不熬夜的 ~ 唉 ~ 算了，权当周末给自己找个借口吧 ~

下一篇博文将介绍的是如何在应用程序中获取到所有的进程啊，以及应用程序如何和内核程序设备进行通信之类的知识，

知识重点是放在 Ring3 了，其中不会涉及到很多 Ring0 的内容了 ~

       

开发工具以及环境搭建：

Visual Studio 2010 + VirtualDDK + WDK + VMware + Windows Service 2003 SP1，至于具体环境的搭建，

可以参考我的博文《驱动程序环境搭建(VS2010 + WDK + VirtualDDK + VMware)》，博文地址如下：

http://www.cnblogs.com/BoyXiao/archive/2011/07/31/2122755.html

           

下载 SSDT Hook Source Code

                     

和前一篇文章一样，我将我近来遇到的一些疑问放到博文的最后面，看是否有看官遇到过，如果有遇到过的，

还请不吝赐教 ~ 在下感激不尽 ~

          

疑问 1：

在 .Net WinForm 中，我有一个定时器，然后又有一个按钮，

那么对应的就有一个定时器 Tick 处理事件，按钮也会有一个 Click 事件，

考虑在多核处理器上，有没有这样一种可能，按钮的 Click 事件和 Tick 处理事件并发执行 ?

如果有的话，大伙一般都是如何做处理的 ?

            

疑问 2：

大家都有用过 SVN 的，当我们安装好客户端工具 TortoiseSVN 后，

每次启动 PC ，均会有一个 TSVNCache.exe 的进程随 PC 自动启动，

请教一下大家这个进程是如何启动的 ?

              

           

版权所有，欢迎转载，但转载请注明： 转载自  Zachary.XiaoZhen - 梦想的天空

进程隐藏与进程保护（SSDT Hook 实现）（三）

文章目录：

                 

1. 引子：

2. 获取当前系统下所有进程：

3. 服务管理（安装，启动，停止，卸载）：

4. 应用程序和内核程序通信：

5. 小结：

                

1. 引子：

                         

关于这个 SSDT Hook 实现进程隐藏和进程保护呢，这是最后一篇博文了，

在文章的结尾处呢你可以下载到整个项目的实例程序以及代码，

程序可以在 XP、Server、Win7 上运行的，当然我是说的 32 位操作系统。       

                  

《进程隐藏与进程保护(SSDT Hook 实现)(一)》呢把 SSDT Hook 的原理说得差不多了，

博文地址：http://www.cnblogs.com/BoyXiao/archive/2011/09/03/2164574.html

《进程隐藏与进程保护(SSDT Hook 实现)(二)》则把 SSDT Hook 的实现说得差不多了，

博文地址：http://www.cnblogs.com/BoyXiao/archive/2011/09/04/2166596.html

             

这一篇博文介绍的则是在 Ring3 下编写 MFC 应用程序，并且让应用程序与内核程序通信，

即由应用程序将需要隐藏的进程或者是需要保护的进程的 PID 传递给内核程序，

然后在内核程序中就会将传递进来的这个 PID 进行隐藏或者保护 ~

在这里再给出这个应用程序的一张截图：

        

                

2. 获取当前系统下所有进程：

                 

前面提到过，要想获取到系统下的所有进程，有三种方法，

第一种即是使用 ToolHelp 来获取，

第二种则是使用 PSAPI 来获取，

第三种则是使用 ntdll.dll 中的未文档化的 NtQuerySystemInformation 之类的 API 来获取(比较麻烦)。

而在这里我使用最简单的方式，即通过 PSAPI 中的 EnumProcesses 这个 API 来获取，

EnumProcesses API 可以获取到当前系统下所有进程的 PID，并且将 PID 存放在作为输出参数的数组当中，

其原型如下（可以看 MSDN）：

BOOL WINAPI EnumProcesses(
  __out         DWORD* pProcessIds,
  __in          DWORD cb,
  __out         DWORD* pBytesReturned
);

     

代码中使用(将获取到所有的 PID，然后将 PID 保存到 vector 容器中)：

//遍历当前所有的进程，并且将进程 ID 填充到容器 vectorPID 中
void CSSDTProcessDlg::FillPIDVector()
{
    DWORD dwPIDArray[MAX_PROCESS_COUNT];
    DWORD dwNeededBytes;
    DWORD dwProcCount;

    dwNeededBytes = 0;
    dwProcCount = 0;
    memset(dwPIDArray, 0, sizeof(DWORD) * MAX_PROCESS_COUNT);
    if(NULL != EnumProcesses(dwPIDArray, sizeof(dwPIDArray), &dwNeededBytes))
    {
        dwProcCount = dwNeededBytes / sizeof(DWORD);
    }

    BubbleSort(dwPIDArray, dwProcCount);

    ClearVector();
    for(int i=0; i<dwProcCount; i++)
    {
        PROCESS_BIND procBind;
        procBind.dwPID = dwPIDArray[i];
        if(dwPIDArray[i] == 0)
        {
            procBind.state = ProcessStateUnknown;
        }
        else
        {
            procBind.state = ProcessStateGeneral;
        }
        this->m_vctAllProcess.push_back(procBind);
    }
}

        

                

3. 服务管理（安装，启动，停止，卸载）：

             

在 Windows 内核程序中，现在大体可以分为三类了，

第一类是 NT 式驱动程序；

第二类为 WDM 驱动程序；

第三类为 WDF 驱动程序；

其中，对于 NT 式驱动程序，其安装方式是很简单的，因为你可以将 NT 式驱动程序看做一个服务，

既然是服务的话，自然在 Windows 中可以通过 SCM API 来完成其安装，启动，停止和卸载等功能 ~

而至于 WDM 和 WDF 的话，如果其中涉及到了设备的话，还必须使用 INF 文件来实现安装 ~

而我们前面的那个 SSDT 内核程序就是基于 NT 式的驱动程序，所以可以通过 SCM API 来实现上面的这些功能，

至于如何使用 SCM API 来完成服务的安装、启动、停止和卸载功能的话，

可以参见笔者的另外一篇博文《Windows 服务(附服务开发辅助工具)》，

博文地址为：http://www.cnblogs.com/BoyXiao/archive/2011/08/07/2130208.html

下面就只是将服务的安装 API、启动 API、停止 API 和卸载 API 贴出来了 ~

至于这些代码的细细道来的话，可以参加上面给出的那篇博文的 ~

//=====================================================================================//
//Name: bool InstallSvc()                                                              //
//                                                                                     //
//Descripion: 安装服务                                                                 //
//            lpszSvcName 为服务名称，                                                 //
//            lpszDisplay 为显示在服务控制管理器中的名称，                             //
//            lpszSvcBinaryPath 为服务映像文件所在路径，                               //
//            dwSvcType 为服务类型                                                     //
//            dwStartType 为服务启动类型                                               //
//=====================================================================================//
bool CSSDTProcessDlg::InstallSvc(LPTSTR lpszSvcName, LPTSTR lpszDisplayName,
        LPTSTR lpszSvcBinaryPath, DWORD dwSvcType, DWORD dwStartType)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hSvc = NULL;

    AdjustProcessTokenPrivilege();

    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if(NULL == hSCM)
    {
        OutputErrorMessage(TEXT("InstallSvc - OpenSCManager Failed , Error Code Is %d , Error Message Is %s !"));

        return FALSE;
    }

    for(int i = 0; i < 3 && (NULL == hSvc); i++)
    {
        //SERVICE_WIN32_OWN_PROCESS  | SERVICE_INTERACTIVE_PROCESS
        hSvc = CreateService(hSCM, lpszSvcName, lpszDisplayName, SERVICE_ALL_ACCESS,
            dwSvcType, dwStartType, SERVICE_ERROR_NORMAL,
            lpszSvcBinaryPath, NULL, NULL, NULL, NULL, NULL);
        if(NULL != hSvc)
        {
            if(NULL != hSvc)
            {
                CloseServiceHandle(hSvc);
            }
            CloseServiceHandle(hSCM);
            return TRUE;
        }
    }

    OutputErrorMessage(TEXT("InstallSvc - CreateService Failed , Error Code Is %d , Error Message Is %s !"));

    CloseServiceHandle(hSCM);

    return FALSE;
}


//=====================================================================================//
//Name: bool UnInstallSvc()                                                            //
//                                                                                     //
//Descripion: 实现卸载服务                                                             //
//=====================================================================================//
bool CSSDTProcessDlg::UnInstallSvc(LPTSTR lpszSvcName)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hSvc = NULL;
    bool rtResult = FALSE;

    AdjustProcessTokenPrivilege();

    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if(NULL == hSCM)
    {
        OutputErrorMessage(TEXT("UnInstallSvc - OpenSCManager Failed , Error Code Is %d , Error Message Is %s !"));

        return FALSE;
    }

    hSvc = OpenService(hSCM, lpszSvcName, SERVICE_ALL_ACCESS);
    if(NULL == hSvc)
    {
        OutputErrorMessage(TEXT("UnInstallSvc - OpenService Failed , Error Code Is %d , Error Message Is %s !"));

        CloseServiceHandle(hSCM);

        return FALSE;
    }

    rtResult = DeleteService(hSvc);

    CloseServiceHandle(hSvc);
    CloseServiceHandle(hSCM);

    return rtResult;
}


//=====================================================================================//
//Name: bool StartSvc()                                                                //
//                                                                                     //
//Descripion: 实现启动服务                                                             //
//=====================================================================================//
bool CSSDTProcessDlg::StartSvc(LPTSTR lpszSvcName)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hSvc = NULL;
    bool rtResult = FALSE;

    AdjustProcessTokenPrivilege();

    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if(NULL == hSCM)
    {
        OutputErrorMessage(TEXT("StartSvc - OpenSCManager Failed , Error Code Is %d , Error Message Is %s !"));

        return FALSE;
    }

    hSvc = OpenService(hSCM, lpszSvcName, SERVICE_ALL_ACCESS);
    if(NULL == hSvc)
    {
        OutputErrorMessage(TEXT("StartSvc - OpenService Failed , Error Code Is %d , Error Message Is %s !"));

        CloseServiceHandle(hSCM);

        return FALSE;
    }

    rtResult = StartService(hSvc, NULL, NULL);

    CloseServiceHandle(hSvc);
    CloseServiceHandle(hSCM);

    if(FALSE == rtResult)
    {
        if(ERROR_SERVICE_ALREADY_RUNNING == GetLastError())
        {
            return TRUE;
        }
        else
        {
            OutputErrorMessage(TEXT("StartSvc - StartService Failed , Error Code Is %d , Error Message Is %s !"));

            return FALSE;
        }
    }
    else
    {
        return TRUE;
    }
}


//=====================================================================================//
//Name: bool StopSvc()                                                                 //
//                                                                                     //
//Descripion: 实现停止服务                                                             //
//=====================================================================================//
bool CSSDTProcessDlg::StopSvc(LPTSTR lpszSvcName)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hSvc = NULL;
    bool rtResult = FALSE;

    SERVICE_STATUS svcStatus;

    AdjustProcessTokenPrivilege();

    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if(NULL == hSCM)
    {
        OutputErrorMessage(TEXT("StopSvc - OpenSCManager Failed , Error Code Is %d , Error Message Is %s !"));

        return FALSE;
    }

    hSvc = OpenService(hSCM, lpszSvcName, SERVICE_ALL_ACCESS);
    if(NULL == hSvc)
    {
        OutputErrorMessage(TEXT("StopSvc - OpenService Failed , Error Code Is %d , Error Message Is %s !"));

        CloseServiceHandle(hSCM);

        return FALSE;
    }

    rtResult = ControlService(hSvc, SERVICE_CONTROL_STOP, &svcStatus);
    if(rtResult == FALSE)
    {
        OutputErrorMessage(TEXT("StopSvc - ControlService Failed , Error Code Is %d , Error Message Is %s !"));
    }
    CloseServiceHandle(hSvc);
    CloseServiceHandle(hSCM);

    return rtResult;
}

       

那么服务的安装和启动放在那里比较合适，而服务的关闭和卸载又放在那里比较合适呢 ?

由于这个应用程序采用 MFC 开发，自然可以在 OnInitDialog()中安装和启动服务比较合适，

而后可以在对话框类的析构函数中关闭和卸载掉服务 ~

安装和启动服务：

    wstring wStrSysPath = GetSysFilePath();
    BOOL bResult = InstallSvc(((LPTSTR)(LPCTSTR)SSDT01_SERVICE_NAME),
                              ((LPTSTR)(LPCTSTR)SSDT01_SERVICE_NAME),
                              ((LPTSTR)(LPCTSTR)wStrSysPath.c_str()),
                              SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START);
    if(FALSE == bResult)
    {
        MessageBox(_TEXT(" Install SSDT Service Failed , Application Auto Exit !  "),
                   _TEXT("Application Error"), MB_OK | MB_ICONSTOP);
        CDialogEx::OnCancel();
        return FALSE;
    }
    else
    {
        bResult = StartSvc(SSDT01_SERVICE_NAME);
        if(FALSE == bResult)
        {
            MessageBox(_TEXT(" Start SSDT Service Failed , Application Auto Exit !  "),
                       _TEXT("Application Error"), MB_OK | MB_ICONSTOP);
            CDialogEx::OnCancel();
            return FALSE;
        }
    }

           

停止并且将服务卸载掉：

    ~CSSDTProcessDlg()
    {
        //在析构函数中关闭 SSDT 设备句柄
        if(this->m_hDevice)
        {
            CloseHandle(this->m_hDevice);
        }

        //当发生析构函数时，停止服务并且卸载服务
        StopSvc(SSDT01_SERVICE_NAME);
        UnInstallSvc(SSDT01_SERVICE_NAME);
    }

        

                

4. 应用程序和内核程序通信：

           

由前面的第二篇博文，可以知道，应用程序和内核程序的通信我是通过 DeviceIoControl 来完成的，

开发过内核程序的都清楚，应用程序和内核程序的通信最普遍的也就通过三个 API 来实现，

一个 ReadFile，一个 WriteFile，一个 DeviceIoContrl，

当然其中属 DeviceIoControl 功能最为强大，完全可以用其替换掉 ReadFile 和 WriteFile，

DeviceIoControl 原型(详细信息可以参考 MSDN)：

BOOL WINAPI DeviceIoControl(
  __in          HANDLE hDevice,
  __in          DWORD dwIoControlCode,
  __in          LPVOID lpInBuffer,
  __in          DWORD nInBufferSize,
  __out         LPVOID lpOutBuffer,
  __in          DWORD nOutBufferSize,
  __out         LPDWORD lpBytesReturned,
  __in          LPOVERLAPPED lpOverlapped
);

         

至于如何实现应用程序和内核程序的通信的话，在我的 Demo 中是这样做处理的，

首先在 OnInitDialog 事件中通过 CreateFile 打开我们所安装的服务中创建的设备，

(在 NT 式驱动程序中我创建了一个设备，这个设备用来实现应用程序和内核程序的通信)，

然后在对话框类中保存有一个全局变量，这个全局变量即代表所打开的这个设备的句柄，

       

既然这个全局变量是保存的我们的设备的句柄，自然我们需要来获取到设备的句柄，并且将句柄赋值给该全局变量，

而这个呢，又是在 OnInitDialog 中完成的 ~

    this->m_hDevice = CreateFile(SSDT01_DEVICE_NAME, GENERIC_READ | GENERIC_WRITE, 0,
                                 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if(INVALID_HANDLE_VALUE == this->m_hDevice)
    {
        MessageBox(_TEXT(" Open SSDT Device Failed , Application Auto Exit !  "),
                   _TEXT("Application Error"), MB_OK | MB_ICONSTOP);

        CDialogEx::OnCancel();
        return FALSE;
    }

        

有了这个设备句柄，我们就可以通过其来实现和内核程序的通信了，

因为通过在应用程序中调用 DeviceIoControl 可以产生 IRP_MJ_DEVICE_CONTROL 的 IRP，

然后该 IRP 可以被驱动程序中的 DeviceIoControl 分发函数所处理 ~

我们的应用程序只需要将我们所要隐藏或者是需要保护的进程的 PID 通过 DeviceIoControl 传递给内核程序即可 !!!

所以我们在应用程序中只需要调用 DeviceIoContrl 即可 ~

下面给出的代码比较凌乱(重点请看 DeviceIoControl 的调用)

//隐藏进程或者取消对进程的隐藏
void CSSDTProcessDlg::OnBnClickedBtnHideorunhide()
{
    int nIndex;
    DWORD dwPID;
    CString cStrText;
    CString cStrState;

    DWORD dwOutput;
    BOOL bRet;
    CHAR inBuffer[10];
    CHAR outBuffer[10];
    memset(inBuffer, 0, 10);
    memset(outBuffer, 0, 10);

    dwPID = this->GetDlgItemInt(IDC_STATIC_SELECTED_PID);
    this->GetDlgItemText(ID_BTN_HIDEORUNHIDE, cStrText);

    ultoa(dwPID, inBuffer, 10);

    nIndex = QueryItemIndexByPID(dwPID);
    cStrState = this->m_ListCtrlProcess.GetItemText(nIndex, 4);

    if(cStrText.CompareNoCase(_TEXT("Hide")) == 0)
    {
        //隐藏 dwPID
        bRet = DeviceIoControl(this->m_hDevice, IO_INSERT_HIDE_PROCESS, inBuffer, 10,
             &outBuffer, 10, &dwOutput, NULL);
        if(bRet)
        {
            this->SetDlgItemText(ID_BTN_HIDEORUNHIDE, _TEXT("UnHide"));
            if(cStrState.CompareNoCase(_TEXT("Protect")) == 0)
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("HideAndProtect"));
            }
            else
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("Hide"));
            }
            MessageBox(_TEXT(" Hide Process Sucess !  "), _TEXT("Information"), MB_OK |
                     MB_ICONINFORMATION);
        }
        else
        {
            MessageBox(_TEXT(" Hide Process Failed !  "), _TEXT("Warning"), MB_OK | MB_ICONERROR);
        }
    }
    else
    {
        //解除 dwPID 隐藏
        bRet = DeviceIoControl(this->m_hDevice, IO_REMOVE_HIDE_PROCESS, inBuffer, 10,
             &outBuffer, 10, &dwOutput, NULL);
        if(bRet)
        {
            this->SetDlgItemText(ID_BTN_HIDEORUNHIDE, _TEXT("Hide"));
            if(cStrState.CompareNoCase(_TEXT("Protect")) == 0 ||
               cStrState.CompareNoCase(_TEXT("HideAndProtect"))== 0)
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("Protect"));
            }
            else
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("General"));
            }
            MessageBox(_TEXT(" UnHide Process Sucess !  "), _TEXT("Information"), MB_OK |
                  MB_ICONINFORMATION);
        }
        else
        {
            MessageBox(_TEXT(" UnHide Process Failed !  "), _TEXT("Warning"), MB_OK | MB_ICONERROR);
        }
    }
}


//保护进程或者取消对进程的保护操作
void CSSDTProcessDlg::OnBnClickedBtnProtectorunprotect()
{
    int nIndex;
    DWORD dwPID;
    CString cStrText;
    CString cStrState;

    DWORD dwOutput;
    BOOL bRet;
    CHAR inBuffer[10];
    CHAR outBuffer[10];
    memset(inBuffer, 0, 10);
    memset(outBuffer, 0, 10);

    dwPID = this->GetDlgItemInt(IDC_STATIC_SELECTED_PID);
    this->GetDlgItemText(ID_BTN_PROTECTORUNPROTECT, cStrText);

    ultoa(dwPID, inBuffer, 10);

    nIndex = QueryItemIndexByPID(dwPID);
    cStrState = this->m_ListCtrlProcess.GetItemText(nIndex, 4);

    if(cStrText.CompareNoCase(_TEXT("Protect")) == 0)
    {
        //保护 dwPID 保护
        bRet = DeviceIoControl(this->m_hDevice, IO_INSERT_PROTECT_PROCESS, inBuffer, 10,
             &outBuffer, 10, &dwOutput, NULL);
        if(bRet)
        {
            this->SetDlgItemText(ID_BTN_PROTECTORUNPROTECT, _TEXT("UnProtect"));
            if(cStrState.CompareNoCase(_TEXT("Hide"))== 0)
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("HideAndProtect"));
            }
            else
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("Protect"));
            }
            MessageBox(_TEXT(" Protect Process Sucess !  "), _TEXT("Information"), MB_OK |
                  MB_ICONINFORMATION);
        }
        else
        {
            MessageBox(_TEXT(" Protect Process Failed !  "), _TEXT("Warning"), MB_OK | MB_ICONERROR);
        }
    }
    else
    {
        //解除 dwPID 保护
        bRet = DeviceIoControl(this->m_hDevice, IO_REMOVE_PROTECT_PROCESS, inBuffer, 10,
             &outBuffer, 10, &dwOutput, NULL);
        if(bRet)
        {
            this->SetDlgItemText(ID_BTN_PROTECTORUNPROTECT, _TEXT("Protect"));
            if(cStrState.CompareNoCase(_TEXT("Hide")) == 0 ||
                 cStrState.CompareNoCase(_TEXT("HideAndProtect")) == 0)
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("Hide"));
            }
            else
            {
                this->m_ListCtrlProcess.SetItemText(nIndex, 4, _TEXT("General"));
            }
            MessageBox(_TEXT(" UnProtect Process Sucess !  "), _TEXT("Information"), MB_OK |
                  MB_ICONINFORMATION);
        }
        else
        {
            MessageBox(_TEXT(" UnProtect Process Failed !  "), _TEXT("Warning"), MB_OK | MB_ICONERROR);
        }
    }
}

5. 小结：

          

介绍这个应用程序呢，还真是不好写，因为感觉整个 Demo 里面却是没有什么好介绍的，

无非就是获取到所有的进程，然后通过一个 ListCtrl 来显示这些数据，

然后用户选择一个进程，单击一下隐藏呢，我就在这个按钮的消息处理函数中和内核程序通过 DeviceIoControl 通信一下，

将这个进程的 PID 传递给内核程序，其他的就都不需要理会了 ~ 所以转来转去的，也没什么好些的，干脆就写到这里得了，

等下将整个 Demo 打个包，直接提供下载，我这里说得口干舌燥也没什么用，感兴趣的自己下载了源码去慢慢玩得了 ~

最后再总结一个 SSDT Hook 的优点，那就是 SSDT Hook 无论你是 Windows XP 还是 Server 或者 Vista 或者 Win7，

你都是可以很好的运行程序的，所以你下载的 Demo 你可以放心的在上面的这些操作系统上运行，当然 64 位的除外，

64 位的操作系统虽然我没有做过测试，但是我估摸着会蓝屏的 ~ 有兴趣的可以去蓝一次 ~

           

下载 Demo Source Code