驱动开发：内核解锁与强删文件

在某些时候我们的系统中会出现一些无法被正常删除的文件，如果想要强制删除则需要在驱动层面对其进行解锁后才可删掉，而所谓的解锁其实就是释放掉文件描述符（句柄表）占用，文件解锁的核心原理是通过调用ObSetHandleAttributes函数将特定句柄设置为可关闭状态，然后在调用ZwClose将其文件关闭，强制删除则是通过ObReferenceObjectByHandle在对象上提供相应的权限后直接调用ZwDeleteFile将其删除，虽此类代码较为普遍，但作为揭秘ARK工具来说也必须要将其分析并讲解一下。

首先封装lyshark.h通用头文件，并定义好我们所需要的结构体，以及特定未导出函数的声明，此处的定义部分是微软官方的规范，如果不懂结构具体含义可自行去微软官方查阅参考资料。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include <ntddk.h>
8. // -------------------------------------------------------
9. // 引用微软结构
10. // -------------------------------------------------------
11. // 结构体定义
12. typedef struct _HANDLE_INFO
13. {
14.         UCHAR ObjectTypeIndex;
15.         UCHAR HandleAttributes;
16.         USHORT  HandleValue;
17.         ULONG GrantedAccess;
18.         ULONG64 Object;
19.         UCHAR Name[256];
20. } HANDLE_INFO, *PHANDLE_INFO;
22. HANDLE_INFO HandleInfo[1024];
24. typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO
25. {
26.         USHORT  UniqueProcessId;
27.         USHORT  CreatorBackTraceIndex;
28.         UCHAR ObjectTypeIndex;
29.         UCHAR HandleAttributes;
30.         USHORT  HandleValue;
31.         PVOID Object;
32.         ULONG GrantedAccess;
33. } SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO;
35. typedef struct _SYSTEM_HANDLE_INFORMATION
36. {
37.         ULONG64 NumberOfHandles;
38.         SYSTEM_HANDLE_TABLE_ENTRY_INFO Handles[1];
39. } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
41. typedef enum _OBJECT_INFORMATION_CLASS
42. {
43.         ObjectBasicInformation,
44.         ObjectNameInformation,
45.         ObjectTypeInformation,
46.         ObjectAllInformation,
47.         ObjectDataInformation
48. } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
50. typedef struct _OBJECT_BASIC_INFORMATION
51. {
52.         ULONG                   Attributes;
53.         ACCESS_MASK             DesiredAccess;
54.         ULONG                   HandleCount;
55.         ULONG                   ReferenceCount;
56.         ULONG                   PagedPoolUsage;
57.         ULONG                   NonPagedPoolUsage;
58.         ULONG                   Reserved[3];
59.         ULONG                   NameInformationLength;
60.         ULONG                   TypeInformationLength;
61.         ULONG                   SecurityDescriptorLength;
62.         LARGE_INTEGER           CreationTime;
63. } OBJECT_BASIC_INFORMATION, *POBJECT_BASIC_INFORMATION;
65. typedef struct _OBJECT_TYPE_INFORMATION
66. {
67.         UNICODE_STRING          TypeName;
68.         ULONG                   TotalNumberOfHandles;
69.         ULONG                   TotalNumberOfObjects;
70.         WCHAR                   Unused1[8];
71.         ULONG                   HighWaterNumberOfHandles;
72.         ULONG                   HighWaterNumberOfObjects;
73.         WCHAR                   Unused2[8];
74.         ACCESS_MASK             InvalidAttributes;
75.         GENERIC_MAPPING         GenericMapping;
76.         ACCESS_MASK             ValidAttributes;
77.         BOOLEAN                 SecurityRequired;
78.         BOOLEAN                 MaintainHandleCount;
79.         USHORT                  MaintainTypeList;
80.         POOL_TYPE               PoolType;
81.         ULONG                   DefaultPagedPoolCharge;
82.         ULONG                   DefaultNonPagedPoolCharge;
83. } OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
85. typedef struct _KAPC_STATE
86. {
87.         LIST_ENTRY ApcListHead[2];
88.         PVOID Process;
89.         BOOLEAN KernelApcInProgress;
90.         BOOLEAN KernelApcPending;
91.         BOOLEAN UserApcPending;
92. }KAPC_STATE, *PKAPC_STATE;
94. typedef struct _OBJECT_HANDLE_FLAG_INFORMATION
95. {
96.         BOOLEAN Inherit;
97.         BOOLEAN ProtectFromClose;
98. }OBJECT_HANDLE_FLAG_INFORMATION, *POBJECT_HANDLE_FLAG_INFORMATION;
100. typedef struct _LDR_DATA_TABLE_ENTRY64
101. {
102.   LIST_ENTRY64 InLoadOrderLinks;
103.   LIST_ENTRY64 InMemoryOrderLinks;
104.   LIST_ENTRY64 InInitializationOrderLinks;
105.   ULONG64 DllBase;
106.   ULONG64 EntryPoint;
107.   ULONG64 SizeOfImage;
108.   UNICODE_STRING FullDllName;
109.   UNICODE_STRING BaseDllName;
110.   ULONG Flags;
111.   USHORT LoadCount;
112.   USHORT TlsIndex;
113.   LIST_ENTRY64 HashLinks;
114.   ULONG64 SectionPointer;
115.   ULONG64 CheckSum;
116.   ULONG64 TimeDateStamp;
117.   ULONG64 LoadedImports;
118.   ULONG64 EntryPointActivationContext;
119.   ULONG64 PatchInformation;
120.   LIST_ENTRY64 ForwarderLinks;
121.   LIST_ENTRY64 ServiceTagLinks;
122.   LIST_ENTRY64 StaticLinks;
123.   ULONG64 ContextInformation;
124.   ULONG64 OriginalBase;
125.   LARGE_INTEGER LoadTime;
126. } LDR_DATA_TABLE_ENTRY64, *PLDR_DATA_TABLE_ENTRY64;
128. // -------------------------------------------------------
129. // 导出函数定义
130. // -------------------------------------------------------
132. NTKERNELAPI NTSTATUS ObSetHandleAttributes
133. (
134.         HANDLE Handle,
135.         POBJECT_HANDLE_FLAG_INFORMATION HandleFlags,
136.         KPROCESSOR_MODE PreviousMode
137. );
139. NTKERNELAPI VOID KeStackAttachProcess
140. (
141.         PEPROCESS PROCESS,
142.         PKAPC_STATE ApcState
143. );
145. NTKERNELAPI VOID KeUnstackDetachProcess
146. (
147.         PKAPC_STATE ApcState
148. );
150. NTKERNELAPI NTSTATUS PsLookupProcessByProcessId
151. (
152.         IN HANDLE ProcessId,
153.         OUT PEPROCESS *Process
154. );
156. NTSYSAPI NTSTATUS NTAPI ZwQueryObject
157. (
158.         HANDLE  Handle,
159.         ULONG ObjectInformationClass,
160.         PVOID ObjectInformation,
161.         ULONG ObjectInformationLength,
162.         PULONG  ReturnLength OPTIONAL
163. );
165. NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation
166. (
167.         ULONG SystemInformationClass,
168.         PVOID SystemInformation,
169.         ULONG SystemInformationLength,
170.         PULONG  ReturnLength
171. );
173. NTSYSAPI NTSTATUS NTAPI ZwDuplicateObject
174. (
175.         HANDLE    SourceProcessHandle,
176.         HANDLE    SourceHandle,
177.         HANDLE    TargetProcessHandle OPTIONAL,
178.         PHANDLE   TargetHandle OPTIONAL,
179.         ACCESS_MASK DesiredAccess,
180.         ULONG   HandleAttributes,
181.         ULONG   Options
182. );
184. NTSYSAPI NTSTATUS NTAPI ZwOpenProcess
185. (
186.         PHANDLE       ProcessHandle,
187.         ACCESS_MASK     AccessMask,
188.         POBJECT_ATTRIBUTES  ObjectAttributes,
189.         PCLIENT_ID      ClientId
190. );
192. #define STATUS_INFO_LENGTH_MISMATCH 0xC0000004

