强删文件--->构建IRP---->独占--->正在运行 以及磁盘读写(思路)

版权声明：本文为博主原创文章，未经博主允许不得转载。

个人比较崇拜360 一个小小的按钮下面蕴含着很多的原理 要有多么强大才能1天搞定偏移
-------致敬360 致敬MJ-001
无奈本人学业不精 只能说说“独占”和“正在运行”
打开文件 一般使用ZwCreateFile NtCreateFile 但这些函数还不够底层 使用IoCreateFile会好一些
被其它程序独占
枚举句柄表 ZwQuerySystemInformation --->复制句柄 ZwDuplicateObject --->ZwClose 然后再ZwDuplicateObject 一次 这次使用DUPLICATE_CLOSE_SOURCE -->ZwClose


正在运行 这个涉及构建IRP 最下面会说
将ImageSectionObject 和 DataSectionObject设为0就可以解决了

[cpp]  view plain  copy

1. NtfsSetDispositionInfoMmFlushImageSection  
2. pSectionObjectPointer = fileObject->SectionObjectPointer;  
3. pSectionObjectPointer->ImageSectionObject = 0;  
4. pSectionObjectPointer->DataSectionObject = 0;  

 核心代码代码:

[cpp]  view plain  copy

1.  NTSTATUS  
2. dfSkillSetFileCompletion(  
3.     IN PDEVICE_OBJECT DeviceObject,  
4.     IN PIRP Irp,  
5.     IN PVOID Context  
6.     )  
7. {  
8.     Irp->UserIosb->Status = Irp->IoStatus.Status;  
9.     Irp->UserIosb->Information = Irp->IoStatus.Information;  
10.   
11.     KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, FALSE);  
12.   
13.     IoFreeIrp(Irp);  
14.   
15.     return STATUS_MORE_PROCESSING_REQUIRED;  
16. }  
17.   
18. BOOLEAN dfDelFile(WCHAR* name)  
19. {  
20.     NTSTATUS        ntStatus = STATUS_SUCCESS;  
21.     PFILE_OBJECT    fileObject;  
22.     PDEVICE_OBJECT  DeviceObject;  
23.     PIRP            Irp;  
24.     KEVENT          event;  
25.     FILE_DISPOSITION_INFORMATION  FileInformation;  
26.     IO_STATUS_BLOCK ioStatus;  
27.     PIO_STACK_LOCATION irpSp;  
28.     PSECTION_OBJECT_POINTERS pSectionObjectPointer;  
29.     HANDLE handle;  
30.   
31.     ntStatus = dfOpenFile(name, &handle, FILE_READ_ATTRIBUTES|DELETE,FILE_SHARE_DELETE);  
32.     if (ntStatus == STATUS_OBJECT_NAME_NOT_FOUND ||  
33.         ntStatus == STATUS_OBJECT_PATH_NOT_FOUND )  
34.     {  
35.         KdPrint(("No such file"));  
36.         return FALSE;  
37.     }  
38.     else if (!NT_SUCCESS(ntStatus))  
39.     {  
40.         if (dfCloseFileHandle(name))  
41.         {  
42.             ntStatus = dfOpenFile(name, &handle, FILE_READ_ATTRIBUTES|DELETE,FILE_SHARE_DELETE);  
43.             if (!NT_SUCCESS(ntStatus))  
44.                 return FALSE;  
45.         }  
46.         else  
47.         {  
48.             return FALSE;  
49.         }  
50.     }  
51.   
52.     ntStatus = ObReferenceObjectByHandle(handle,  
53.         DELETE,  
54.         *IoFileObjectType,  
55.         KernelMode,  
56.         &fileObject,  
57.         NULL);  
58.   
59.     if (!NT_SUCCESS(ntStatus))  
60.     {  
61.         DbgPrint("ObReferenceObjectByHandle()");  
62.         ZwClose(handle);  
63.         return FALSE;  
64.     }    
65.   
66.     DeviceObject = IoGetRelatedDeviceObject(fileObject);  
67.     Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);  
68.   
69.     if (Irp == NULL)  
70.     {  
71.         ObDereferenceObject(fileObject);  
72.         ZwClose(handle);  
73.         return FALSE;  
74.     }  
75.   
76.     KeInitializeEvent(&event, SynchronizationEvent, FALSE);  
77.      
78.     FileInformation.DeleteFile = TRUE;  
79.   
80.     Irp->AssociatedIrp.SystemBuffer = &FileInformation;  
81.     Irp->UserEvent = &event;  
82.     Irp->UserIosb = &ioStatus;  
83.     Irp->Tail.Overlay.OriginalFileObject = fileObject;  
84.     Irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();  
85.     Irp->RequestorMode = KernelMode;  
86.      
87.     irpSp = IoGetNextIrpStackLocation(Irp);  
88.     irpSp->MajorFunction = IRP_MJ_SET_INFORMATION;  
89.     irpSp->DeviceObject = DeviceObject;  
90.     irpSp->FileObject = fileObject;  
91.     irpSp->Parameters.SetFile.Length = sizeof(FILE_DISPOSITION_INFORMATION);  
92.     irpSp->Parameters.SetFile.FileInformationClass = FileDispositionInformation;  
93.     irpSp->Parameters.SetFile.FileObject = fileObject;  
94.   
95.     IoSetCompletionRoutine(  
96.             Irp,  
97.             dfSkillSetFileCompletion,  
98.             &event,  
99.             TRUE,  
100.             TRUE,  
101.             TRUE);  
102.     pSectionObjectPointer = fileObject->SectionObjectPointer;  
103.     if(pSectionObjectPointer)  
104.     {  
105.         pSectionObjectPointer->ImageSectionObject = 0;  
106.         pSectionObjectPointer->DataSectionObject = 0;  
107.     }  
108.     ntStatus = IoCallDriver(DeviceObject, Irp);   
109.     if (!NT_SUCCESS(ntStatus))  
110.     {  
111.          ObDereferenceObject(fileObject);  
112.          ZwClose(handle);  
113.          return FALSE;  
114.     }    
115.   
116.     KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);  
117.     //IoFreeIrp(Irp);  
118.     ObDereferenceObject(fileObject);  
119.     ZwClose(handle);  
120.     return TRUE;  
121.   
122. }  

