程序博客网 > linux文件系统书籍

DeviceIoControl 直接从磁盘扇区读文件

来源：互联网 发布：linux文件系统书籍 编辑：程序博客网 时间：2024/06/08 10:44

https://msdn.microsoft.com/en-us/library/windows/desktop/aa365521(v=vs.85).aspx

好久没写博客了，最近看了下DeviceIoControl  关于磁盘的应用，特记一文，以备久后查阅。


首先介绍下，文件在磁盘的存储结构（具体可以到网上查询NTFS文件系统相关的教程后者数据恢复方面教程的介绍）。下面介绍的仅与此文相关。

文件属性（头）：




（Ps: 截图摘自[数据重现文件系统原理精解与数据恢复最佳实践].(马林））

然后我们需要认识两个结构：

[cpp] view plain copy
  1. typedef struct {  
  2.   LARGE_INTEGER StartingVcn;  
  3. } STARTING_VCN_INPUT_BUFFER, *PSTARTING_VCN_INPUT_BUFFER;  

[cpp] view plain copy
  1. typedef struct RETRIEVAL_POINTERS_BUFFER {  
  2.   DWORD         ExtentCount;  
  3.   LARGE_INTEGER StartingVcn;  
  4.   struct {  
  5.     LARGE_INTEGER NextVcn;  
  6.     LARGE_INTEGER Lcn;  
  7.   } Extents[1];  
  8. } RETRIEVAL_POINTERS_BUFFER, *PRETRIEVAL_POINTERS_BUFFER;  

通过使用参数

FSCTL_GET_RETRIEVAL_POINTERS  调用函数DeviceIoControl 我们就可以获得文件在磁盘中的定位信息。
方式如下：
[cpp] view plain copy
 
  1. DeviceIoControl(  
  2.   (HANDLE) hDevice,              // handle to volume  
  3.   FSCTL_GET_RETRIEVAL_POINTERS,  // dwIoControlCode  
  4.   (LPVOID) lpInBuffer,           // input buffer  
  5.   (DWORD) nInBufferSize,         // size of input buffer  
  6.   (LPVOID) lpOutBuffer,          // output buffer  
  7.   (DWORD) nOutBufferSize,        // size of output buffer  
  8.   (LPDWORD) lpBytesReturned,     // number of bytes returned  
  9.   (LPOVERLAPPED) lpOverlapped ); // OVERLAPPED structure  

函数第三个参数对应上述第一个结构，此结构比较简单，需要传入文件的其实Vcn号，这里填入 0 即可 （StartingVcn.QuadPart = 0）。
第二个结构相对复杂些：
由上述介绍可以知道，文件（相对较大的文件）在磁盘中是以簇流（连续的簇）的形式存放的。结构体中 ExtentCount 即表示簇流的个数
StartingVcn 第一个簇流的起始Vcn号， 而每个Extents都包含一个NextVcn号和一个Lcn，Lcn即表示本簇流的起始Lcn，NextVcn是用来判断下一个簇流的位置（通过NextVcn也可以的到上一个簇流的大小）
下面是msdn的解释：
[html] view plain copy
 
  1. NextVcn  
  2. The VCN at which the next extent begins. This value minus either StartingVcn (for the first Extents array member) or the NextVcn of the previous member of the array (for all other Extents array members) is the length, in clusters, of the current extent. The length is an input to the FSCTL_MOVE_FILE operation.  

对于第一个簇流，NextVcn 减去 StartingVcn 即得到第一个簇流的大小，而对于后续的簇流，使用此NextVcn 减去上一个簇流的NextVcn即上一个簇流的大小。
所以根据此信息，我们能够得到文件在磁盘中簇流链的信息，从而定位文件，从磁盘中直接读取文件，具体代码如下（基本参考网上已有代码）：
[cpp] view plain copy
 
  1. //////////////////////////////////////////////////////////////////////////  
  2. /// ReadFileFromSectors.cpp  
  3.   
  4.   
  5. #include <windows.h>  
  6. #include <WinIoCtl.h>  
  7. #include <stdio.h>  
  8.   
  9.   
  10. ULONGLONG *GetFileClusters(PCHAR lpFilename, ULONG *ClusterSize, ULONG *ClusterCount, ULONG *FileSize)  
  11. {  
  12.     HANDLE hFile = NULL;  
  13.     //磁盘基本信息变量定义  
  14.     ULONG SectorsPerCluster;  
  15.     ULONG BytesPerSector;  
  16.   
  17.     STARTING_VCN_INPUT_BUFFER InVcvBuffer;   //输入的开始vcn号  
  18.     PRETRIEVAL_POINTERS_BUFFER pOutFileBuffer;  //输出的结果缓冲区  
  19.     ULONG OutFileSize;  
  20.   
  21.     LARGE_INTEGER PreVcn,Lcn;  
  22.   
  23.     ULONGLONG *Clusters = NULL;  
  24.     BOOLEAN bDeviceIoResult = FALSE;  
  25.   
  26.     //逻辑路径(卷号)  
  27.     char DriverPath[8];  
  28.     memset(DriverPath, 0, sizeof(DriverPath));  
  29.     DriverPath[0] = lpFilename[0];  
  30.     DriverPath[1] = ':';  
  31.     DriverPath[2] = 0;  
  32.     GetDiskFreeSpace(DriverPath, &SectorsPerCluster, &BytesPerSector, NULL, NULL);  
  33.     *ClusterSize = SectorsPerCluster * BytesPerSector;  
  34.   
  35.     //定位文件  
  36.     hFile = CreateFile(lpFilename,  
  37.                     //GENERIC_READ | GENERIC_WRITE,  
  38.                     FILE_READ_ATTRIBUTES,  
  39.                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,  
  40.                     NULL,  
  41.                     OPEN_EXISTING,  
  42.                     0,  
  43.                     0);  
  44.     if(hFile == INVALID_HANDLE_VALUE)  
  45.     {  
  46.         printf("GetFileClusters(): Failed to open file %s ...\n",lpFilename);  
  47.         return 0;  
  48.     }  
  49.     *FileSize = GetFileSize(hFile, NULL);  
  50.     //初始化IO相关参数  
  51.     DWORD dwRead, Cls, CnCount, r;  
  52.     OutFileSize = sizeof(RETRIEVAL_POINTERS_BUFFER) + (*FileSize / *ClusterSize) * sizeof(pOutFileBuffer->Extents);  //个人认为这个结果应该比实际所需的缓冲区大  
  53.     pOutFileBuffer = (PRETRIEVAL_POINTERS_BUFFER)malloc(OutFileSize);  
  54.     InVcvBuffer.StartingVcn.QuadPart = 0;  
  55.     //调用函数后去信息  
  56.     bDeviceIoResult = DeviceIoControl(hFile,  
  57.                                 FSCTL_GET_RETRIEVAL_POINTERS,  
  58.                                 &InVcvBuffer,  
  59.                                 sizeof(InVcvBuffer),  
  60.                                 pOutFileBuffer,  
  61.                                 OutFileSize,  
  62.                                 &dwRead,  
  63.                                 NULL);  
  64.     if(!bDeviceIoResult)  
  65.     {  
  66.         printf("GetFileClusters(): Failed to call DeviceIocontrol with paramter FSCTL_GET_RETRIEVAL_POINTERS...\n|---errorcode = %d\n",GetLastError());  
  67.         CloseHandle(hFile);  
  68.         return 0;  
  69.     }  
  70.   
  71.     *ClusterCount = (*FileSize + *ClusterSize -1) / *ClusterSize;   //Cluster 数组的大小，一个簇占一个元素  
  72.     Clusters = (ULONGLONG *)malloc(*ClusterCount * sizeof(ULONGLONG));   //分配簇数组空间  
  73.   
  74.     //开始遍历返回结果  
  75.     PreVcn = pOutFileBuffer->StartingVcn;  
  76.     for(r=0,Cls=0; r<pOutFileBuffer->ExtentCount; r++)   //ExtentCount 簇流的个数(每个簇流中有几个连续的簇)  
  77.     {  
  78.         Lcn = pOutFileBuffer->Extents[r].Lcn;  
  79.         //簇流中连续簇的个数等于 下一个簇流的起始 Vcn 号 减去 上一个 簇流的 起始 Vcn号   
  80.         for(CnCount = (ULONG)(pOutFileBuffer->Extents[r].NextVcn.QuadPart - PreVcn.QuadPart); CnCount; CnCount--,Cls++,Lcn.QuadPart++)  
  81.         {  
  82.             Clusters[Cls] = Lcn.QuadPart;  //保存每个簇流中簇的 Lcn 号  
  83.         }  
  84.   
  85.         PreVcn = pOutFileBuffer->Extents[r].NextVcn;  
  86.     }  
  87.   
  88.     free(pOutFileBuffer);  
  89.     CloseHandle(hFile);  
  90.     return Clusters;  
  91. }  
  92.   
  93. int ReadFileFromSectors(PCHAR lpFileName, PCHAR pDstFileName)  
  94. {  
  95.     ULONG ClusterSize, BlockSize, ClusterCount, FileSize;  
  96.     ULONGLONG *Clusters = NULL;  
  97.     DWORD dwReads,dwWrites;  
  98.     HANDLE hDriver, hFile;  
  99.     ULONG SectorsPerCluster, BytesPerSector, r;  
  100.     PVOID FileBuff;  //存放从扇区中读取的数据  
  101.     LARGE_INTEGER offset;  
  102.     char DrivePath[10];  
  103.     Clusters = GetFileClusters(lpFileName, &ClusterSize, &ClusterCount, &FileSize);  
  104.     if(Clusters == NULL)  
  105.     {  
  106.         printf("ReadFileFromSectors(): Failed to GetFileClusters ...\n|---errrorcode = %d\n",GetLastError());  
  107.         return 0;  
  108.     }  
  109.     DrivePath[0] = '\\';  
  110.     DrivePath[1] = '\\';  
  111.     DrivePath[2] = '.';  
  112.     DrivePath[3] = '\\';  
  113.     DrivePath[4] = lpFileName[0];  
  114.     DrivePath[5] = ':';  
  115.     DrivePath[6] = 0;  
  116.     //打开磁盘卷  
  117.     hDriver = CreateFile(DrivePath,  
  118.                     GENERIC_READ,  
  119.                     FILE_SHARE_READ | FILE_SHARE_WRITE,  
  120.                     NULL,  
  121.                     OPEN_EXISTING,  
  122.                     0,  
  123.                     NULL);  
  124.     if(hDriver == INVALID_HANDLE_VALUE)  
  125.     {  
  126.         printf("ReadFileFromSectors(): Failed to CreateFile %s ...\n|---errrorcode = %d\n",DrivePath,GetLastError());  
  127.         return 0;  
  128.     }  
  129.     //存放读出的文件  
  130.     hFile = CreateFile(pDstFileName, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);  
  131.     if(hFile == INVALID_HANDLE_VALUE)  
  132.     {  
  133.         printf("ReadFileFromSectors(): Failed to CreateFile %s ...\n|---errrorcode = %d\n",pDstFileName,GetLastError());  
  134.         return 0;  
  135.     }  
  136.   
  137.   
  138.     FileBuff = malloc(ClusterSize);  
  139.     //开始读扇区文件内容  
  140.     for (r=0; r<ClusterCount; r++, FileSize -= BlockSize)  
  141.     {  
  142.         offset.QuadPart = ClusterSize * Clusters[r];    //确定每个簇的偏移  
  143.         SetFilePointer(hDriver, offset.LowPart, &offset.HighPart, FILE_BEGIN);  
  144.         ReadFile(hDriver, FileBuff, ClusterSize, &dwReads, NULL);  //每次读一个簇的大小  
  145.         BlockSize = FileSize < ClusterSize ? FileSize : ClusterSize;  
  146.         WriteFile(hFile, FileBuff, BlockSize, &dwWrites, NULL);  //将读取的文件保存起来  
  147.     }  
  148.     free(FileBuff);  
  149.     free(Clusters);  
  150.     CloseHandle(hFile);  
  151.     CloseHandle(hDriver);  
  152. }  
  153.   
  154. //--------------------------------------------------------------------  
  155. //  
  156. // Usage  
  157. //  
  158. // Tell user how to use the program.  
  159. //  
  160. //--------------------------------------------------------------------  
  161. int Usage( CHAR *ProgramName )   
  162. {  
  163.     printf("\nusage: %s -f srcfile dstfile ...\n", ProgramName );  
  164.     return -1;  
  165. }  
  166.   
  167. int main(int argc, char *argv[])  
  168. {  
  169.     if(argc != 4)  
  170.     {  
  171.         Usage(argv[0]);  
  172.         return 0;  
  173.     }  
  174.   
  175.     //读文件  
  176.     if(strcmp(argv[1], "-f") == 0)  
  177.     {  
  178.         ReadFileFromSectors(argv[2], argv[3]);  
  179.     }  
  180.     else  
  181.     {  
  182.         Usage(argv[0]);  
  183.     }  
  184.   
  185.     system("pause");  
  186.     return 1;  
  187. }  


编译程序，以管理员权限运行，测试结果如下：
Ps： 此方法还有些弊端，文件不能使加密、压缩的文件，而且文件必须是非常驻的（相对大些的文件即要有自己的簇），对于常驻的（小文件），文件内容直接存放到文件的MFT中，此方法是读不到的。
取得文件所在磁盘的扇区大小
  1. int GetSectorSize(LPCWSTR Path) {  
  2.     wchar_t buf[MAX_PATH + 1] = { L"" };  
  3.     DWORD SecPerClu, BytePerSec, NumFreeClu, TotalClu;  
  4.     UINT  DriveType;  
  5.   
  6.     if (GetFullPathName(Path, MAX_PATH, buf, NULL) == 0) { return 0; }  
  7.     if (!buf[0])                                         { return 0; }  
  8.     buf[3] = 0x00;        
  9.   
  10.     DriveType = GetDriveType(buf);  
  11.     if (DriveType != DRIVE_FIXED && DriveType != DRIVE_REMOVABLE) { return 0; }  
  12.   
  13.     if (GetDiskFreeSpace(buf, &SecPerClu, &BytePerSec, &NumFreeClu, &TotalClu)) {  
  14.         return ((int)BytePerSec);  
  15.     }  
  16.     return 0;  
  17. }  
直接读取扇区来拷贝文件的例子
使用函数
DeviceIoControl(hFile, FSCTL_GET_RETRIEVAL_POINTERS, &InBuf,  
  sizeof(InBuf), OutBuf, OutSize, &Bytes, NULL))