复制代码

接下来将具体分析如何解锁指定文件的句柄表，强制解锁文件句柄表，大体步骤如下所示。

• 1.首先调用ZwQuerySystemInformation的16功能号SystemHandleInformation来枚举系统里的句柄。
  
• 2.通过ZwOpenProcess()打开拥有此句柄的进程，通过ZwDuplicateObject创建一个新的句柄，并把此句柄复制到自己的进程内。
  
• 3.通过调用ZwQueryObject并传入ObjectNameInformation查询到句柄的名称，并将其放入到pNameInfo变量内。
  
• 4.循环这个过程并在每次循环中通过strstr()判断是否是我们需要关闭的文件名，如果是则调用ForceCloseHandle强制解除占用。
  
• 5.此时会进入到ForceCloseHandle流程内，通过KeStackAttachProcess附加到进程内，并调用ObSetHandleAttributes将句柄设置为可关闭状态。
  
• 6.最后调用ZwClose关闭句柄占用，并KeUnstackDetachProcess脱离该进程。
  

实现代码流程非常容易理解，此类功能也没有其他别的写法了一般也就这种，但是还是需要注意这些内置函数的参数传递，这其中ZwQuerySystemInformation()一般用于查询系统进程等信息居多，但通过对SystemInformationClass变量传入不同的参数可实现对不同结构的枚举工作，具体的定义可去查阅微软定义规范；