整个工程代码:

DelFile.c

[cpp]  view plain  copy

1. #include <ntddk.h>  
2. #include <ntimage.h>  
3. #include <ntdef.h>  
4. #include "DelFile.h"  
5.   
6. PDEVICE_OBJECT  g_HookDevice;  
7.   
8.   
9. NTSTATUS dfQuerySymbolicLink(  
10.     IN PUNICODE_STRING SymbolicLinkName,  
11.     OUT PUNICODE_STRING LinkTarget  
12.     )                                    
13. {  
14.     OBJECT_ATTRIBUTES oa;  
15.     NTSTATUS status;  
16.     HANDLE handle;  
17.      
18.     InitializeObjectAttributes(  
19.         &oa,   
20.         SymbolicLinkName,  
21.         OBJ_CASE_INSENSITIVE,  
22.         0,   
23.         0);  
24.      
25.     status = ZwOpenSymbolicLinkObject(&handle, GENERIC_READ, &oa);  
26.     if (!NT_SUCCESS(status))  
27.     {  
28.         return status;  
29.     }  
30.      
31.     LinkTarget->MaximumLength = 1024*sizeof(WCHAR);  
32.     LinkTarget->Length = 0;  
33.     LinkTarget->Buffer = ExAllocatePoolWithTag(PagedPool, LinkTarget->MaximumLength, 'A0');  
34.     if (!LinkTarget->Buffer)  
35.     {  
36.         ZwClose(handle);  
37.         return STATUS_INSUFFICIENT_RESOURCES;  
38.     }  
39.   
40.   
41.     RtlZeroMemory(LinkTarget->Buffer, LinkTarget->MaximumLength);  
42.      
43.     status = ZwQuerySymbolicLinkObject(handle, LinkTarget, NULL);  
44.     ZwClose(handle);  
45.      
46.     if (!NT_SUCCESS(status))  
47.     {  
48.         ExFreePool(LinkTarget->Buffer);  
49.     }  
50.      
51.     return status;  
52. }  
53.   
54.   
55. BOOLEAN dfCloseFileHandle(WCHAR *name)  
56. {  
57.       
58.     NTSTATUS                     status;  
59.     PVOID                        buf   = NULL;  
60.     PSYSTEM_HANDLE_INFORMATION   pSysHandleInfo;  
61.     SYSTEM_HANDLE_TABLE_ENTRY_INFO handleTEI;  
62.   
63.   
64.     ULONG                       size  = 1;  
65.     ULONG                       NumOfHandle = 0;  
66.     ULONG                       i;  
67.     CLIENT_ID                   cid;  
68.     HANDLE                      hHandle;  
69.     HANDLE                      hProcess;  
70.     HANDLE                      hDupObj;  
71.     HANDLE                      hFile;  
72.     HANDLE                      link_handle;  
73.     OBJECT_ATTRIBUTES           oa;  
74.     ULONG                       FileType;   
75.     ULONG                       processID;  
76.     UNICODE_STRING              uLinkName;  
77.     UNICODE_STRING              uLink;  
78.     OBJECT_ATTRIBUTES           objectAttributes;  
79.     IO_STATUS_BLOCK             IoStatus;  
80.     ULONG                       ulRet;  
81.     PVOID                       fileObject;  
82.     POBJECT_NAME_INFORMATION    pObjName;  
83.     UNICODE_STRING              delFileName = {0};  
84.     int                         length;  
85.     WCHAR                       wVolumeLetter[3];  
86.     WCHAR                       *pFilePath;  
87.     UNICODE_STRING              uVolume;  
88.     UNICODE_STRING              uFilePath;  
89.     UNICODE_STRING              NullString = RTL_CONSTANT_STRING(L"");  
90.     BOOLEAN                 bRet = FALSE;  
91.   
92.   
93.   
94.   
95.     for ( size = 1; ; size *= 2 )  
96.     {  
97.         if ( NULL == ( buf = ExAllocatePoolWithTag(NonPagedPool,size, 'FILE') ) )  
98.         {  
99.             DbgPrint(("alloc mem failed\n"));  
100.             goto Exit;  
101.         }  
102.         RtlZeroMemory( buf ,size );  
103.         status = ZwQuerySystemInformation( SystemHandleInformation, buf, size, NULL );  
104.         if ( !NT_SUCCESS( status ) )  
105.         {  
106.             if ( STATUS_INFO_LENGTH_MISMATCH == status )  
107.             {  
108.                 ExFreePool( buf );  
109.                 buf = NULL;  
110.             }  
111.             else  
112.             {  
113.                 DbgPrint(( "ZwQuerySystemInformation() failed"));  
114.                 goto Exit;  
115.             }  
116.         }  
117.         else  
118.         {  
119.             break;  
120.         }  
121.     }  
122.   
123.   
124.     pSysHandleInfo = (PSYSTEM_HANDLE_INFORMATION)buf;  
125.     NumOfHandle = pSysHandleInfo->NumberOfHandles;  
126.   
127.   
128.       
129.   
130.   
131.     /* Get the volume character like C: */  
132.   
133.   
134.     wVolumeLetter[0] = name[4];  
135.     wVolumeLetter[1] = name[5];  
136.     wVolumeLetter[2] = 0;  
137.     uLinkName.Buffer = ExAllocatePoolWithTag(NonPagedPool, 256 + sizeof(ULONG), 'A1');  
138.     uLinkName.MaximumLength = 256;  
139.     RtlInitUnicodeString(&uVolume, wVolumeLetter);  
140.     RtlInitUnicodeString( &uLink, L"\\DosDevices\\");  
141.     RtlCopyUnicodeString(&uLinkName, &uLink);  
142.       
143.     status = RtlAppendUnicodeStringToString(&uLinkName, &uVolume);  
144.     if (!NT_SUCCESS(status))  
145.     {  
146.         KdPrint(("RtlAppendUnicodeStringToString() failed"));  
147.         return FALSE;  
148.     }  
149.       
150.     dfQuerySymbolicLink(&uLinkName, &delFileName);  
151.     RtlFreeUnicodeString(&uLinkName);  
152.     KdPrint(("delFileName:%wZ", &delFileName));  
153.   
154.   
155.     pFilePath = (WCHAR *) &name[6];  
156.     RtlInitUnicodeString( &uFilePath, pFilePath);  
157.   
158.   
159.     RtlAppendUnicodeStringToString(&delFileName, &uFilePath);  
160.     if (!NT_SUCCESS(status))  
161.     {  
162.         KdPrint(("RtlAppendUnicodeStringToString() failed"));  
163.         return FALSE;  
164.     }  
165.   
166.   
167.     KdPrint(("delFile:%wZ", &delFileName));  
168.   
169.   
170.     for(i = 0; i < NumOfHandle ;i++)  
171.     {  
172.         handleTEI = pSysHandleInfo->Handles[i];  
173.         if (handleTEI.ObjectTypeIndex != 25 && handleTEI.ObjectTypeIndex != 28)//28文件,25设备对象  
174.             continue;  
175.         processID = (ULONG) handleTEI.UniqueProcessId;  
176.         cid.UniqueProcess = (HANDLE)processID;  
177.         cid.UniqueThread = (HANDLE)0;  
178.         hHandle = (HANDLE)handleTEI.HandleValue;  
179.         InitializeObjectAttributes( &oa ,NULL ,0 ,NULL ,NULL );  
180.         status = ZwOpenProcess( &hProcess ,PROCESS_DUP_HANDLE ,&oa ,&cid );  
181.         if ( !NT_SUCCESS( status ) )  
182.         {  
183.             KdPrint(( "ZwOpenProcess:%d Fail ", processID));  
184.             continue;  
185.         }  
186.   
187.   
188.         status = ZwDuplicateObject( hProcess ,hHandle ,NtCurrentProcess() ,&hDupObj ,\  
189.          PROCESS_ALL_ACCESS ,0 ,DUPLICATE_SAME_ACCESS );  
190.         if ( !NT_SUCCESS( status ) )  
191.         {  
192.             DbgPrint(( "ZwDuplicateObject1 : Fail " ));  
193.             continue;  
194.         }  
195.         status = ObReferenceObjectByHandle(  
196.               hDupObj,  
197.               FILE_ANY_ACCESS,  
198.               0,  
199.               KernelMode,  
200.               &fileObject,  
201.               NULL);  
202.           
203.         if (!NT_SUCCESS(status))  
204.         {  
205.             DbgPrint(( "ObReferenceObjectByHandle : Fail " ));  
206.             continue;  
207.         }    
208.   
209.   
210.         pObjName = (POBJECT_NAME_INFORMATION) ExAllocatePoolWithTag(NonPagedPool, \  
211.             sizeof (OBJECT_NAME_INFORMATION) + 1024 * sizeof (WCHAR), 'A1');  
212.   
213.   
214.         if (STATUS_SUCCESS != (status = ObQueryNameString(fileObject, pObjName, \  
215.             sizeof (OBJECT_NAME_INFORMATION) + 1024 * sizeof (WCHAR), &ulRet)))  
216.         {  
217.            ObDereferenceObject(fileObject);  
218.            continue;  
219.         }  
220.         if (RtlCompareUnicodeString(&pObjName->Name, &delFileName, TRUE) == 0)  
221.         {  
222.   
223.   
224.             ObDereferenceObject(fileObject);  
225.             ZwClose(hDupObj);  
226.   
227.   
228.             status = ZwDuplicateObject( hProcess ,hHandle ,NtCurrentProcess() ,&hDupObj ,\  
229.              PROCESS_ALL_ACCESS ,0 ,DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE );  
230.             if ( !NT_SUCCESS( status ) )  
231.             {  
232.                 DbgPrint(( "ZwDuplicateObject2 : Fail " ));  
233.                 //return FALSE;  
234.             }  
235.             else  
236.             {  
237.                 ZwClose(hDupObj);  
238.                 bRet = TRUE;  
239.                 //return TRUE;  
240.             }  
241.             break;  
242.   
243.   
244.         }  
245.               
246.         ExFreePool(pObjName);  
247.         pObjName = NULL;  
248.   
249.   
250.         ObDereferenceObject(fileObject);  
251.         ZwClose( hDupObj );  
252.         ZwClose( hProcess );  
253.   
254.   
255.     }  
256.   
257.   
258. Exit:  
259.     if (pObjName != NULL)  
260.     {  
261.         ExFreePool(pObjName);  
262.         pObjName = NULL;  
263.     }  
264.     if (delFileName.Buffer != NULL)  
265.     {  
266.         ExFreePool(delFileName.Buffer);   
267.     }  
268.     if ( buf != NULL )  
269.     {  
270.         ExFreePool( buf );  
271.         buf = NULL;  
272.     }  
273.     return(bRet);  
274.   
275.   
276. }  
277.   
278.   
279. NTSTATUS  
280. dfOpenFile(WCHAR* name,PHANDLE phFileHandle, ACCESS_MASK access,ULONG share)  
281. {  
282.   
283.   
284.    IO_STATUS_BLOCK iosb;  
285.    NTSTATUS stat;  
286.    OBJECT_ATTRIBUTES oba;  
287.    UNICODE_STRING nameus;  
288.   
289.   
290.    if(KeGetCurrentIrql()>PASSIVE_LEVEL){return 0;}  
291.    RtlInitUnicodeString(&nameus,name);  
292.    InitializeObjectAttributes(  
293.         &oba,  
294.         &nameus,  
295.         OBJ_KERNEL_HANDLE|OBJ_CASE_INSENSITIVE,  
296.         0,  
297.         0);  
298.    stat=IoCreateFile(  
299.         phFileHandle,  
300.         access,  
301.         &oba,  
302.         &iosb,  
303.         0,  
304.         FILE_ATTRIBUTE_NORMAL,  
305.         share,  
306.         FILE_OPEN,  
307.         0,  
308.         NULL,  
309.         0,  
310.         0,  
311.         NULL,  
312.         IO_NO_PARAMETER_CHECKING);  
313.   
314.   
315.     return stat;  
316. }  
317.   
318.   
319. NTSTATUS  
320. dfSkillSetFileCompletion(  
321.     IN PDEVICE_OBJECT DeviceObject,  
322.     IN PIRP Irp,  
323.     IN PVOID Context  
324.     )  
325. {  
326.     Irp->UserIosb->Status = Irp->IoStatus.Status;  
327.     Irp->UserIosb->Information = Irp->IoStatus.Information;  
328.   
329.   
330.     KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, FALSE);  
331.   
332.   
333.     IoFreeIrp(Irp);  
334.   
335.   
336.     return STATUS_MORE_PROCESSING_REQUIRED;  
337. }  
338.   
339.   
340. BOOLEAN dfDelFile(WCHAR* name)  
341. {  
342.     NTSTATUS        ntStatus = STATUS_SUCCESS;  
343.     PFILE_OBJECT    fileObject;  
344.     PDEVICE_OBJECT  DeviceObject;  
345.     PIRP            Irp;  
346.     KEVENT          event;  
347.     FILE_DISPOSITION_INFORMATION  FileInformation;  
348.     IO_STATUS_BLOCK ioStatus;  
349.     PIO_STACK_LOCATION irpSp;  
350.     PSECTION_OBJECT_POINTERS pSectionObjectPointer;  
351.     HANDLE handle;  
352.   
353.   
354.     ntStatus = dfOpenFile(name, &handle, FILE_READ_ATTRIBUTES|DELETE,FILE_SHARE_DELETE);  
355.     if (ntStatus == STATUS_OBJECT_NAME_NOT_FOUND ||  
356.         ntStatus == STATUS_OBJECT_PATH_NOT_FOUND )  
357.     {  
358.         KdPrint(("No such file"));  
359.         return FALSE;  
360.     }  
361.     else if (!NT_SUCCESS(ntStatus))  
362.     {  
363.         if (dfCloseFileHandle(name))  
364.         {  
365.             ntStatus = dfOpenFile(name, &handle, FILE_READ_ATTRIBUTES|DELETE,FILE_SHARE_DELETE);  
366.             if (!NT_SUCCESS(ntStatus))  
367.                 return FALSE;  
368.         }  
369.         else  
370.         {  
371.             return FALSE;  
372.         }  
373.     }  
374.   
375.   
376.     ntStatus = ObReferenceObjectByHandle(handle,  
377.         DELETE,  
378.         *IoFileObjectType,  
379.         KernelMode,  
380.         &fileObject,  
381.         NULL);  
382.   
383.   
384.     if (!NT_SUCCESS(ntStatus))  
385.     {  
386.         DbgPrint("ObReferenceObjectByHandle()");  
387.         ZwClose(handle);  
388.         return FALSE;  
389.     }    
390.   
391.   
392.     DeviceObject = IoGetRelatedDeviceObject(fileObject);  
393.     Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);  
394.   
395.   
396.     if (Irp == NULL)  
397.     {  
398.         ObDereferenceObject(fileObject);  
399.         ZwClose(handle);  
400.         return FALSE;  
401.     }  
402.   
403.   
404.     KeInitializeEvent(&event, SynchronizationEvent, FALSE);  
405.      
406.     FileInformation.DeleteFile = TRUE;  
407.   
408.   
409.     Irp->AssociatedIrp.SystemBuffer = &FileInformation;  
410.     Irp->UserEvent = &event;  
411.     Irp->UserIosb = &ioStatus;  
412.     Irp->Tail.Overlay.OriginalFileObject = fileObject;  
413.     Irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();  
414.     Irp->RequestorMode = KernelMode;  
415.      
416.     irpSp = IoGetNextIrpStackLocation(Irp);  
417.     irpSp->MajorFunction = IRP_MJ_SET_INFORMATION;  
418.     irpSp->DeviceObject = DeviceObject;  
419.     irpSp->FileObject = fileObject;  
420.     irpSp->Parameters.SetFile.Length = sizeof(FILE_DISPOSITION_INFORMATION);  
421.     irpSp->Parameters.SetFile.FileInformationClass = FileDispositionInformation;  
422.     irpSp->Parameters.SetFile.FileObject = fileObject;  
423.   
424.   
425.     IoSetCompletionRoutine(  
426.             Irp,  
427.             dfSkillSetFileCompletion,  
428.             &event,  
429.             TRUE,  
430.             TRUE,  
431.             TRUE);  
432.     pSectionObjectPointer = fileObject->SectionObjectPointer;  
433.     if(pSectionObjectPointer)  
434.     {  
435.         pSectionObjectPointer->ImageSectionObject = 0;  
436.         pSectionObjectPointer->DataSectionObject = 0;  
437.     }  
438.     ntStatus = IoCallDriver(DeviceObject, Irp);   
439.     if (!NT_SUCCESS(ntStatus))  
440.     {  
441.          ObDereferenceObject(fileObject);  
442.          ZwClose(handle);  
443.          return FALSE;  
444.     }    
445.   
446.   
447.     KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);  
448.     //IoFreeIrp(Irp);  
449.     ObDereferenceObject(fileObject);  
450.     ZwClose(handle);  
451.     return TRUE;  
452.   
453.   
454. }  
455.   
456.   
457.   
458.   
459. NTSTATUS OnUnload(IN PDRIVER_OBJECT DriverObject)  
460. {  
461.     UNICODE_STRING          deviceLinkUnicodeString;  
462.     PDEVICE_OBJECT     p_NextObj;  
463.   
464.   
465.   
466.   
467.     DbgPrint("OnUnload called\n");  
468.   
469.   
470.     p_NextObj = DriverObject->DeviceObject;  
471.   
472.   
473.     if (p_NextObj != NULL)  
474.     {  
475.   
476.   
477.         RtlInitUnicodeString( &deviceLinkUnicodeString, deviceLinkBuffer );  
478.         IoDeleteSymbolicLink( &deviceLinkUnicodeString );  
479.   
480.   
481.         IoDeleteDevice( DriverObject->DeviceObject );  
482.     }  
483.     return STATUS_SUCCESS;  
484. }  
485.   
486.   
487. NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)  
488. {  
489.     NTSTATUS                ntStatus;  
490.     UNICODE_STRING          deviceNameUnicodeString;  
491.     UNICODE_STRING          deviceLinkUnicodeString;  
492.   
493.   
494.     RtlInitUnicodeString (&deviceNameUnicodeString,  
495.         deviceNameBuffer );  
496.     RtlInitUnicodeString (&deviceLinkUnicodeString,  
497.         deviceLinkBuffer );  
498.   
499.   
500.     ntStatus = IoCreateDevice ( DriverObject,  
501.         0,  
502.         &deviceNameUnicodeString,  
503.         FILE_DEVICE_SWAP,  
504.         0,  
505.         TRUE,  
506.         &g_HookDevice );  
507.   
508.   
509.     if(! NT_SUCCESS(ntStatus))  
510.     {  
511.           DbgPrint(("Failed to create device!\n"));  
512.           return ntStatus;  
513.      }  
514.   
515.   
516.     /* We test the DelFile() function here */     
517.     if (dfDelFile(L"\\??\\c:\\haha.doc"))  
518.     {  
519.         KdPrint(("Deleted"));  
520.     }  
521.     else  
522.     {  
523.         KdPrint(("Failed"));  
524.     }  
525.     if (dfDelFile(L"\\??\\c:\\filedelet.exe"))  
526.     {  
527.         KdPrint(("Deleted"));  
528.     }  
529.     else  
530.     {  
531.         KdPrint(("Failed"));  
532.     }  
533.   
534.   
535.     ntStatus = IoCreateSymbolicLink (&deviceLinkUnicodeString,  
536.         &deviceNameUnicodeString );  
537.     if(! NT_SUCCESS(ntStatus))   
538.     {  
539.          IoDeleteDevice(DriverObject->DeviceObject);  
540.             DbgPrint("Failed to create symbolic link!\n");  
541.             return ntStatus;  
542.      }  
543.   
544.   
545.     DriverObject->DriverUnload  = OnUnload;  
546.     return STATUS_SUCCESS;  
547. }  

