刚开始学驱动，成功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 的链表结构，居然能影响到它们，太奇怪了。
以下是截图。
后来经过自己改进，实现了隐藏指定进程，任务管理器可以显示其他的进程，冰刃和XueTr就无法获取进程。不过不稳定，任务管理器有时候会报错或者会显示出无名的进程但是PID的值却非常大。没法，不知道真正原因，所以这个问题也没法解决。
以下是成功的时候截的图：
嘿嘿，正因为开始我对链表不太熟悉，所以在一次实验中无意破坏了链表的结构，就发现这个现象。哈哈~~~，当然也不能说这发现能跟冰刃和XueTr对抗了，因为采用SSDD HOOK，所以它们很容易就能发现。至于360，倒也没去测试过，首先加载驱动这一步就得费很多心思了。
以下是SYS完整源码：
main.h： 用于初始化驱动程序
/
// 表示函数运行后 就从内存释放
#define INITCODE code_sge("INIT")
// 表示内存不足时，可以被置换到硬盘
#define PAGECODE code_seg("PAGE")
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <ntddk.h>
#ifdef __cplusplus
}
#endif
/
// 保存符号连接 用于卸载驱动是删除符号连接
UNICODE_STRING SymLinkName;
// 创建设备
NTSTATUS CreateMyDevice(IN PDRIVER_OBJECT pDriverObject, WCHAR MyDeviceName[], WCHAR MySymLinkName[]);
// 派遣函数
NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDevobj,IN PIRP pIrp);
// 卸载驱动
void UnLoadSys(IN PDRIVER_OBJECT pDriverObject);
// 接收到Ring3传递的命令则分析并执行
ULONG CallBack(IN ULONG Ring3_Cmd, IN PIRP pIrp);
/
// 创建设备
#pragma INITCODE // 参数： 驱动对象，所创建的设备名称，所创建的符号连接名称
NTSTATUS CreateMyDevice(IN PDRIVER_OBJECT pDriverObject, WCHAR MyDeviceName[], WCHAR MySymLinkName[])
{
// 创建设备
UNICODE_STRING DeviceName;
RtlInitUnicodeString(&DeviceName, MyDeviceName);
NTSTATUS Status;
PDEVICE_OBJECT pDevObj;
Status = IoCreateDevice(pDriverObject, 0, &DeviceName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
if(!NT_SUCCESS(Status))
{
if(Status == STATUS_INSUFFICIENT_RESOURCES)
{
KdPrint(("资源不足！"));
}
if(Status == STATUS_OBJECT_NAME_EXISTS)
{
KdPrint(("指定对象名存在！"));
}
if(Status == STATUS_OBJECT_NAME_COLLISION)
{
KdPrint(("指定对象名冲突！"));
}
KdPrint(("创建设备失败！"));
return Status;
}
// KdPrint(("设备创建成功！"));
pDevObj->Flags |= DO_BUFFERED_IO;
// 创建符号连接
RtlInitUnicodeString(&SymLinkName, MySymLinkName);
Status = IoCreateSymbolicLink(&SymLinkName, &DeviceName);
if(!NT_SUCCESS(Status)) // 创建符号连接失败
{
KdPrint(("创建符号连接失败！"));
IoDeleteDevice(pDevObj); // 删除创建的设备
return Status;
}
return STATUS_SUCCESS;
}
#pragma PAGECODE
NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDevobj,IN PIRP pIrp)
{
ULONG Info = 0;
// 得到当前栈指针
PIO_STACK_LOCATION Stack;
Stack = IoGetCurrentIrpStackLocation(pIrp);
// 区分IRP
ULONG IRP = 0;
IRP = Stack->MajorFunction;
switch(IRP)
{
case IRP_MJ_DEVICE_CONTROL:
{
//得到输入缓冲区大小
ULONG cbin = Stack->Parameters.DeviceIoControl.InputBufferLength;
//得到输出缓冲区大小
ULONG cbout = Stack->Parameters.DeviceIoControl.OutputBufferLength;
//得到IOCTL码
ULONG Ring3_Cmd = Stack->Parameters.DeviceIoControl.IoControlCode;
// 掉用回调函数，按照指定的信息执行指定动作
Info = CallBack(Ring3_Cmd, pIrp);
}
break;
case IRP_MJ_CREATE:
break;
case IRP_MJ_CLOSE:
break;
case IRP_MJ_READ:
break;
}
// 对相应的IRP进行处理
pIrp->IoStatus.Information = Info;
pIrp->IoStatus.Status = STATUS_SUCCESS; // 返回成功
// 指示完成此IRP
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
SSDT_HOOK.h： SSDT HOOK 架构
// 导出SSDT表
typedef struct _ServiceDescriptorTable
{
PVOID ServiceTableBase; // SSDT基址
PVOID ServiceCounterTable; // 包含SSDT中每个服务被调用次数的计数器，一般由sysenter更新即Ring3转Ring0中断
unsigned int NumberOfServices; // 由ServiceTableBase描述服务的数目
PVOID ParamTableBase; // 包含每个系统服务参数字节数表的基地址-系统服务参数表
}*PServiceDescriptorTable;
extern PServiceDescriptorTable KeServiceDescriptorTable;
#pragma PAGECODE // 要hook的NTAPI服务号，指向原生API，自己的函数地址
int HOOK_API(IN int NtAPI_ID, OUT LONG *Nt_Addr, IN ULONG MyFun)
{
if(NtAPI_ID>295)
{
KdPrint(("NtAPI服务号过大(WIN200：0-295,WINXP：0-283)：%d", NtAPI_ID));
return 1;
}
if(!MyFun)
{
KdPrint(("代替函数地址无效：0x%X", MyFun));
return 2;
}
// 获取NtAPI的在SSDT表的地址
LONG *SSDT_NT_Addr = NULL;
SSDT_NT_Addr = (PLONG)((LONG)(KeServiceDescriptorTable->ServiceTableBase) + NtAPI_ID * 4);
*Nt_Addr = *SSDT_NT_Addr; // 取出真正的NtApi地址
KdPrint(("函数原地址存放在SSDT的地址：0x%X", SSDT_NT_Addr));
KdPrint(("读取该地址获取真正NtAPI地址：0x%X", *SSDT_NT_Addr));
KdPrint(("代替函数地址：0x%X", MyFun));
if((LONG)SSDT_NT_Addr<0x80000000 ||(LONG)SSDT_NT_Addr>0x90000000)
{
KdPrint(("函数原地址存放在SSDT的地址获取失败：0x%X", SSDT_NT_Addr));
return 3;
}
if((LONG)*Nt_Addr<0x80000000 ||(LONG)*Nt_Addr>0x90000000)
{
KdPrint(("原生函数地址获取失败：0x%X", SSDT_NT_Addr));
return 3;
}
// 修改SSDT API地址
__asm
{
cli
mov eax, cr0
and eax, not 10000h
mov cr0, eax // 去掉内存保护
}
*SSDT_NT_Addr = MyFun; // 修改存放在SSDT里面的地址
__asm
{
mov eax, cr0
or eax, 10000h
mov cr0, eax // 恢复内存保护
sti
}
return 0;
}
#pragma PAGECODE // 要hook的NTAPI服务号，指向原生API，自己的函数地址
int UnHOOK_API(IN int NtAPI_ID, WCHAR Real_NtAPI_Name[])
{
if(NtAPI_ID>295)
{
KdPrint(("NtAPI服务号过大(WIN200：0-295,WINXP：0-283)：%d", NtAPI_ID));
return 1;
}
// 获取NtAPI的在SSDT表的地址
LONG *SSDT_NT_Addr = NULL;
SSDT_NT_Addr = (PLONG)((LONG)(KeServiceDescriptorTable->ServiceTableBase) + NtAPI_ID * 4);
// 获取原生NtAPI地址
UNICODE_STRING NtAPI_Name;
ULONG Real_NtAPI_Addr;
RtlInitUnicodeString(&NtAPI_Name, Real_NtAPI_Name);
Real_NtAPI_Addr = (ULONG)MmGetSystemRoutineAddress(&NtAPI_Name);
if(Real_NtAPI_Addr<0x80000000 ||Real_NtAPI_Addr>0x90000000)
{
KdPrint(("获取原生%ws地址失败：0x%X",Real_NtAPI_Name, Real_NtAPI_Addr));
return 2;
}
// 恢复SSDT API地址
__asm
{
cli
mov eax, cr0
and eax, not 10000h
mov cr0, eax // 去掉内存保护
}
*SSDT_NT_Addr = Real_NtAPI_Addr; // 修改存放在SSDT里面的地址
__asm
{
mov eax, cr0
or eax, 10000h
mov cr0, eax // 恢复内存保护
sti
}
return 0;
}
NtQuerySystemInformation_Struct.h： 含义如其名
#ifndef __HOOKFUN_H__
#define __HOOKFUN_H__
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation, // 0 Y N
SystemProcessorInformation, // 1 Y N
SystemPerformanceInformation, // 2 Y N
SystemTimeOfDayInformation, // 3 Y N
SystemNotImplemented1, // 4 Y N
SystemProcessesAndThreadsInformation, // 5 Y N
SystemCallCounts, // 6 Y N
SystemConfigurationInformation, // 7 Y N
SystemProcessorTimes, // 8 Y N
SystemGlobalFlag, // 9 Y Y
SystemNotImplemented2, // 10 Y N
SystemModuleInformation, // 11 Y N
SystemLockInformation, // 12 Y N
SystemNotImplemented3, // 13 Y N
SystemNotImplemented4, // 14 Y N
SystemNotImplemented5, // 15 Y N
SystemHandleInformation, // 16 Y N
SystemObjectInformation, // 17 Y N
SystemPagefileInformation, // 18 Y N
SystemInstructionEmulationCounts, // 19 Y N
SystemInvalidInfoClass1, // 20
SystemCacheInformation, // 21 Y Y
SystemPoolTagInformation, // 22 Y N
SystemProcessorStatistics, // 23 Y N
SystemDpcInformation, // 24 Y Y
SystemNotImplemented6, // 25 Y N
SystemLoadImage, // 26 N Y
SystemUnloadImage, // 27 N Y
SystemTimeAdjustment, // 28 Y Y
SystemNotImplemented7, // 29 Y N
SystemNotImplemented8, // 30 Y N
SystemNotImplemented9, // 31 Y N
SystemCrashDumpInformation, // 32 Y N
SystemExceptionInformation, // 33 Y N
SystemCrashDumpStateInformation, // 34 Y Y/N
SystemKernelDebuggerInformation, // 35 Y N
SystemContextSwitchInformation, // 36 Y N
SystemRegistryQuotaInformation, // 37 Y Y
SystemLoadAndCallImage, // 38 N Y
SystemPrioritySeparation, // 39 N Y
SystemNotImplemented10, // 40 Y N
SystemNotImplemented11, // 41 Y N
SystemInvalidInfoClass2, // 42
SystemInvalidInfoClass3, // 43
SystemTimeZoneInformation, // 44 Y N
SystemLookasideInformation, // 45 Y N
SystemSetTimeSlipEvent, // 46 N Y
SystemCreateSession, // 47 N Y
SystemDeleteSession, // 48 N Y
SystemInvalidInfoClass4, // 49
SystemRangeStartInformation, // 50 Y N
SystemVerifierInformation, // 51 Y Y
SystemAddVerifier, // 52 N Y
SystemSessionProcessesInformation // 53 Y N
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_PROCESSES { // Information Class 5
ULONG NextEntryDelta; // 构成结构列的偏移量
ULONG ThreadCount; // 线程数目
ULONG Reserved1[6];
LARGE_INTEGER CreateTime; // 创建时间
LARGE_INTEGER UserTime; // 用户模式(Ring3)的CPU时间
LARGE_INTEGER KernelTime; // 内核模式(Ring0)的CPU时间
UNICODE_STRING ProcessName; // 进程名称
KPRIORITY BasePriority; // 进程优先权
ULONG ProcessId; // 进程标识符
ULONG InheritedFromProcessID; // 句柄数目
ULONG HandleCount; // 句柄数目
ULONG Reserved2[2];
VM_COUNTERS VmCounters; // 虚拟存储器的结构
IO_COUNTERS IoCounters; // IO计数结构
// SYSTEM_THREADS Therads[1]; // 进程相关线程的结构数组
} SYSTEM_PROCESSES, *PSYSTEM_PROCESSES;
/*
typedef struct _SYSTEM_THREADS
{
LARGE_INTEGER KernelTime; //CPU内核模式使用时间;
LARGE_INTEGER UserTime; //CPU用户模式使用时间;
LARGE_INTEGER CreateTime; //线程创建时间;
ULONG WaitTime; //等待时间;
PVOID StartAddress; //线程开始的虚拟地址;
CLIENT_ID ClientId; //线程标识符;
KPRIORITY Priority; //线程优先级;
KPRIORITY BasePriority; //基本优先级;
ULONG ContextSwitchCount; //环境切换数目;
THREAD_STATE State; //当前状态;
KWAIT_REASON WaitReason; //等待原因;
}SYSTEM_THREADS,*PSYSTEM_THREADS;
typedef struct _VM_COUNTERS
{
ULONG PeakVirtualSize; //虚拟存储峰值大小;
ULONG VirtualSize; //虚拟存储大小;
ULONG PageFaultCount; //页故障数目;
ULONG PeakWorkingSetSize; //工作集峰值大小;
ULONG WorkingSetSize; //工作集大小;
ULONG QuotaPeakPagedPoolUsage; //分页池使用配额峰值;
ULONG QuotaPagedPoolUsage; //分页池使用配额;
ULONG QuotaPeakNonPagedPoolUsage; //非分页池使用配额峰值;
ULONG QuotaNonPagedPoolUsage; //非分页池使用配额;
ULONG PagefileUsage; //页文件使用情况;
ULONG PeakPagefileUsage; //页文件使用峰值;
}VM_COUNTERS,*PVM_COUNTERS;
typedef struct _IO_COUNTERS
{
LARGE_INTEGER ReadOperationCount; //I/O读操作数目;
LARGE_INTEGER WriteOperationCount; //I/O写操作数目;
LARGE_INTEGER OtherOperationCount; //I/O其他操作数目;
LARGE_INTEGER ReadTransferCount; //I/O读数据数目;
LARGE_INTEGER WriteTransferCount; //I/O写数据数目;
LARGE_INTEGER OtherTransferCount; //I/O其他操作数据数目;
}IO_COUNTERS,*PIO_COUNTERS;
typedef struct _SYSTEM_PERFORMANCE_INFORMATION
{
LARGE_INTEGER IdleTime; //CPU空闲时间;
LARGE_INTEGER ReadTransferCount; //I/O读操作数目;
LARGE_INTEGER WriteTransferCount; //I/O写操作数目;
LARGE_INTEGER OtherTransferCount; //I/O其他操作数目;
ULONG ReadOperationCount; //I/O读数据数目;
ULONG WriteOperationCount; //I/O写数据数目;
ULONG OtherOperationCount; //I/O其他操作数据数目;
ULONG AvailablePages; //可获得的页数目;
ULONG TotalCommittedPages; //总共提交页数目;
ULONG TotalCommitLimit; //已提交页数目;
ULONG PeakCommitment; //页提交峰值;
ULONG PageFaults; //页故障数目;
ULONG WriteCopyFaults; //Copy-On-Write故障数目;
ULONG TransitionFaults; //软页故障数目;
ULONG Reserved1;
ULONG DemandZeroFaults; //需求0故障数;
ULONG PagesRead; //读页数目;
ULONG PageReadIos; //读页I/O操作数;
ULONG Reserved2[2];
ULONG PagefilePagesWritten; //已写页文件页数;
ULONG PagefilePageWriteIos; //已写页文件操作数;
ULONG MappedFilePagesWritten; //已写映射文件页数;
ULONG MappedFileWriteIos; //已写映射文件操作数;
ULONG PagedPoolUsage; //分页池使用;
ULONG NonPagedPoolUsage; //非分页池使用;
ULONG PagedPoolAllocs; //分页池分配情况;
ULONG PagedPoolFrees; //分页池释放情况;
ULONG NonPagedPoolAllocs; //非分页池分配情况;
ULONG NonPagedPoolFress; //非分页池释放情况;
ULONG TotalFreeSystemPtes; //系统页表项释放总数;
ULONG SystemCodePage; //操作系统代码页数;
ULONG TotalSystemDriverPages; //可分页驱动程序页数;
ULONG TotalSystemCodePages; //操作系统代码页总数;
ULONG SmallNonPagedLookasideListAllocateHits; //小非分页侧视列表分配次数;
ULONG SmallPagedLookasideListAllocateHits; //小分页侧视列表分配次数;
ULONG Reserved3;
ULONG MmSystemCachePage; //系统缓存页数;
ULONG PagedPoolPage; //分页池页数;
ULONG SystemDriverPage; //可分页驱动页数;
ULONG FastReadNoWait; //异步快速读数目;
ULONG FastReadWait; //同步快速读数目;
ULONG FastReadResourceMiss; //快速读资源冲突数;
ULONG FastReadNotPossible; //快速读失败数;
ULONG FastMdlReadNoWait; //异步MDL快速读数目;
ULONG FastMdlReadWait; //同步MDL快速读数目;
ULONG FastMdlReadResourceMiss; //MDL读资源冲突数;
ULONG FastMdlReadNotPossible; //MDL读失败数;
ULONG MapDataNoWait; //异步映射数据次数;
ULONG MapDataWait; //同步映射数据次数;
ULONG MapDataNoWaitMiss; //异步映射数据冲突次数;
ULONG MapDataWaitMiss; //同步映射数据冲突次数;
ULONG PinMappedDataCount; //牵制映射数据数目;
ULONG PinReadNoWait; //牵制异步读数目;
ULONG PinReadWait; //牵制同步读数目;
ULONG PinReadNoWaitMiss; //牵制异步读冲突数目;
ULONG PinReadWaitMiss; //牵制同步读冲突数目;
ULONG CopyReadNoWait; //异步拷贝读次数;
ULONG CopyReadWait; //同步拷贝读次数;
ULONG CopyReadNoWaitMiss; //异步拷贝读故障次数;
ULONG CopyReadWaitMiss; //同步拷贝读故障次数;
ULONG MdlReadNoWait; //异步MDL读次数;
ULONG MdlReadWait; //同步MDL读次数;
ULONG MdlReadNoWaitMiss; //异步MDL读故障次数;
ULONG MdlReadWaitMiss; //同步MDL读故障次数;
ULONG ReadAheadIos; //向前读操作数目;
ULONG LazyWriteIos; //LAZY写操作数目;
ULONG LazyWritePages; //LAZY写页文件数目;
ULONG DataFlushes; //缓存刷新次数;
ULONG DataPages; //缓存刷新页数;
ULONG ContextSwitches; //环境切换数目;
ULONG FirstLevelTbFills; //第一层缓冲区填充次数;
ULONG SecondLevelTbFills; //第二层缓冲区填充次数;
ULONG SystemCall; //系统调用次数;
}SYSTEM_PERFORMANCE_INFORMATION,*PSYSTEM_PERFORMANCE_INFORMATION;
typedef struct __SYSTEM_PROCESSOR_TIMES
{
LARGE_INTEGER IdleTime; //空闲时间;
LARGE_INTEGER KernelTime; //内核模式时间;
LARGE_INTEGER UserTime; //用户模式时间;
LARGE_INTEGER DpcTime; //延迟过程调用时间;
LARGE_INTEGER InterruptTime; //中断时间;
ULONG InterruptCount; //中断次数;
}SYSTEM_PROCESSOR_TIMES,*PSYSTEM_PROCESSOR_TIMES;
typedef struct _SYSTEM_PAGEFILE_INFORMATION
{
ULONG NetxEntryOffset; //下一个结构的偏移量;
ULONG CurrentSize; //当前页文件大小;
ULONG TotalUsed; //当前使用的页文件数;
ULONG PeakUsed; //当前使用的页文件峰值数;
UNICODE_STRING FileName; //页文件的文件名称;
}SYSTEM_PAGEFILE_INFORMATION,*PSYSTEM_PAGEFILE_INFORMATION;
typedef struct _SYSTEM_CACHE_INFORMATION
{
ULONG SystemCacheWsSize; //高速缓存大小;
ULONG SystemCacheWsPeakSize; //高速缓存峰值大小;
ULONG SystemCacheWsFaults; //高速缓存页故障数目;
ULONG SystemCacheWsMinimum; //高速缓存最小页大小;
ULONG SystemCacheWsMaximum; //高速缓存最大页大小;
ULONG TransitionSharedPages; //共享页数目;
ULONG TransitionSharedPagesPeak; //共享页峰值数目;
ULONG Reserved[2];
}SYSTEM_CACHE_INFORMATION,*PSYSTEM_CACHE_INFORMATION;
typedef NTSTATUS (* PZW_QUERY_SYSTEMINFORMATION)(
IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
OUT PVOID SystemInformation,
IN ULONG SystemInformationLength,
OUT PULONG ReturnLength
);
NTSTATUS NTAPI NewZwQuerySystemInformation(
IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
OUT PVOID SystemInformation,
IN ULONG SystemInformationLength,
OUT PULONG ReturnLength
);
*/
// =================================================================
// BASIC TYPES
// =================================================================
typedef unsigned char BYTE, *PBYTE, **PPBYTE;
typedef unsigned short WORD, *PWORD, **PPWORD;
typedef unsigned long DWORD, *PDWORD, **PPDWORD;
typedef unsigned __int64 QWORD, *PQWORD, **PPQWORD;
typedef int BOOL, *PBOOL, **PPBOOL;
typedef void **PPVOID;
#endif //;
HOOK_API.h： HOOK API 原型定义与替代函数的实现
#include "NtQuerySystemInformation_Struct.h" // NtQuerySystemInformation 函数需要的结构
// 定义NtQuerySystemInformation的原型
extern "C" typedef NTSTATUS __stdcall NTQUERYSYSTEMINFORMATION(
// 类型信息，大概提供50余种信息探测或设置
__in SYSTEM_INFORMATION_CLASS SystemInformationClass,
// 为我们提供需要获得的信息，或是我们需要设置的系统信息
__out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
// SystemInformation 长度，根据探测的信息类型决定
__in ULONG SystemInformationLength,
// 系统返回需要的长度，通常可以设置为NULL
__out_opt PULONG ReturnLength
);
NTQUERYSYSTEMINFORMATION *RealNtQuerySystemInformation;
// 定义NtOpenProcess的原型
extern "C" typedef NTSTATUS __stdcall NTOPENPROCESS
(
OUT PHANDLE ProcessHandle,
IN ACCESS_MASK AccessMask,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PCLIENT_ID ClientId
);
NTOPENPROCESS *RealNtOpenProcess; // 定义函数指针 用来指向真正的NtOpenProcess函数地址
///
ULONG _ProcessPID_Len = 0;
ULONG _ProcessPID[512] = {0};
BOOL _L_HOOK = FALSE;
#pragma PAGECODE
BOOL ScanPID(ULONG PID)
{
for(ULONG i=0; i<_ProcessPID_Len; i++)
{
if(PID == _ProcessPID[i])
{
return TRUE;
}
}
return FALSE;
}
// 定义自己的NtOpenProcess 用于检查其传递过来的参数
#pragma PAGECODE
extern "C" NTSTATUS __stdcall MyNtOpenProcess(
OUT PHANDLE ProcessHandle,
IN ACCESS_MASK AccessMask,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PCLIENT_ID ClientId
)
{
PEPROCESS EP;
NTSTATUS rc;
HANDLE PID;
if( (ClientId != NULL) )
{
PID = ClientId->UniqueProcess;
// 如果是被保护的PID，则拒绝访问，并将句柄设置为空
// if(PID == (HANDLE)_ProcessPID)
if(ScanPID((ULONG)PID))
{
//调试输出 类似C语言的 Printf
ProcessHandle = NULL; //这个是关键
rc = STATUS_ACCESS_DENIED; //这个返回值
//PsLookupProcessByProcessId((ULONG)PID,&EP);
EP=PsGetCurrentProcess();
KdPrint(("【%s】进程想结束要保护的进程 \n",(PTSTR)((ULONG)EP+0x174)));
}
else
rc = RealNtOpenProcess(ProcessHandle, AccessMask, ObjectAttributes, ClientId);
}
return rc;
}
#pragma PAGECODE
extern "C" NTSTATUS __stdcall MyNtQuerySystemInformation(
__in SYSTEM_INFORMATION_CLASS SystemInformationClass, // 获取信息的类型
__out_bcount_opt(SystemInformationLength) PVOID SystemInformation, // 输出信息的buf地址
__in ULONG SystemInformationLength, // buf的空间大小
__out_opt PULONG ReturnLength) // 实际写入的大小
{
SYSTEM_PROCESSES *lpspi = 0,*lpspia = 0;
lpspi = (SYSTEM_PROCESSES*)SystemInformation;
// UNICODE_STRING aProcessName;
// RtlInitUnicodeString(&aProcessName, L"Explorer.exe");
NTSTATUS a = RealNtQuerySystemInformation(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
if(SystemInformationClass != 5 || !NT_SUCCESS(a))
{
return a;
}
/*
// 这个是隐藏所有的进程 但是冰刃、XueTr能检测出来
SystemInformation = NULL;
return STATUS_ACCESS_DENIED;
*/
if(_L_HOOK)
{
// 这个也是隐藏所有的进程 最新版的XueTr无法检测出来并且也无法显示正确的进程数等信息 冰刃查看进程会报错
int i = 0;
while(lpspi->NextEntryDelta != 0)
{
i++;
if(i==2)
{
lpspi->NextEntryDelta = 5;
lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
continue;
}
lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
}
return a;
}
// 这个是隐藏指定进程 对冰刃、XueTr无效
// 如果节点信息有效
while(lpspi)
{
// 判断该节点信息是否是我们要保护的进程信息
// if(RtlEqualUnicodeString(&aProcessName,&lpspi->ProcessName,1))
// if(lpspi->ProcessId == _ProcessPID)
if(ScanPID(lpspi->ProcessId))
{
// 如果这条要保护的进程信息是在头节点
if(lpspia == 0)
{
// 有头结点也有下一个节点 即不是唯一的节点
if(lpspi->NextEntryDelta != 0)
{
// 直接将输出缓冲区的头指针指向下一个节点 忽略头结点的信息
SystemInformation = (PVOID)((DWORD)SystemInformation + lpspi->NextEntryDelta);
// 指针下移
lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
continue;
}
else
{
// 如果只有一个节点且是要隐藏的节点 则将输出缓冲器置空
SystemInformation = NULL;
}
}
else // 如果是中间节点 则表示该进程信息是在中间或尾部
{
// 如果还有下一个节点 说明该进程信息是在中间部分
if(lpspi->NextEntryDelta != 0)
{
// 将该进程信息的上一个指针结构偏移量指向下一个节点 这样就可以忽略这个进程的指针信息
lpspia->NextEntryDelta += lpspi->NextEntryDelta;
// 指针移向下一个指针
lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
continue;
}
//尾部结点
else
{
// 如果该进程信息是在尾部 则直接将进程信息的上一个指针结构偏移量指向空，这样整个链表就忽略了这个进程信息链表
lpspia->NextEntryDelta = 0;
}
}
}
// 保存这个与我们要保护进程无关的信息指针~~
lpspia = lpspi;
// 如果还有下一个节点
if(lpspi->NextEntryDelta != 0)
{
// 移动到下一个节点 进行判断该节点的信息是不要移除的信息
lpspi = (SYSTEM_PROCESSES*)((PUCHAR)lpspi+lpspi->NextEntryDelta);
}
else
{
// 如果没有则置空 结束循环
lpspi = NULL;
// lpspia->NextEntryDelta = 5; //加上这个就能隐藏指定进程并且冰刃查看进程会报错 XT看不到所有的进程 但是能显示出正确的进程数 任务管理器可能也会报错
}
}
return a;
}
main.cpp： 主函数
#include <main.h>
// 定义Rin3 传递下来的指令 因与Ring3定义相同 值必须 >=0x800
#define HOOK CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED,FILE_ANY_ACCESS)
#define L_HOOK CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED,FILE_ANY_ACCESS)
#define UnHOOK CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED,FILE_ANY_ACCESS)
extern "C"
{
#include <SSDT_HOOK.h> // SSDT HOOK 框架
#include <HOOK_API.h> // 要HOOK的函数原型及替代函数
}
// 相当于应用程序的main()函数 这是驱动人口函数，凡是驱动被加载均会从这里开始执行
#pragma INITCODE
extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING B)
{
// 注册派遣函数
pDriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchRoutine;
pDriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchRoutine;
pDriverObject->MajorFunction[IRP_MJ_READ] = DispatchRoutine;
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchRoutine;
// 设置卸载驱动时要执行的代码做善后，不设置则无法卸载
pDriverObject->DriverUnload = UnLoadSys;
// 创建设备 和 符号连接
CreateMyDevice(pDriverObject, L"\\Device\\L_Device", L"\\??\\LoveMengx_SSDTHOOK_Driver");
KdPrint(("【加载】驱动完毕。"));
///
LONG NtAPI_Addrs = 0;
if(!HOOK_API(122, &NtAPI_Addrs, (ULONG)MyNtOpenProcess))
{
KdPrint(("NtOpenProcess HOOK 成功~~", NtAPI_Addrs));
RealNtOpenProcess = (NTOPENPROCESS*)NtAPI_Addrs;
}
else
{
KdPrint(("HOOK 失败~~", NtAPI_Addrs));
}
if(!HOOK_API(173, &NtAPI_Addrs, (ULONG)MyNtQuerySystemInformation))
{
KdPrint(("NtQuerySystemInformation HOOK 成功~~", NtAPI_Addrs));
RealNtQuerySystemInformation = (NTQUERYSYSTEMINFORMATION*)NtAPI_Addrs;
}
else
{
KdPrint(("HOOK 失败~~", NtAPI_Addrs));
}
return 1;
}
// 卸载驱动
#pragma PAGECODE
void UnLoadSys(IN PDRIVER_OBJECT pDriverObject)
{
// 删除设备
PDEVICE_OBJECT pDev;
pDev = pDriverObject->DeviceObject;
IoDeleteDevice(pDev);
// 删除符号连接
IoDeleteSymbolicLink(&SymLinkName);
KdPrint(("【卸载】驱动完毕。"));
KdPrint(("-----------------------------------"));
}
BOOL HOOKAPI(ULONG Process_PID)
{
if(Process_PID >65536)
{
return FALSE;
}
if(!ScanPID(Process_PID)) // 检查是否存在
{
_ProcessPID[_ProcessPID_Len] = Process_PID;
_ProcessPID_Len++;
}
return TRUE;
}
BOOL UnHOOKAPI()
{
BOOL Retu = FALSE;
_ProcessPID_Len = 0;
if(!UnHOOK_API(122, L"NtOpenProcess"))
{
Retu = TRUE;
KdPrint(("NtOpenProcess UnHOOK 成功~~"));
}
else
{
Retu = FALSE;
KdPrint(("NtOpenProcess UnHOOK 失败~~"));
}
if(!UnHOOK_API(173, L"NtQuerySystemInformation"))
{
Retu = TRUE;
KdPrint(("NtQuerySystemInformation UnHOOK 成功~~"));
}
else
{
Retu = FALSE;
KdPrint(("NtQuerySystemInformation UnHOOK 失败~~"));
}
return Retu;
}
int my_atoi(const char* p)
{
bool neg_flag = false;// 符号标记
int res = 0;// 结果
if(p[0] == '+' || p[0] == '-')
neg_flag = (*p++ != '+');
while(isdigit(*p)) res = res*10 + (*p++ - '0');
return neg_flag ?0 -res : res;
}
ULONG CallBack(IN ULONG Ring3_Cmd, IN PIRP pIrp)
{
// 获取应用层传递下来的数据
char* InputBuffer = (char*)pIrp->AssociatedIrp.SystemBuffer;
char* OutputBuffer = (char*)pIrp->AssociatedIrp.SystemBuffer;
char Tmp[100] = {0};
ULONG Info = 0;
// 分析指令
switch(Ring3_Cmd)
{
case HOOK:
{
strcpy(Tmp, InputBuffer);
KdPrint(("用户传下来的数据 %s %d", Tmp,my_atoi(Tmp) ));
if(HOOKAPI(my_atoi(Tmp)))
{
strcpy(Tmp, "ADD 完毕~");
}
else
{
strcpy(Tmp, "ADD 失败，PID超过有效范围~");
}
break;
}
case UnHOOK:
{
if(UnHOOKAPI())
{
strcpy(Tmp, "UnHOOK OK");
}
else
{
strcpy(Tmp, "UnHOOK Error");
}
break;
}
case L_HOOK: // 终极隐藏
_L_HOOK = TRUE;
strcpy(Tmp, "已经启动终极隐藏");
break;
}
strcpy(OutputBuffer, Tmp);
Info = strlen(Tmp);
return Info;
}
Exe完整程序源码
#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"
#include<winioctl.h> //CTL_CODE
#define UHook CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED,FILE_ANY_ACCESS)
BOOL LoadNTDriver(char* lpDriverName,char* lpDriverPathName)
{
BOOL bRet = FALSE;
SC_HANDLE hServiceMgr=NULL;//SCM管理器的句柄
SC_HANDLE hServiceDDK=NULL;//NT驱动程序的服务句柄
//打开服务控制管理器
hServiceMgr = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if( hServiceMgr == NULL )
{
//OpenSCManager失败
//TRACE( "OpenSCManager() Faild %d ! \n", GetLastError() );
bRet = FALSE;
goto BExit;
}
//创建驱动所对应的服务
hServiceDDK = CreateService( hServiceMgr,
lpDriverName, //驱动程序的在注册表中的名字
lpDriverName, // 注册表驱动程序的 DisplayName 值
SERVICE_ALL_ACCESS, // 加载驱动程序的访问权限
SERVICE_KERNEL_DRIVER,// 表示加载的服务是驱动程序
SERVICE_DEMAND_START, // 注册表驱动程序的 Start 值
SERVICE_ERROR_IGNORE, // 注册表驱动程序的 ErrorControl 值
lpDriverPathName, // 注册表驱动程序的 ImagePath 值
NULL,
NULL,
NULL,
NULL,
NULL);
DWORD dwRtn;
//判断服务是否失败
if( hServiceDDK == NULL )
{
dwRtn = GetLastError();
if( dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_EXISTS )
{
//由于其他原因创建服务失败
//TRACE( "CrateService() 失败 %d ! \n", dwRtn );
bRet = FALSE;
goto BExit;
}
else
{
//服务创建失败，是由于服务已经创立过
//TRACE( "CrateService() 服务创建失败，是由于服务已经创立过 ERROR is ERROR_IO_PENDING or ERROR_SERVICE_EXISTS! \n" );
}
// 驱动程序已经加载，只需要打开
hServiceDDK = OpenService( hServiceMgr, lpDriverName, SERVICE_ALL_ACCESS );
if( hServiceDDK == NULL )
{
//如果打开服务也失败，则意味错误
dwRtn = GetLastError();
//TRACE( "OpenService() 失败 %d ! \n", dwRtn );
bRet = FALSE;
goto BExit;
}
}
//开启此项服务
bRet= StartService( hServiceDDK, NULL, NULL );
if( !bRet ) //开启服务不成功
{
//TRACE( "StartService() 失败 服务可能已经开启%d ! \n", dwRtn );
bRet = FALSE;
goto BExit;
}
bRet = TRUE;
//离开前关闭句柄
BExit:
if(hServiceDDK)
{
CloseServiceHandle(hServiceDDK);
}
if(hServiceMgr)
{
CloseServiceHandle(hServiceMgr);
}
return bRet;
}
//卸载驱动程序
BOOL UnLoadSys( char * szSvrName )
{
//一定义所用到的变量
BOOL bRet = FALSE;
SC_HANDLE hSCM=NULL;//SCM管理器的句柄,用来存放OpenSCManager的返回值
SC_HANDLE hService=NULL;//NT驱动程序的服务句柄，用来存放OpenService的返回值
SERVICE_STATUS SvrSta;
//二打开SCM管理器
hSCM = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if( hSCM == NULL )
{
bRet = FALSE;
goto BeforeLeave;
}
//三打开驱动所对应的服务
hService = OpenService( hSCM, szSvrName, SERVICE_ALL_ACCESS );
if( hService == NULL )
{
bRet = FALSE;
goto BeforeLeave;
}
//四停止驱动程序，如果停止失败，只有重新启动才能，再动态加载。
if( !ControlService( hService, SERVICE_CONTROL_STOP , &SvrSta ) )
{
bRet = FALSE;
goto BeforeLeave;
}
//五动态卸载驱动服务。
if( !DeleteService( hService ) ) //TRUE//FALSE
{
bRet = FALSE;
goto BeforeLeave;
}
bRet = TRUE;
//六 离开前关闭打开的句柄
BeforeLeave:
if(hService>0)
{
CloseServiceHandle(hService);
}
if(hSCM>0)
{
CloseServiceHandle(hSCM);
}
return bRet;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
char FilaPath[MAX_PATH] = {0};
char FileName[MAX_PATH] = "UnHook.sys";
if(!strstr(lpCmdLine, "-") || !strstr(lpCmdLine,"<") || !strlen(lpCmdLine))
{
puts("参数格式：指定Nt内核函数的SSDT序列号-Nt内核函数命<");
puts("例如：122-NtOpenProcess<");
return 1;
}
GetModuleFileName(NULL,FilaPath,MAX_PATH);
*(strrchr(FilaPath,'\\')+1) = '\0';
strcat(FilaPath, FileName);
if (!LoadNTDriver(FileName, FilaPath))
{
puts("加载驱动失败！...");
return 1;
}
Sleep(100);
HANDLE hDevice = NULL;
hDevice = CreateFile("\\\\.\\LoveMengx_UnSSDTHOOK_Driver",
GENERIC_READ|GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == hDevice)
{
puts("打开驱动失败...");
return 1;
}
char Buff[1024] = {0};
char Tmp[1024]= {0};
ULONG dwWrite;
DeviceIoControl(hDevice, UHook, Buff, strlen(Buff), Tmp, 1024, &dwWrite, NULL);
if (UnLoadSys(FileName))
{
puts("卸载驱动失败...");
return 1;
}
puts("完成操作~~");
return 0;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