1. NTSTATUS WINAPI ZwQuerySystemInformation(
2.   _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,      // 传入不同参数则输出不同内容
3.   _Inout_   PVOID                    SystemInformation,           // 输出数据
4.   _In_      ULONG                    SystemInformationLength,     // 长度
5.   _Out_opt_ PULONG                   ReturnLength                 // 返回长度
6. );

复制代码

函数ZwDuplicateObject()，该函数例程用于创建一个句柄，该句柄是指定源句柄的副本，此函数的具体声明部分如下；

1. NTSYSAPI NTSTATUS ZwDuplicateObject(
2.   [in]            HANDLE      SourceProcessHandle,    // 要复制的句柄的源进程的句柄。
3.   [in]            HANDLE      SourceHandle,           // 要复制的句柄。
4.   [in, optional]  HANDLE      TargetProcessHandle,    // 要接收新句柄的目标进程的句柄。
5.   [out, optional] PHANDLE     TargetHandle,           // 指向例程写入新重复句柄的 HANDLE 变量的指针。
6.   [in]            ACCESS_MASK DesiredAccess,          // 一个ACCESS_MASK值，该值指定新句柄的所需访问。
7.   [in]            ULONG       HandleAttributes,       // 一个 ULONG，指定新句柄的所需属性。
8.   [in]            ULONG       Options                 // 一组标志，用于控制重复操作的行为。
9. );

复制代码

函数ZwQueryObject()其可以返回特定的一个对象参数，此函数尤为注意第二个参数，当下我们传入的是ObjectNameInformation则代表需要取出对象名称，而如果使用ObjectTypeInformation则是返回对象类型，该函数微软定义如下所示；

1. NTSYSAPI NTSTATUS ZwQueryObject(
2.   [in, optional]  HANDLE                   Handle,                        // 要获取相关信息的对象句柄。
3.   [in]            OBJECT_INFORMATION_CLASS ObjectInformationClass,        // 该值确定 ObjectInformation 缓冲区中返回的信息的类型。
4.   [out, optional] PVOID                    ObjectInformation,             // 指向接收请求信息的调用方分配缓冲区的指针。
5.   [in]            ULONG                    ObjectInformationLength,       // 指定 ObjectInformation 缓冲区的大小（以字节为单位）。
6.   [out, optional] PULONG                   ReturnLength                   // 指向接收所请求密钥信息的大小（以字节为单位）的变量的指针。
7. );

复制代码

而对于ForceCloseHandle函数中，需要注意的只有一个ObSetHandleAttributes该函数微软并没有格式化文档，但是也并不影响我们使用它，如下最需要注意的是PreviousMode变量，该变量如果传入KernelMode则是内核模式，传入UserMode则代表用户模式，为了权限最大化此处需要写入KernelMode模式；

1. NTSYSAPI NTSTATUS ObSetHandleAttributes(
2.   HANDLE Handle,                                        // 传入文件句柄
3.   POBJECT_HANDLE_FLAG_INFORMATION HandleFlags,          // OBJECT_HANDLE_FLAG_INFORMATION标志
4.   KPROCESSOR_MODE PreviousMode                          // 指定运行级别KernelMode
5. )