DelFile.h

[cpp]  view plain  copy

1. #ifndef _MAIN_H_  
2. #define _MAIN_H_  
3. const WCHAR deviceLinkBuffer[]  = L"\\DosDevices\\Delfile";  
4. const WCHAR deviceNameBuffer[]  = L"\\Device\\Delfile";  
5. typedef unsigned long DWORD;  
6. #define SystemHandleInformation 16  
7. #define INVALID_PID_VALUE 0xFFFFFFFF  
8. #define FILE_DEVICE_SWAP     0x0000800a  
9.   
10.   
11. typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO  
12. {  
13. USHORT UniqueProcessId;  
14. USHORT CreatorBackTraceIndex;  
15. UCHAR ObjectTypeIndex;  
16. UCHAR HandleAttributes;  
17. USHORT HandleValue;  
18. PVOID Object;  
19. ULONG GrantedAccess;  
20. } SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO;  
21.   
22.   
23. typedef struct _SYSTEM_HANDLE_INFORMATION  
24. {  
25. ULONG NumberOfHandles;  
26. SYSTEM_HANDLE_TABLE_ENTRY_INFO Handles[];  
27. } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;  
28.   
29.   
30.   
31.   
32. NTSTATUS  
33. ObQueryNameString(  
34.     IN PVOID  Object,  
35.     OUT POBJECT_NAME_INFORMATION  ObjectNameInfo,  
36.     IN ULONG  Length,  
37.     OUT PULONG  ReturnLength  
38.     );   
39.   
40.   
41. NTSYSAPI  
42. NTSTATUS  
43. NTAPI  
44. ZwQuerySystemInformation(     
45.        ULONG    SystemInformationClass,  
46.        PVOID    SystemInformation,  
47.        ULONG    SystemInformationLength,  
48.        PULONG    ReturnLength  
49.        );  
50. NTSYSAPI  
51. NTSTATUS  
52. NTAPI  
53. ZwDuplicateObject(  
54.       IN HANDLE SourceProcessHandle,  
55.       IN HANDLE SourceHandle,  
56.       IN HANDLE TargetProcessHandle OPTIONAL,  
57.       OUT PHANDLE TargetHandle OPTIONAL,  
58.       IN ACCESS_MASK DesiredAccess,  
59.       IN ULONG HandleAttributes,  
60.       IN ULONG Options  
61.       );  
62.   
63.   
64. NTSYSAPI  
65. NTSTATUS  
66. NTAPI  
67. ZwOpenProcess(      
68.      OUT PHANDLE             ProcessHandle,  
69.      IN ACCESS_MASK          AccessMask,  
70.      IN POBJECT_ATTRIBUTES   ObjectAttributes,  
71.      IN PCLIENT_ID           ClientId  
72.      );  
73.   
74.   
75. /* The file name looks like L"\\??\\C:\\hello.doc" */  
76. BOOLEAN dfDelFile(WCHAR* name);  
77.   
78.   
79. #endif  

