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

本文深入探讨了Windows环境下文件删除的实现机制,包括如何通过构建IRP进行文件删除操作,解决文件被占用的问题,并介绍了硬链接和软链接的概念及其区别。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

个人比较崇拜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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值