复制代码

实现文件解锁，该驱动程序不仅可用于解锁应用层程序，也可用于解锁驱动，如下代码中我们解锁pagefile.sys程序的句柄占用；

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. // 根据PID得到EProcess
9. PEPROCESS LookupProcess(HANDLE Pid)
10. {
11.         PEPROCESS eprocess = NULL;
12.         if (NT_SUCCESS(PsLookupProcessByProcessId(Pid, &eprocess)))
13.                 return eprocess;
14.         else
15.                 return NULL;
16. }
18. // 将uncode转为char*
19. VOID UnicodeStringToCharArray(PUNICODE_STRING dst, char *src)
20. {
21.         ANSI_STRING string;
22.         if (dst->Length > 260)
23.         {
24.                 return;
25.         }
27.         RtlUnicodeStringToAnsiString(&string, dst, TRUE);
28.         strcpy(src, string.Buffer);
29.         RtlFreeAnsiString(&string);
30. }
32. // 强制关闭句柄
33. VOID ForceCloseHandle(PEPROCESS Process, ULONG64 HandleValue)
34. {
35.         HANDLE h;
36.         KAPC_STATE ks;
37.         OBJECT_HANDLE_FLAG_INFORMATION ohfi;
39.         if (Process == NULL)
40.         {
41.                 return;
42.         }
43.         // 验证进程是否可读写
44.         if (!MmIsAddressValid(Process))
45.         {
46.                 return;
47.         }
49.         // 附加到进程
50.         KeStackAttachProcess(Process, &ks);
51.         h = (HANDLE)HandleValue;
52.         ohfi.Inherit = 0;
53.         ohfi.ProtectFromClose = 0;
55.         // 设置句柄为可关闭状态
56.         ObSetHandleAttributes(h, &ohfi, KernelMode);
58.         // 关闭句柄
59.         ZwClose(h);
61.         // 脱离附加进程
62.         KeUnstackDetachProcess(&ks);
64.         DbgPrint("EP = [ %d ] | HandleValue = [ %d ] 进程句柄已被关闭 \n",Process,HandleValue);
65. }
67. VOID UnDriver(PDRIVER_OBJECT driver)
68. {
69.         DbgPrint("驱动卸载成功 \n");
70. }
72. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
73. {
74.         DbgPrint("Hello LyShark.com \n");
76.         PVOID Buffer;
77.         ULONG BufferSize = 0x20000, rtl = 0;
78.         NTSTATUS Status, qost = 0;
79.         NTSTATUS ns = STATUS_SUCCESS;
80.         ULONG64 i = 0;
81.         ULONG64 qwHandleCount;
83.         SYSTEM_HANDLE_TABLE_ENTRY_INFO *p;
84.         OBJECT_BASIC_INFORMATION BasicInfo;
85.         POBJECT_NAME_INFORMATION pNameInfo;
87.         ULONG ulProcessID;
88.         HANDLE hProcess;
89.         HANDLE hHandle;
90.         HANDLE hDupObj;
91.         CLIENT_ID cid;
92.         OBJECT_ATTRIBUTES oa;
93.         CHAR szFile[260] = { 0 };
95.         Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, "LyShark");
96.         memset(Buffer, 0, BufferSize);
98.         // SystemHandleInformation
99.         Status = ZwQuerySystemInformation(16, Buffer, BufferSize, 0);
100.         while (Status == STATUS_INFO_LENGTH_MISMATCH)
101.         {
102.                 ExFreePool(Buffer);
103.                 BufferSize = BufferSize * 2;
104.                 Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, "LyShark");
105.                 memset(Buffer, 0, BufferSize);
106.                 Status = ZwQuerySystemInformation(16, Buffer, BufferSize, 0);
107.         }
109.         if (!NT_SUCCESS(Status))
110.         {
111.                 return;
112.         }
114.         // 获取系统中所有句柄表
115.         qwHandleCount = ((SYSTEM_HANDLE_INFORMATION *)Buffer)->NumberOfHandles;
117.         // 得到句柄表的SYSTEM_HANDLE_TABLE_ENTRY_INFO结构
118.         p = (SYSTEM_HANDLE_TABLE_ENTRY_INFO *)((SYSTEM_HANDLE_INFORMATION *)Buffer)->Handles;
120.         // 初始化HandleInfo数组
121.         memset(HandleInfo, 0, 1024 * sizeof(HANDLE_INFO));
123.         // 开始枚举句柄
124.         for (i = 0; i<qwHandleCount; i++)
125.         {
126.                 ulProcessID = (ULONG)p[i].UniqueProcessId;
127.                 cid.UniqueProcess = (HANDLE)ulProcessID;
128.                 cid.UniqueThread = (HANDLE)0;
129.                 hHandle = (HANDLE)p[i].HandleValue;
131.                 // 初始化对象结构
132.                 InitializeObjectAttributes(&oa, NULL, 0, NULL, NULL);
134.                 // 通过句柄信息打开占用进程
135.                 ns = ZwOpenProcess(&hProcess, PROCESS_DUP_HANDLE, &oa, &cid);
137.                 // 打开错误
138.                 if (!NT_SUCCESS(ns))
139.                 {
140.                         continue;
141.                 }
143.                 // 创建一个句柄，该句柄是指定源句柄的副本。
144.                 ns = ZwDuplicateObject(hProcess, hHandle, NtCurrentProcess(), &hDupObj, PROCESS_ALL_ACCESS, 0, DUPLICATE_SAME_ACCESS);
145.                 if (!NT_SUCCESS(ns))
146.                 {
147.                         continue;
148.                 }
150.                 // 查询对象句柄的信息并放入BasicInfo
151.                 ZwQueryObject(hDupObj, ObjectBasicInformation, &BasicInfo, sizeof(OBJECT_BASIC_INFORMATION), NULL);
153.                 // 得到对象句柄的名字信息
154.                 pNameInfo = ExAllocatePool(PagedPool, 1024);
155.                 RtlZeroMemory(pNameInfo, 1024);
157.                 // 查询对象信息中的对象名，并将该信息保存到pNameInfo中
158.                 qost = ZwQueryObject(hDupObj, ObjectNameInformation, pNameInfo, 1024, &rtl);
160.                 // 获取信息并关闭句柄
161.                 UnicodeStringToCharArray(&(pNameInfo->Name), szFile);
162.                 ExFreePool(pNameInfo);
163.                 ZwClose(hDupObj);
164.                 ZwClose(hProcess);
166.                 // 检查句柄是否被占用,如果被占用则关闭文件并删除
167.                 if (strstr(_strlwr(szFile), "pagefile.sys"))
168.                 {
169.                         PEPROCESS ep = LookupProcess((HANDLE)(p[i].UniqueProcessId));
171.                         // 占用则强制关闭
172.                         ForceCloseHandle(ep, p[i].HandleValue);
173.                         ObDereferenceObject(ep);
174.                 }
175.         }
177.         Driver->DriverUnload = UnDriver;
178.         return STATUS_SUCCESS;
179. }