构建IRP删除文件
 得到要发向的设备对象--->申请一个IRP头--->设置头的一些信息(传给它什么,原始对象,原始线程,请求模式,事件,返回结果)--->得到目标设备IRP的栈--->填充一些信息
 (功能号(主要干什么),设备对象,文件对象等等和次功能号和描述buffer里的数据)--->设置完成例程--->这里可以自由发挥了修改数据什么的-->下发IRP IoCallDriver-->剩下的就是等待了

代码注释：

 

[cpp]  view plain  copy

1. ......  
2.     //IRP是发向设备对象的 下面这句根据文件对象得到设备对象  
3.     DeviceObject = IoGetRelatedDeviceObject(fileObject);  
4.     //申请一个IRP  
5.     Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);  
6.     if (Irp == NULL)  
7.     {  
8.         ObDereferenceObject(fileObject);  
9.         return FALSE;  
10.     }  
11.     初始化一个信号 等待下面的处理结果  
12.     KeInitializeEvent(&event, SynchronizationEvent, FALSE);  
13.     //设置FILE_DISPOSITION_INFORMATION 结构DeleteFile 为TRUE；  
14.     FileInformation.DeleteFile = TRUE;  
15.     //将这个结构放到缓冲区buff中  
16.     Irp->AssociatedIrp.SystemBuffer = &FileInformation;  
17.     //设置事件  
18.     Irp->UserEvent = &event;  
19.     //设置处理返回结果  
20.     Irp->UserIosb = &ioStatus;  
21.     //设置原始文件对象  
22.     Irp->Tail.Overlay.OriginalFileObject = fileObject;  
23.     //设置原始线程  
24.     Irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();  
25.     //设置请求模式是内核模式  
26.     Irp->RequestorMode = KernelMode;  
27.   
28.   
29.     //以上是设置头部分  
30.     //下面是设置栈上面  
31.   
32.   
33.     //填充给下一个设备的信息  
34.     //获取下一个设备的栈  
35.     irpSp = IoGetNextIrpStackLocation(Irp);  
36.     //要删除文件 要设置一个东西所以主功能号是IRP_MJ_SET_INFORMATION  
37.     irpSp->MajorFunction = IRP_MJ_SET_INFORMATION;  
38.     //设备对象是前面获取到的设备对象  
39.     irpSp->DeviceObject = DeviceObject;  
40.     //文件对象是得到的文件对象  
41.     irpSp->FileObject = fileObject;  
42.     //设置参数大小  
43.     irpSp->Parameters.SetFile.Length = sizeof(FILE_DISPOSITION_INFORMATION);  
44.     //设置参数类型 次功能号FileDispositionInformation就是删除文件  
45.     irpSp->Parameters.SetFile.FileInformationClass = FileDispositionInformation;  
46.     //设置参数文件对象  
47.     irpSp->Parameters.SetFile.FileObject = fileObject;  
48.   
49.   
50.     //设置完成例程  
51.      IoSetCompletionRoutine(  
52.             Irp,  
53.             dfSkillSetFileCompletion,  
54.             &event,  
55.             TRUE,  
56.             TRUE,  
57.             TRUE);  
58.     //得到文件对象的内存指针  
59.     pSectionObjectPointer = fileObject->SectionObjectPointer;  
60.     if(pSectionObjectPointer)  
61.     {  
62.         //这两个可以让操作系统以为这个程序不是PE文件  
63.         pSectionObjectPointer->ImageSectionObject = 0;  
64.         pSectionObjectPointer->DataSectionObject = 0;  
65.     }  
66.   
67.   
68.     //下发IRP  
69.     ntStatus = IoCallDriver(DeviceObject, Irp);   
70.     if (!NT_SUCCESS(ntStatus))  
71.     {  
72.          ObDereferenceObject(fileObject);  
73.          ZwClose(handle);  
74.          return FALSE;  
75.     }    
76.     //等待处理结果  
77.     KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);  
78.     //IoFreeIrp(Irp);  
79.     ObDereferenceObject(fileObject);  
80.     ZwClose(handle);  
81.     return TRUE;  
82. .....  