就可以查询文件的簇链

下面是个例如直接读取扇区来拷贝文件的例子
用法：FileCopy("C://boot.ini", "D://boot.ini");
C/C++ code
ULONGLONG *GetFileClusters(    LPCSTR lpFileName,    ULONG ClusterSize,     ULONG *ClCount,    ULONG *FileSize     ){    HANDLE  hFile;    ULONG   OutSize;    ULONG   Bytes, Cls, CnCount, r;    ULONGLONG *Clusters = NULL;    BOOLEAN Result = FALSE;    LARGE_INTEGER PrevVCN, Lcn;    STARTING_VCN_INPUT_BUFFER  InBuf;    PRETRIEVAL_POINTERS_BUFFER OutBuf;    hFile = CreateFile(lpFileName, FILE_READ_ATTRIBUTES,                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,                       NULL, OPEN_EXISTING, 0, 0);    if (hFile != INVALID_HANDLE_VALUE)    {        *FileSize = GetFileSize(hFile, NULL);        OutSize = sizeof(RETRIEVAL_POINTERS_BUFFER) + (*FileSize / ClusterSize) * sizeof(OutBuf->Extents);        OutBuf = (PRETRIEVAL_POINTERS_BUFFER)malloc(OutSize);        InBuf.StartingVcn.QuadPart = 0;                if (DeviceIoControl(hFile, FSCTL_GET_RETRIEVAL_POINTERS, &InBuf,                             sizeof(InBuf), OutBuf, OutSize, &Bytes, NULL))        {            *ClCount = (*FileSize + ClusterSize - 1) / ClusterSize;            Clusters = (PULONGLONG)malloc(*ClCount * sizeof(ULONGLONG));            PrevVCN = OutBuf->StartingVcn;            for (r = 0, Cls = 0; r < OutBuf->ExtentCount; r++)            {                Lcn = OutBuf->Extents[r].Lcn;                for (CnCount = (ULONG)(OutBuf->Extents[r].NextVcn.QuadPart - PrevVCN.QuadPart);                     CnCount; CnCount--, Cls++, Lcn.QuadPart++) Clusters[Cls] = Lcn.QuadPart;                PrevVCN = OutBuf->Extents[r].NextVcn;            }        }                    free(OutBuf);            CloseHandle(hFile);    }        return Clusters;}BOOL FileCopy(LPCSTR lpSrcName, LPCSTR lpDstName){    BOOL bResult = FALSE;    ULONG         ClusterSize, BlockSize;    ULONGLONG    *Clusters;    ULONG         ClCount, FileSize, Bytes;    HANDLE        hDrive, hFile;    ULONG         SecPerCl, BtPerSec, r;    PVOID         Buff;    LARGE_INTEGER Offset;    CHAR          Name[7];        Name[0] = lpSrcName[0];    Name[1] = ':';    Name[2] = 0;    GetDiskFreeSpace(Name, &SecPerCl, &BtPerSec, NULL, NULL);    ClusterSize = SecPerCl * BtPerSec;    Clusters = GetFileClusters(lpSrcName, ClusterSize, &ClCount, &FileSize);    if(Clusters)    {        Name[0] = '//';        Name[1] = '//';        Name[2] = '.';        Name[3] = '//';        Name[4] = lpSrcName[0];        Name[5] = ':';        Name[6] = 0;        hDrive = CreateFile(Name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);        if (hDrive != INVALID_HANDLE_VALUE)        {            hFile = CreateFile(lpDstName, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);            if (hFile != INVALID_HANDLE_VALUE)            {                Buff = malloc(ClusterSize);                for (r = 0; r < ClCount; r++, FileSize -= BlockSize)                {                    Offset.QuadPart = ClusterSize * Clusters[r];                    SetFilePointer(hDrive, Offset.LowPart, &Offset.HighPart, FILE_BEGIN);                    ReadFile(hDrive, Buff, ClusterSize, &Bytes, NULL);                    BlockSize = FileSize < ClusterSize ? FileSize : ClusterSize;                    WriteFile(hFile, Buff, BlockSize, &Bytes, NULL);                }                free(Buff);                CloseHandle(hFile);                bResult = TRUE;            }            CloseHandle(hDrive);        }        free(Clusters);    }    else    {        printf("GetFileClusters fail./n");    }    return bResult;}
 
 
  
  
阅读全文
                                             
        0        0           
	
				
		









 linux文件系统书籍
    		linux文件系统书籍