复制代码

编译并运行这段驱动程序，则会将pagefile.sys内核文件进行解锁，输出效果如下所示；

聊完了文件解锁功能，接下来将继续探讨如何实现强制删除文件的功能，文件强制删除的关键在于ObReferenceObjectByHandle函数，该函数可在对象句柄上提供访问验证，并授予访问权限返回指向对象的正文的相应指针，当有了指定的权限以后则可以直接调用ZwDeleteFile()将文件强制删除。
在调用初始化句柄前提之下需要先调用KeGetCurrentIrql()函数，该函数返回当前IRQL级别，那么什么是IRQL呢?
Windows中系统中断请求（IRQ）可分为两种，一种外部中断（硬件中断），一种是软件中断（INT3），微软将中断的概念进行了扩展，提出了中断请求级别（IRQL）的概念，其中就规定了32个中断请求级别。

• 其中0-2级为软中断，顺序由小到大分别是：PASSIVE_LEVEL，APC_LEVEL，DISPATCH_LEVEL
  
• 其中27-31为硬中断，顺序由小到大分别是：PROFILE_LEVEL，CLOCK1_LEVEL，CLOCK2_LEVEL，IPI_LEVEL，POWER_LEVEL，HIGH_LEVEL
  

我们的代码中开头部分KeGetCurrentIrql() > PASSIVE_LEVEL则是在判断当前的级别不大于0级，也就是说必须要大于0才可以继续执行。
好开始步入正题，函数ObReferenceObjectByHandle需要传入一个文件句柄，而此句柄需要通过IoCreateFileSpecifyDeviceObjectHint对其进行初始化，文件系统筛选器驱动程序使用IoCreateFileSpecifyDeviceObjectHint函数创建，该函数的微软完整定义如下所示；