//自定义的完成例程

[cpp]  view plain  copy

1. NTSTATUS  
2. dfSkillSetFileCompletion(  
3.     IN PDEVICE_OBJECT DeviceObject,  
4.     IN PIRP Irp,  
5.     IN PVOID Context  
6.     )  
7. {  
8.     Irp->UserIosb->Status = Irp->IoStatus.Status;  
9.     Irp->UserIosb->Information = Irp->IoStatus.Information;  
10.   
11.   
12.     //设置信号  
13.     KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, FALSE);  
14.     //不用说了吧  
15.     IoFreeIrp(Irp);  
16.   
17.   
18.     return STATUS_MORE_PROCESSING_REQUIRED;//这个设置可以再处理后还可以访问这个IRP 如果不设置这个 在完成后还访问IRP就会BSOD  
19. }  

关于磁盘读写 本人不才 只有思路 因为涉及NTFS 所以要推迟一些了 不过不会太久了

hDrive = CreateFile( "\\\\.\\PHYSICALDRIVE0", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0); 
TCHAR _devicename[] = _T("\\\\.\\C:");


writefile/readfile
CNtfsFileSys::ReadSector(ULONGLONG sector, ULONG count, PVOID buffer) 
WIN7权限问题：DeviceIoControl向逻辑分区发一个FSCTL_LOCK_VOLUME指令，把它“锁住”，然后就可以WriteFile写扇区了 