原创粉丝点击



		

热门IT博客


excel数据分析工具箱excel数据分析工具箱




python代码示例python代码示例




淘宝滑动验证码源码




域名注册解析




长江证券 mac




sqlserver enterprise




阴阳师挂机软件ios




自动生成条码软件




网络主播黑名单有谁




虚拟光驱for mac 破解




手机淘宝安全中心在哪




windows缩小图片大小




磁贴数据库已损坏




ubuntu进程查看




超级奇门排盘软件




北邮人论坛 知乎




c语言default的用法




mp3剪切合并大师 mac




传感器数据采集系统




美国网络恐怖组织



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    刁狐狸和傻狐狸
    刁曼岛
    河清村
    刁海明
    小花爱学刁
    刁爱青照片
    南京刁爱青
    刁爱青碎尸案图
    刁爱青小肠
    刁爱青图片
    刁爱青凶手
    刁爱青死后照片
    刁爱青煮熟的头
    刁爱青的案子破了吗
    李昌钰对刁爱青结局
    南京大学刁爱青碎尸案
    刁爱青吧
    刁琳宇
    刁琳琳
    刁笔顺
    刁艾青
    刁读音
    刁铺镇
    刁难的拼音
    双刃战士
    20级破极兵刃换装表
    鬼灭之刃善逸
    鬼灭之刃我妻善逸
    鬼灭之刃我妻善逸图片
    鬼灭之刃善逸图片
    鬼灭之刃妻善逸超帅图片
    鬼灭之刃图片善逸
    鬼灭之刃妻善逸高清图片
    鬼灭之刃善逸帅气图片
    半齿格斗刃
    刃齿虎
    毁灭刃齿虎
    异度之刃2龙之胃
    丝分缕解
    丝分缕析
    重庆亚一分拔中心在哪里


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里