1. NTSTATUS IoCreateFileSpecifyDeviceObjectHint(
2.   [out]          PHANDLE            FileHandle,               // 指向变量的指针，该变量接收文件对象的句柄。
3.   [in]           ACCESS_MASK        DesiredAccess,            // 标志的位掩码，指定调用方需要对文件或目录的访问类型。
4.   [in]           POBJECT_ATTRIBUTES ObjectAttributes,         // 指向已由 InitializeObjectAttributes 例程初始化的OBJECT_ATTRIBUTES结构的指针。
5.   [out]          PIO_STATUS_BLOCK   IoStatusBlock,            // 指向 IO_STATUS_BLOCK 结构的指针，该结构接收最终完成状态和有关所请求操作的信息。
6.   [in, optional] PLARGE_INTEGER     AllocationSize,           // 指定文件的初始分配大小（以字节为单位）。
7.   [in]           ULONG              FileAttributes,           // 仅当文件创建、取代或在某些情况下被覆盖时，才会应用显式指定的属性。
8.   [in]           ULONG              ShareAccess,              // 指定调用方希望的对文件的共享访问类型（为零或 1，或以下标志的组合）。
9.   [in]           ULONG              Disposition,              // 指定一个值，该值确定要执行的操作，具体取决于文件是否已存在。
10.   [in]           ULONG              CreateOptions,            // 指定要在创建或打开文件时应用的选项。
11.   [in, optional] PVOID              EaBuffer,                 // 指向调用方提供的 FILE_FULL_EA_INFORMATION结构化缓冲区的指针。
12.   [in]           ULONG              EaLength,                 // EaBuffer 的长度（以字节为单位）。
13.   [in]           CREATE_FILE_TYPE   CreateFileType,           // 驱动程序必须将此参数设置为 CreateFileTypeNone。
14.   [in, optional] PVOID              InternalParameters,       // 驱动程序必须将此参数设置为 NULL。
15.   [in]           ULONG              Options,                  // 指定要在创建请求期间使用的选项。
16.   [in, optional] PVOID              DeviceObject              // 指向要向其发送创建请求的设备对象的指针。
17. );

复制代码

当调用IoCreateFileSpecifyDeviceObjectHint()函数完成初始化并创建设备后，则下一步就是调用ObReferenceObjectByHandle()并传入初始化好的设备句柄到Handle参数上，

1. NTSTATUS ObReferenceObjectByHandle(
2.   [in]            HANDLE                     Handle,             // 指定对象的打开句柄。
3.   [in]            ACCESS_MASK                DesiredAccess,      // 指定对对象的请求访问类型。
4.   [in, optional]  POBJECT_TYPE               ObjectType,         // 指向对象类型的指针。
5.   [in]            KPROCESSOR_MODE            AccessMode,         // 指定要用于访问检查的访问模式。 它必须是 UserMode 或 KernelMode。
6.   [out]           PVOID                      *Object,            // 指向接收指向对象正文的指针的变量的指针。
7.   [out, optional] POBJECT_HANDLE_INFORMATION HandleInformation   // 驱动程序将此设置为 NULL。
8. );

复制代码