其它的一些资料

围观注册表穿越操作_Returns' Station

围观文件穿越操作_Returns' Station

NTFS之HARDLINK攻防第二版 - 电脑系统安全 - 红黑联盟

VPB、VCB、FCB、CCB、SCB
http://bbs.pediy.com/showthread.php?t=87741&highlight=ntfs

【原创】NTFS文件系统底层挖掘 - 看雪安全论坛

【文件7】所谓hardlink 所谓XCB大法 - Returns' Station - 博客频道

文件穿越与注册表穿越

打开文件用IoCreateFile
其他比较好发irp的（比如删除操作）走FSD irp
自己实现了所有Nt系列操作文件的功能
文件删除部分有关闭其他进程里的句柄（硬链接无效）
硬链接：mklink /h link.txt gb.txt link.txt是对gb.txt的一个alias，链接计数（删除减一）。硬连接是不能跨卷的，只有在同一文件系统中的文件之间才能创建链接。
软链接（也叫符号链接）与硬链接不同，文件用户数据块中存放的内容是另一文件的路径名的指向。软链接就是一个普通文件，只是数据块内容有点特殊。删除软链接并不影响被指向的文件，但若被指向的原文件被删除，则相关软连接就变成了死链接。   
MJ XCB大法： FCB、 VCB、CCB、SCB 、LCB