通过调用如上两个函数将权限设置好以后，我们再手动将ImageSectionObject也就是映像节对象填充为0，然后再将DeleteAccess删除权限位打开，最后调用ZwDeleteFile()函数即可实现强制删除文件的效果，其核心代码如下所示；

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. // 强制删除文件
9. BOOLEAN ForceDeleteFile(UNICODE_STRING pwzFileName)
10. {
11.         PEPROCESS pCurEprocess = NULL;
12.         KAPC_STATE kapc = { 0 };
13.         OBJECT_ATTRIBUTES fileOb;
14.         HANDLE hFile = NULL;
15.         NTSTATUS status = STATUS_UNSUCCESSFUL;
16.         IO_STATUS_BLOCK iosta;
17.         PDEVICE_OBJECT DeviceObject = NULL;
18.         PVOID pHandleFileObject = NULL;
21.         // 判断中断等级不大于0
22.         if (KeGetCurrentIrql() > PASSIVE_LEVEL)
23.         {
24.                 return FALSE;
25.         }
26.         if (pwzFileName.Buffer == NULL || pwzFileName.Length <= 0)
27.         {
28.                 return FALSE;
29.         }
31.         __try
32.         {
33.                 // 读取当前进程的EProcess
34.                 pCurEprocess = IoGetCurrentProcess();
36.                 // 附加进程
37.                 KeStackAttachProcess(pCurEprocess, &kapc);
39.                 // 初始化结构
40.                 InitializeObjectAttributes(&fileOb, &pwzFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
42.                 // 文件系统筛选器驱动程序 仅向指定设备对象下面的筛选器和文件系统发送创建请求。
43.                 status = IoCreateFileSpecifyDeviceObjectHint(&hFile,
44.                         SYNCHRONIZE | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_READ_DATA,
45.                         &fileOb,
46.                         &iosta,
47.                         NULL,
48.                         0,
49.                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
50.                         FILE_OPEN,
51.                         FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
52.                         0,
53.                         0,
54.                         CreateFileTypeNone,
55.                         0,
56.                         IO_IGNORE_SHARE_ACCESS_CHECK,
57.                         DeviceObject);
58.                 if (!NT_SUCCESS(status))
59.                 {
60.                         return FALSE;
61.                 }
63.                 // 在对象句柄上提供访问验证，如果可以授予访问权限，则返回指向对象的正文的相应指针。
64.                 status = ObReferenceObjectByHandle(hFile, 0, 0, 0, &pHandleFileObject, 0);
65.                 if (!NT_SUCCESS(status))
66.                 {
67.                         return FALSE;
68.                 }
70.                 // 镜像节对象设置为0
71.                 ((PFILE_OBJECT)(pHandleFileObject))->SectionObjectPointer->ImageSectionObject = 0;
73.                 // 删除权限打开
74.                 ((PFILE_OBJECT)(pHandleFileObject))->DeleteAccess = 1;
76.                 // 调用删除文件API
77.                 status = ZwDeleteFile(&fileOb);
78.                 if (!NT_SUCCESS(status))
79.                 {
80.                         return FALSE;
81.                 }
82.         }
84.         _finally
85.         {
86.                 if (pHandleFileObject != NULL)
87.                 {
88.                         ObDereferenceObject(pHandleFileObject);
89.                         pHandleFileObject = NULL;
90.                 }
91.                 KeUnstackDetachProcess(&kapc);
93.                 if (hFile != NULL || hFile != (PVOID)-1)
94.                 {
95.                         ZwClose(hFile);
96.                         hFile = (PVOID)-1;
97.                 }
98.         }
99.         return TRUE;
100. }
102. VOID UnDriver(PDRIVER_OBJECT driver)
103. {
104.         DbgPrint("驱动卸载成功 \n");
105. }
107. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
108. {
109.         DbgPrint("Hello LyShark.com \n");
111.         UNICODE_STRING local_path;
112.         UNICODE_STRING file_path;
113.         BOOLEAN ref = FALSE;
114.        
115.         // 初始化被删除文件
116.         RtlInitUnicodeString(&file_path, L"\\??\\C:\\lyshark.exe");
118.         // 获取自身驱动文件
119.         local_path = ((PLDR_DATA_TABLE_ENTRY64)Driver->DriverSection)->FullDllName;
121.         // 删除lyshark.exe
122.         ref = ForceDeleteFile(file_path);
123.         if (ref == TRUE)
124.         {
125.                 DbgPrint("[+] 已删除 %wZ \n",file_path);
126.         }
128.         // 删除WinDDK.sys
129.         ref = ForceDeleteFile(local_path);
130.         if (ref == TRUE)
131.         {
132.                 DbgPrint("[+] 已删除 %wZ \n", local_path);
133.         }
135.         Driver->DriverUnload = UnDriver;
136.         return STATUS_SUCCESS;
137. }

复制代码

编译并运行如上程序，则会分别将c://lyshark.exe以及驱动程序自身删除，并输出如下图所示的提示信息；


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！