NTFS文件系统详解之文件定位+NTFS文件系统结构--从零开始追踪一个文件的位置＋NTFS的目录和文件

NTFS文件系统详解

NTFS (New Technology File System)，是 WindowsNT 环境的文件系统。新技术文件系统是Windows NT家族（如，Windows 2000、Windows XP、Windows Vista、Windows 7和 windows 8.1）等的限制级专用的文件系统（操作系统所在的盘符的文件系统必须格式化为NTFS的文件系统，4096簇环境下）。NTFS取代了老式的FAT文件系统。

NTFS对FAT和HPFS作了若干改进，例如，支持元数据，并且使用了高级数据结构，以便于改善性能、可靠性和磁盘空间利用率，并提供了若干附加扩展功能。NTFS文件系统拥有以下特点:

安全性高：NTFS支持基于文件或目录的ACL，并且支持加密文件系统（EFS）。

可恢复性：NTFS支持基于原子事务概念的文件恢复，比较符合服务器文件系统的要求。

文件压缩：NTFS支持基于文件或目录的文件压缩，可以很方便的节省磁盘空间。

磁盘配额：NTFS支持磁盘配额，可针对系统中每个用户分配磁盘资源。

一、分析NTFS文件系统的结构

当用户将硬盘的一个分区格式化为NTFS分区时，就建立了一个NTFS文件系统。NTFS文件系统同FAT32文件系统一样，也是用“簇”为存储单位，一个文件总是占用一个或多个簇。

NTFS文件系统使用逻辑簇号（LCN）和虚拟簇号（VCN）对分区进行管理。

逻辑簇号：既对分区内的第一个簇到最后一个簇进行编号，NTFS使用逻辑簇号对簇进行定位。

虚拟簇号：既将文件所占用的簇从开头到尾进行编号的，虚拟簇号不要求在物理上是连续的。

NTFS文件系统一共由16个“元文件”构成，它们是在分区格式化时写入到硬盘的隐藏文件（以”$”开头），也是NTFS文件系统的系统信息。

NTFS的16个元文件介绍：

二、分析$Boot文件

下面我们分析一下DBR中的各参数

EB 52 90：（跳转指令）本身占2字节它将程序执行流程跳转到引导程序处。

“EB 52 90″清楚地指明了OS引导代码的偏移位置。jump 52H加上跳转指令所需的位移量，即开始于0×55。

4E 54 46 53 20 20 20 20:(OEM代号)这部分占8字节，其内容由创建该文件系统的OEM厂商具体安排。为“NTFS”。

BPB：NTFS文件系统的BPB从DBR的第12个字节开始，占用73字节，记录了有关该文件系统的重要信息，

下表中的内容包含了“跳转指令”、“OEM代号”以及“BPB”的参数。

对照上表，对BPB的分析如下:

02 00：每个扇区512个字节

08：每个簇8个扇区

00 00：保留扇区为0

00 00 00：为0

00：不使用

F8：为硬盘

00 00：为0

00 3F：每磁道63个扇区

00 FF：每柱面255个磁头

00 00 00 3F：隐藏扇区数（MBR到DBR）

00 00 00 00：不使用

80 00 80 00：不使用

00 00 00 00 04 FF D5 E5：扇区总数83875301

00 00 00 00 00 0C 00 00：MFT的开始簇号7864320000000000000010：MFT的开始簇号7864320000000000000010：MFTmirr的开始簇号16

00 00 00 F6：每个MFT记录的簇数

00 00 00 01：每索引的簇数

B6 FC 23 AA FC 23 63 B9：分区的逻辑序列号

引导程序：DBR的引导程序占用426字节，其负责完成将系统文件NTLDR装入，对于没有安装系统的分区是无效的。

三、分析$MFT元文件

在NTFS文件系统中，磁盘上的所有数据都是以文件的形式存储，其中包括元文件。每个文件都有一个或多个文件记录，每个文件记录占用两个扇区，而MFT元文件就是专门记录每个文件的文件记录。由于NTFS文件系统是通过MFT元文件就是专门记录每个文件的文件记录。由于NTFS文件系统是通过MFT来确定文件在磁盘上的位置以及文件的属性，所以MFT是非常重要的，MFT是非常重要的，MFT的起始位置在DBR中有描述。MFT的文件记录在物理上是连续的，并且从0开始编号。MFT的文件记录在物理上是连续的，并且从0开始编号。MFT的前16个文件记录总是元文件的，并且顺序是固定不变的。

四、分析文件记录

1、文件记录的结构

文件记录由两部分构成，一部分是文件记录头，另一部分是属性列表，最后结尾是四个“FF”。然后我们根据上面BPB中的MFT偏移簇号786432(786432∗4096(偏移)+63∗512(C盘偏移地址)=3221257728=0xC0007E00)找到系统MFT偏移簇号786432(786432∗4096(偏移)+63∗512(C盘偏移地址)=3221257728=0xC0007E00)找到系统MFT所在地址,查看文件记录格式如下是一个完整的文件记录：

在同一系统中，文件记录头的长度和具体偏移位置的数据含义是不变的，而属性列表是可变的，其不同的属性有着不同的含义。后文将对属性进行具体分析，先来看看文件记录头的信息。

在NTFS文件系统中所有与文件相关的数据结构均被认为是属性，包括文件的内容。文件记录是一个与文件相对应的文件属性数据库，它记录了文件的所有属性。每个文件记录中都有多个属性，他们相对独立，有各自的类型和名称。每个属性都由两部分组成，既属性头和属性体。属性头的前四个字节为属性的类型。从文件记录头可以看到第一个属性流的偏移地址,(C0007E00+0038=C0007E38)如下是以10H属性为例的属性结构

另外属性还有常驻与非常驻之分。当一个文件很小时，其所有属性体都可以存放在文件记录中，该属性就称为常驻属性。如果某个文件很大，1KB的文件记录无法记录所有属性时，则文件系统会在MFT元文件之外的区域(也称数据流)存放该文件的其他文件记录属性，这些存放在非MFT元文件之外的区域(也称数据流)存放该文件的其他文件记录属性，这些存放在非MFT元文件内的记录就称为非常驻属性。

分析属性的属性头

每个属性都有一个属性头，这个属性头包含了一些该属性的重要信息，如属性类型，属性大小，名字(并非都有)及是否为常驻属性等。

常驻属性的属性头分析表：

如下是非常驻属性的属性头分析表：

前面说过了，属性的种类有很多，因此各属性体的含义也不同。下表是NTFS文件系统中的所有属性体的简介。

接下来来看几个重要的属性：

分析10H属性：

10H类型属性它包含文件的一些基本信息，如文件的传统属性，文件的创建时间和最后修改时间和日期，文件的硬链接数等等。如下：是一个10H类型的属性。

其中偏移0×20处的文件属性解释如下：

分析20H属性

20H类型属性既属性列表，当一个文件需要好几个文件记录时，才会用到20H属性。20H属性记录了一个文件的下一个文件记录的位置。如下：是20H属性的解释。

分析30H属性

30H类型属，该属性用于存储文件名，它总是常驻属性。最少68字节，最大578字节，可容纳最大Unicode字符的文件名长度。

分析80H属性

80H属性是文件数据属性，该属性容纳着文件的内容，文件的大小一般指的就是未命名数据流的大小。该属性没有最大最小限制，最小情况是该属性为常驻属性。常驻属性就不做多的解释了，上面我标记的是一个非常驻的80H属性。

其中，Run List是最难理解，也是最重要的。当属性不能存放完数据，系统就会在NTFS数据区域开辟一个空间存放，这个区域是以簇为单位的。Run List就是记录这个数据区域的起始簇号和大小，一个Run List例子上所示。这个示例中，Run List的值为“32 CC 26 00 00 0C”，因为后面是00H，所以知道已经是结尾。如何解析这个Run List呢？第一个字节是压缩字节，高位和低位相加，3 + 2 = 5，表示这个Data Run信息占用五个字节，其中高位表示起始簇号占用多少个字节，低位表示大小占用的字节数。在这里，起始簇号占用3个字节，值为0C 00 00，大小占用2个字节，值为26 CC。解析后，得到这个数据流起始簇号为C0000，大小为9932簇。

分析90H属性

90H属性是索引根属性，该属性是实现NTFS的B+树索引的根节点，它总是常驻属性。该属性的结构如下图：

索引根的结构如表：

索引头的结构如表：

索引项结构如表：

分析A0H属性

A0属性是索引分配属性，也是一个索引的基本结构，存储着组成索引的B+树目录索引子节点的定位信息。它总是常驻属性。如下：是一个A0H属性的实例。

根据上图A0H属性的“Run List”可以找到索引区域，偏移到索引区域所在的簇，如下图：

起始簇：18265

簇大小：3

起始扇区号 = 该分区的其实扇区 + 簇号 * 每个簇的扇区数也就是

64 + 18265 * 8 = 146124

对了，上面的偏移0×28还要加上0×18 = 0×40.

标准索引头的解释如下：

索引项的解释如下：

到此一些常用属性基本介绍的差不多了。

下面来说下遍历一个分区下面文件列表的思路：

1、定位DBR，通过DBR可以得知“$MFT”的起始簇号及簇的大小。

2、定位“MFT”，找到“MFT”，找到“MFT”后，在其中寻找根目录的文件记录，一般在5号文件记录。

3、在90H属性中得到B+树索引的根节点文件信息，重点在A0属性上。通过属性中的“Run List”定位到其数据流。

4、从“Run List”定位到起始簇后，再分析索引项可以得到文件名等信息。

5、从索引项中可以获取“MFT”的参考号，然后进入到“MFT”的参考号，然后进入到“MFT”找到对应的文件记录。

6、然后再根据80H属性中的数据流就可以找到文件真正的数据了。

NTFS文件系统详解之文件定位

一如既往的叨叨

首先要对硬盘分区(MBR、GPT)和文件系统(NTFS、FAT32等)有一定的认识，要知道MBR扇区以及DBR扇区的基本结构，如果后面遇到不清楚的地方可以参考上一篇文章https://blog.csdn.net/hilavergil/article/details/79270379，如果觉得这个文章不行的话，Emmm...还有Google呢。

接下来的代码目前只适用于MBR格式的分区，如果后面有时间的话再加上GPT的分区定位，实际上GPT的分区表更简洁明了一些。

我尽量少用Windows的Api，从硬盘的MBR扇区(0扇区)开始逐步定位，确定每一个主分区和扩展分区的位置，如果是NTFS分区则定位到MFT，从根目录开始使用DFS进行遍历。

我们的目标是

由于硬盘的分区定位在上面那篇文章已经写过了，因此这篇文章的重点会放在NTFS文件系统的解析上。我们从一个硬盘的MBR扇区开始，定位到一个NTFS分区，然后从NTFS分区的第一个扇区(Boot扇区)开始，逐步分析并定位到该分区中的每个目录和文件。

好了开始写正文

前面那篇文章曾提到过，MBR扇区中的分区表只有四项，当分区数小于等于3的时候，所有的分区都属于主分区，安装操作系统的主分区也叫活动分区，这些在Windows的磁盘管理中都可以看到，MBR扇区中分区表的每一项直接指向该主分区的起始位置，也就是该主分区的DBR扇区。当分区数大于等于4的时候呢怎么办？一般来说这种情况下MBR扇区中分区表的第四项将会指向扩展分区，一个扩展分区可以包含多个逻辑分区，每个逻辑分区都有一个EBR扇区与之对应。而EBR扇区和MBR扇区的结构是一致的，但是在EBR扇区中仅用到了其分区表的前两项，其中第一项指向本逻辑分区的起始偏移(注意逻辑分区是存在于扩展分区内的，见下图)，第二项指向下一个逻辑分区的EBR扇区。如此循环往复，你会发现实际上EBR扇区构成了一个逻辑分区的链表，链表的每一个节点都包含两项，第一项指向该EBR对应的逻辑分区，第二项指向下一个逻辑分区的EBR扇区。最后一个节点的第二项为零，表示此后不再有逻辑分区。

图1 名字可能不太对但结构应该没差

当找到一个NTFS文件系统的分区之后，接下来就可以开始着手遍历目录树和文件了。你可能要问为什么不是FAT32或者其他的分区，因为我只看了NTFS……

第一步：读取NTFS的DBR扇区

DBR扇区的结构在之前那片文章写过了，下面给个DBR的截图。

图2 DBR扇区

图中红色方框里面的数据是MFT的偏移(小端字节序)，即0X 00 00 00 00 00 0C 00 00，单位是簇，即MFT偏移786432个簇(相对于该分区的起始位置而言)，蓝色方框里是每簇的扇区数0X08，黑色方框里是每扇区字节数0X 02 00，即512个字节。有了这些就可以算出MFT偏移的扇区数：786432 乘 8 等于 6291456个扇区，我们转到该分区的第 6291456扇区，就是MFT文件的第一个扇区了。接下来该分析MFT了。

第二步：解析MFT

MFT是什么鬼？百度一下。

图3 ???

不好意思，进错片场了。

图4 MFT主文件表

实际上MFT也是一个文件，在winhex中可以看到它：

图5 WinHex中的MFT文件

也能看到MFT的偏移和我们之前计算的结果时一致的。MFT由一个个表项构成，每一个表项是一个文件记录，大小一般为1KB(两个扇区)，记录着卷中每一个目录和文件的信息，每个文件记录的结构都是固定的，由文件记录头和若干属性构成。下面给一个截图：

图6 一个文件记录

其中，文件记录头的结构定义如下：

// 文件记录头

typedef struct _FILE_RECORD_HEADER {

/*+0x00*/ BYTE Type[4];// 固定值'FILE'

/*+0x04*/ UINT16 USNOffset;// 更新序列号偏移, 与操作系统有关

/*+0x06*/ UINT16 USNCount; // 固定列表大小Size in words of Update Sequence Number & Array (S)

/*+0x08*/ UINT64 Lsn; // 日志文件序列号(LSN)

/*+0x10*/ UINT16 SequenceNumber; // 序列号(用于记录文件被反复使用的次数)

/*+0x12*/ UINT16 LinkCount;// 硬连接数

/*+0x14*/ UINT16 AttributeOffset; // 第一个属性偏移

/*+0x16*/ UINT16 Flags;// flags, 00表示删除文件,01表示正常文件,02表示删除目录,03表示正常目录

/*+0x18*/ UINT32 BytesInUse; // 文件记录实时大小(字节) 当前MFT表项长度,到FFFFFF的长度+4

/*+0x1C*/ UINT32 BytesAllocated; // 文件记录分配大小(字节)

/*+0x20*/ UINT64 BaseFileRecord; // = 0 基础文件记录 File reference to the base FILE record

/*+0x28*/ UINT16 NextAttributeNumber; // 下一个自由ID号

/*+0x2A*/ UINT16 Pading; // 边界

/*+0x2C*/ UINT32 MFTRecordNumber; // windows xp中使用,本MFT记录号

/*+0x30*/ UINT16 USN; // 更新序列号

/*+0x32*/ BYTE UpdateArray[0]; // 更新数组 } FILE_RECORD_HEADER, *pFILE_RECORD_HEADER; ————————————————

原文链接：https://blog.csdn.net/Hilavergil/article/details/82622470

文件记录头后面就是属性了，属性由属性头和属性体构成，有如下几种类型：

图7 属性类型

属性有常驻属性和非常驻属性之分，当一个属性的数据能够在1KB的文件记录中保存的时候，该属性为常驻属性；而当属性的数据无法在文件记录中存放，需要存放到MFT外的其他位置时，该属性为非常驻属性。常驻属性和非常驻属性的头部结构定义如下：

//常驻属性和非常驻属性的公用部分

typedef struct _CommonAttributeHeader {

UINT32 ATTR_Type; //属性类型

UINT32 ATTR_Size; //属性头和属性体的总长度

BYTE ATTR_ResFlag; //是否是常驻属性（0常驻 1非常驻）

BYTE ATTR_NamSz; //属性名的长度

UINT16 ATTR_NamOff; //属性名的偏移相对于属性头

UINT16 ATTR_Flags; //标志（0x0001压缩 0x4000加密 0x8000稀疏）

UINT16 ATTR_Id; //属性唯一ID

}CommonAttributeHeader,*pCommonAttributeHeader;

//常驻属性属性头

typedef struct _ResidentAttributeHeader {

CommonAttributeHeader ATTR_Common;

UINT32 ATTR_DatSz; //属性数据的长度

UINT16 ATTR_DatOff; //属性数据相对于属性头的偏移

BYTE ATTR_Indx; //索引

BYTE ATTR_Resvd; //保留

BYTE ATTR_AttrNam[0];//属性名，Unicode，结尾无0

}ResidentAttributeHeader, *pResidentAttributeHeader;

//非常驻属性属性头

typedef struct _NonResidentAttributeHeader {

CommonAttributeHeader ATTR_Common;

UINT64 ATTR_StartVCN; //本属性中数据流起始虚拟簇号

UINT64 ATTR_EndVCN; //本属性中数据流终止虚拟簇号

UINT16 ATTR_DatOff; //簇流列表相对于属性头的偏移

UINT16 ATTR_CmpSz; //压缩单位 2的N次方

UINT32 ATTR_Resvd;

UINT64 ATTR_AllocSz; //属性分配的大小

UINT64 ATTR_ValidSz; //属性的实际大小

UINT64 ATTR_InitedSz; //属性的初始大小

BYTE ATTR_AttrNam[0];

}NonResidentAttributeHeader, *pNonResidentAttributeHeader; ————————————————

原文链接：https://blog.csdn.net/Hilavergil/article/details/82622470

比较重要的几个属性如0X30文件名属性，其中记录着该目录或者文件的文件名；0X80数据属性记录着文件中的数据；0X90索引根属性，存放着该目录下的子目录和子文件的索引项；当某个目录下的内容比较多，从而导致0X90属性无法完全存放时，0XA0属性会指向一个索引区域，这个索引区域包含了该目录下所有剩余内容的索引项。

比较重要的几个属性的结构定义将在后面给出。

下面是一个90属性和A0属性的截图：

图8 90属性和A0属性

从图上大致也能看出来，90属性中包含了2个目录：Program Files (x86) 和 Users，剩下的其他目录就在A0的属性体所指向的索引区了。索引的具体含义将在后面给出。

前面说过，每一个文件记录都会对应一个目录或者文件，因此，如果我们按顺序读取每一个MFT表项，我们就能得到该卷中所有的文件和目录信息，其中还包括了部分被删除的文件和目录(被删除但未覆盖掉)。但我们的目的并不是目录和文件的简单罗列，我们要的是按照目录的树形结构去列出该卷的目录树，并且去定位某一个给定的文件，读出文件的数据。因此到这里还不够，继续向下。

由于所有的目录和文件都在MFT中有对应的记录，因此，一个卷中目录和文件的数量越多，MFT的大小就越大，$MFT文件的大小是动态增长的，NTFS默认给MFT分配了该卷的12.5%的存储空间。MFT的前16项(元数据文件)是固定的(现在第九项$Quota基本上不存在了)：

图9 NTFS的元数据文件

有了前面这些基础，接下来我们就能去解析目录树，定位文件位置啦！

大致的思路如下：

首先，MFT的第五项是卷的根目录的文件记录，见上图的$Root项，这是我们遍历的起点。其次，通过根目录的文件记录的90属性和A0属性，可以定位根目录下所有内容的索引项，而这些索引项又指向了它自己的文件记录项(MFT中的一项)，该文件记录的90和A0属性又指向了它的子目录的索引项。所以呢。写个递归呀，我们的目录树就出来啦。这个树形结构大致上是这样的：

图10 一棵树

接下来以E盘中的E:\dir1_0\dir2_0\dir3_1\新建文本文档.txt为例，一步步详细的写出遍历的步骤，并读取出这个文本文档中的数据。

第三步：得到根目录的文件记录

前面我们通过计算得到，MFT的偏移为6,291,456个扇区，而根目录的文件记录是MFT的第5项，一个MFT表项占2个扇区，所以根目录的文件记录的偏移为6,291,456 + 2 * 5 = 6,291,466个扇区。转到该扇区，可以看到根目录的文件记录如下：

图11 根目录的文件记录

其中，30属性的属性体结构定义如下(不包含属性头)：

//FILE_NAME 0X30属性体

typedef struct _FILE_NAME {

UINT64 FN_ParentFR; /*父目录的MFT记录的记录索引。

注意：该值的低6字节是MFT记录号，高2字节是该MFT记录的序列号*/

FILETIME FN_CreatTime;

FILETIME FN_AlterTime;

FILETIME FN_MFTChg;

FILETIME FN_ReadTime;

UINT64 FN_AllocSz;

UINT64 FN_ValidSz;//文件的真实尺寸

UINT32 FN_DOSAttr;//DOS文件属性

UINT32 FN_EA_Reparse;//扩展属性与链接

BYTE FN_NameSz;//文件名的字符数

BYTE FN_NamSpace;/*命名空间，该值可为以下值中的任意一个

0：POSIX　可以使用除NULL和分隔符“/”之外的所有UNICODE字符，最大可以使用255个字符。注意：“：”是合法字符，但Windows不允许使用。

1：Win32　Win32是POSIX的一个子集，不区分大小写，可以使用除““”、“＊”、“?”、“：”、“/”、“<”、“>”、“/”、“|”之外的任意UNICODE字符，但名字不能以“.”或空格结尾。

2：DOS　DOS命名空间是Win32的子集，只支持ASCII码大于空格的8BIT大写字符并且不支持以下字符““”、“＊”、“?”、“：”、“/”、“<”、“>”、“/”、“|”、“+”、“,”、“;”、“=”；同时名字必须按以下格式命名：1~8个字符，然后是“.”，然后再是1~3个字符。

3：Win32&DOS　这个命名空间意味着Win32和DOS文件名都存放在同一个文件名属性中。*/

BYTE FN_FileName[0];

}FILE_NAME,*pFILE_NAME;

对照上图，可以得到根目录的文件名为 “ . ”。

第四步：计算根目录下索引项的偏移

90属性的属性体由3部分构成：索引根、索引头和索引项。但是有些情况下90属性中是不存在索引项的(上图的90属性不包含索引项，图8中的90属性包含2个索引项)，这个时候该目录的索引项由A0属性中的data runs指出。90属性体的结构如下(不包含属性头)：

typedef struct _INDEX_HEADER {

UINT32 IH_EntryOff;//第一个目录项的偏移

UINT32 IH_TalSzOfEntries;//目录项的总尺寸(包括索引头和下面的索引项)

UINT32 IH_AllocSize;//目录项分配的尺寸

BYTE IH_Flags;/*标志位，此值可能是以下和值之一：

0x00 小目录(数据存放在根节点的数据区中)

0x01 大目录(需要目录项存储区和索引项位图)*/

BYTE IH_Resvd[3];

}INDEX_HEADER,*pINDEX_HEADER;

//INDEX_ROOT 0X90属性体

typedef struct _INDEX_ROOT {

//索引根

UINT32 IR_AttrType;//属性的类型

UINT32 IR_ColRule;//整理规则

UINT32 IR_EntrySz;//目录项分配尺寸

BYTE IR_ClusPerRec;//每个目录项占用的簇数

BYTE IR_Resvd[3];

//索引头

INDEX_HEADER IH;

//索引项可能不存在

BYTE IR_IndexEntry[0];

}INDEX_ROOT,*pINDEX_ROOT;

由于这里90属性没有索引项，我们直接看A0属性。

A0属性的属性体即为Data Runs，指向若干个索引区域的簇流(若干个物理上连续的簇称为一个簇流)。以上图的Data Runs为例：【11 01 2C 00 00 00 00 00】第一个字节【11】中的第二个1，表示接下来占用“1”个字节，用来存储该簇流占用簇的个数，即紧随其后的一个字节【01】，表示这个簇流占了0X01个簇的空间。第一个字节【11】中的第一个1，表示接下再占用“1”个字节，用来存储该簇流的偏移，即字节【2C】，表示偏移量为0X2C个簇。再往后一个字节为【00】，是结束标志。也就是说，该Data Runs只有一个簇流，而这个簇流包含一个簇，簇流的起始偏移为0X2C个簇，一个簇为8个扇区，即根目录所指向的索引区的偏移为44 * 8 = 352个扇区。

下面再给一个多簇流的data runs：

图12 Data Runs

十六进制的Data Runs 如下：31 05 F9 FF 0B 21 01 4E FF 11 01 12 31 01 12 CA F4 21 02 31 12 21 02 00 48 21 04 C9 0F 21 04 C9 59 31 04 87 11 01 21 08 57 10 00 02 A0 F8 FF FF。下面是对该Data Runs的解析：

图13 Data Runs解析

从上图可以看出，该Data Runs一共包含了10个簇流，其中第一个簇流占用了5个簇，起始偏移为0X0BFFF9，即786425个簇；第二个簇流占用1个簇，相对于第一个簇流偏移【-178】个簇，即第二个簇流起始偏移为786425 – 178 = 786247个簇。接下来的簇流的计算方法是一样的。

第五步：读取索引项

回到图11，我们计算出data runs指向的索引区的偏移为352个扇区，转到第352扇区，即索引区第一个扇区的位置，我们将看到如下数据(只截取了部分索引项)：

图14 索引区域

索引区域占用了若干个簇，每一个簇都包含了两部分：一个标准索引头和若干个标准索引项。这两部分的结构定义如下：

//标准索引头的结构

typedef struct _STD_INDEX_HEADER {

BYTE SIH_Flag[4]; //固定值 "INDX"

UINT16 SIH_USNOffset;//更新序列号偏移

UINT16 SIH_USNSize;//更新序列号和更新数组大小

UINT64 SIH_Lsn; // 日志文件序列号(LSN)

UINT64 SIH_IndexCacheVCN;//本索引缓冲区在索引分配中的VCN

UINT32 SIH_IndexEntryOffset;//索引项的偏移相对于当前位置

UINT32 SIH_IndexEntrySize;//索引项的大小

UINT32 SIH_IndexEntryAllocSize;//索引项分配的大小

UINT8 SIH_HasLeafNode;//置一表示有子节点

BYTE SIH_Fill[3];//填充

UINT16 SIH_USN;//更新序列号

BYTE SIH_USNArray[0];//更新序列数组

}STD_INDEX_HEADER,*pSTD_INDEX_HEADER;

//标准索引项的结构

typedef struct _STD_INDEX_ENTRY {

UINT64 SIE_MFTReferNumber;//文件的MFT参考号

UINT16 SIE_IndexEntrySize;//索引项的大小

UINT16 SIE_FileNameAttriBodySize;//文件名属性体的大小

UINT16 SIE_IndexFlag;//索引标志

BYTE SIE_Fill[2];//填充

UINT64 SIE_FatherDirMFTReferNumber;//父目录MFT文件参考号

FILETIME SIE_CreatTime;//文件创建时间

FILETIME SIE_AlterTime;//文件最后修改时间

FILETIME SIE_MFTChgTime;//文件记录最后修改时间

FILETIME SIE_ReadTime;//文件最后访问时间

UINT64 SIE_FileAllocSize;//文件分配大小

UINT64 SIE_FileRealSize;//文件实际大小

UINT64 SIE_FileFlag;//文件标志

UINT8 SIE_FileNameSize;//文件名长度

UINT8 SIE_FileNamespace;//文件命名空间

BYTE SIE_FileNameAndFill[0];//文件名和填充

}STD_INDEX_ENTRY,*pSTD_INDEX_ENTRY;

在标准索引头中，几个比较重要的数据如下：

(1)索引项的偏移：即第一个标准索引项的偏移。在上图中为0X 00 00 00 40，这个偏移是相对于当前位置的偏移，即相对于字节【40】而言，偏移0X40个字节。

(2)索引项的大小：表示这个簇中，有效的索引项和索引头的总字节数。在上图中为0X 00 00 0A 80，即2688个字节，超出该范围的索引项为无效的索引项。

我们顺序读取每一个索引项，找到路径E:\dir1_0\dir2_0\dir3_1\新建文本文档.txt中目录dir1_0的索引项：

图15 目录dir1_0的索引项

标准索引项的结构已给出，其中几个重要的数据：

(1)文件的MFT参考号：低6字节是目录或者文件对应的文件记录的编号，由于MFT是顺序存储的，根据该编号可以定位到该文件记录在MFT中的位置。在上图中，目录dir1_0的MFT参考号为0X 00 00 00 00 00 2A，即dir1_0的文件记录是MFT的第0X2A，即第42项。之前已计算出MFT的偏移为6,291,456扇区，每一项占用2个扇区，因此dir1_0的文件记录的偏移为6,291,456 + 2 * 42 = 6291540扇区。

(2)索引项的长度：即本索引项占用的字节数，定义该索引项的边界。

第六步：现在可以递归啦

我们转到第6291540扇区，即dir1_0的文件记录，按照先前的步骤，去解析90属性和A0属性，就能进入下一层目录，再去定位索引项，越来越深，直到列出该目录的树形结构。OK，还是慢慢来，dir1_0的文件记录如下：

图16 dir1_0的文件记录

可以看到，30属性中的文件名为dir1_0，90属性中无索引项，A0属性的data runs为【11 01 2A 00 00 00 00 00】，计算得出dir1_0的索引区占用0X01个簇，偏移为0X2A个簇，即0X2A * 8 = 336扇区，转到336扇区，会看到如下索引数据：

图17 目录dir1_0下的索引项

找到路径E:\dir1_0\dir2_0\dir3_1\新建文本文档.txt中dir2_0的索引项，即上图的标准索引项1。得到dir2_0的文件记录的MFT编号为0X2D，可以计算出dir2_0的文件记录的偏移：MFT的起始偏移+MFT编号*2，即6,291,456 + 0X2D * 2 = 6291546扇区。读取该文件记录：

图18 dir2_0的文件记录

这个和以前有些不一样了，因为dir2_0只有两个子目录，90属性就够用了，因此没有A0属性。上面说过，90属性体由三部分构成：索引根、索引头和索引项。而90属性中的索引项和标准索引项的结构是一致的。接下来呢，我们找到路径E:\dir1_0\dir2_0\dir3_1\新建文本文档.txt中dir3_1的索引项，即上图中的索引项2，像以前一样计算出它的文件记录在MFT的位置并算出偏移扇区……

后面不再列举啦，一直找到新建文本文档.txt的文件记录，如下：

图19 新建文本文档.txt的文件记录

第七步：读取文件内容

对于文件呢，我们关注的是它的80属性，即数据属性。因为这个txt文件比较大，在MFT中无法存放其所有数据，因此这个文件的80属性为非常驻属性，属性体是一个data runs，指向存放该文件数据的簇。这里Data Runs的计算方法和前面是一致的，从上图可以看到，该data runs指向一个簇流，该簇流一共占用了0X 00 A9 89个簇，起始偏移为0X 4C C8 40个簇，即40256000扇区。我们转到该扇区，就可以读取这个txt中存储的数据了，截图如下：

图20 .txt中的数据

到这里我们已经读到了这个文本文档中的数据了。对于小文件而言，常驻的80属性就能够存放它的数据内容，比如下面这个文件：

图21 小文件的80属性

这个文本文档中只有一个字符串“sadfasdfasdf”，能够存放在常驻的80属性中，因此80属性的属性体并不是Data Runs，而是直接存放了文件内容。

嗯，到这里其实也差不多了，后面附上我写的测试代码吧。代码跳过了活动分区，因为活动分区比较活跃，最好是能够先打一个快照再去读取。

也传到github了：https://github.com/Hilaver/NtfsResolution/

如果后面想到了其他的东西再做补充。

下面是主程序的测试代码：

// ConsoleApplication.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"

#include "ntfs.h"

#include "fat32.h"

using namespace std;

//#pragma comment(lib, "Shlwapi.lib")

//#pragma comment(lib, "Kernel32.lib")

//#pragma comment(lib, "version.lib")

#pragma pack(1)

#pragma warning(disable : 4996)

typedef struct _PHY_INFO {

DWORD number;

vectorvols;

}PHY_INFO,*pPHY_INFO;

typedef struct _VCN_LCN_SIZE {

UINT64 VCN;

UINT64 LCN;

UINT64 SIZE;

_VCN_LCN_SIZE() {}

_VCN_LCN_SIZE(UINT64 vcn, UINT64 lcn, UINT64 size) {

this->VCN = vcn;

this->LCN = lcn;

this->SIZE = size;

}

~_VCN_LCN_SIZE() {}

}VCN_LCN_SIZE, *pVCN_LCN_SIZE;

FILE *fp;

//error msg

void GetErrorMessage(DWORD dwErrCode, DWORD dwLanguageId) {//dwLanguageId=0

DWORD dwRet = 0;

LPTSTR szResult = NULL;

setlocale(LC_ALL, "chs");

dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,

dwErrCode, dwLanguageId, (LPTSTR)&szResult, 0, NULL);

if (dwRet == 0) { szResult = NULL; _tprintf(_T("No such errorCode\n")); }

else { _tprintf(_T("%s"), szResult); }

szResult = NULL;

return;

}

//char to WCHAR

WCHAR * charToWCHAR(char *s) {

int w_nlen = MultiByteToWideChar(CP_ACP, 0, s, -1, NULL, 0);

WCHAR *ret;

ret = (WCHAR*)malloc(sizeof(WCHAR)*w_nlen);

memset(ret, 0, sizeof(ret));

MultiByteToWideChar(CP_ACP, 0, s, -1, ret, w_nlen);

return ret;

}

//读取物理磁盘

//物理磁盘设备号起始偏移(Byte) 读取长度(最小一个扇区) 输出缓冲

DWORD ReadDisk(DWORD physicalDriverNumber, UINT64 startOffset, DWORD size, PVOID ret) {

OVERLAPPED over = { 0 };

over.Offset = startOffset & (0xFFFFFFFF);

over.OffsetHigh = (startOffset >> 32)&(0xFFFFFFFF);

CHAR PHYSICALDRIVE[MAX_PATH]; memset(PHYSICALDRIVE, 0, sizeof(PHYSICALDRIVE));

strcpy(PHYSICALDRIVE, "\\\\.\\PHYSICALDRIVE");

PHYSICALDRIVE[strlen(PHYSICALDRIVE)] = '0' + physicalDriverNumber;

LPCWSTR PD = charToWCHAR(PHYSICALDRIVE);

HANDLE handle = CreateFile(PD, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (handle == INVALID_HANDLE_VALUE) return 0;

DWORD readsize;

if (ReadFile(handle, ret, size, &readsize, &over) == 0){

CloseHandle(handle);return 0;

}

CloseHandle(handle);

return readsize;

}

//根据逻辑分区获取其物理磁盘设备号

DWORD GetPhysicalDriveFromPartitionLetter(TCHAR letter)

{

HANDLE hDevice; // handle to the drive to be examined

BOOL result; // results flag

DWORD readed; // discard results

STORAGE_DEVICE_NUMBER number; //use this to get disk numbers

CHAR path[MAX_PATH];

sprintf(path, "\\\\.\\%c:", letter);

//printf("%s\n", path);

hDevice = CreateFile(charToWCHAR(path), // drive to open

GENERIC_READ | GENERIC_WRITE,// access to the drive

FILE_SHARE_READ | FILE_SHARE_WRITE,//share mode

NULL, // default security attributes

OPEN_EXISTING,// disposition

0,// file attributes

NULL);// do not copy file attribute

if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive

{

GetErrorMessage(GetLastError(), 0);

//fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());

return DWORD(-1);

}

result = DeviceIoControl(

hDevice,// handle to device

IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode

NULL,// lpInBuffer

0, // nInBufferSize

&number, // output buffer

sizeof(number), // size of output buffer

&readed, // number of bytes returned

NULL // OVERLAPPED structure

);

if (!result) // fail

{

fprintf(stderr, "IOCTL_STORAGE_GET_DEVICE_NUMBER Error: %ld\n", GetLastError());

(void)CloseHandle(hDevice);

return (DWORD)-1;

}

//printf("DeviceType(设备类型) is %d, DeviceNumber(物理设备号) is %d, PartitionNumber(分区号) is %d\n", number.DeviceType, number.DeviceNumber, number.PartitionNumber);

(void)CloseHandle(hDevice);

return number.DeviceNumber;

}

//获取逻辑分区的信息如卷标、空间等

void getVolumeInfo(LPCWSTR volumeName) {

DWORD dwTotalClusters;//总的簇

DWORD dwFreeClusters;//可用的簇

DWORD dwSectPerClust;//每个簇有多少个扇区

DWORD dwBytesPerSect;//每个扇区有多少个字节

BOOL bResult = GetDiskFreeSpace((volumeName), &dwSectPerClust, &dwBytesPerSect, &dwFreeClusters, &dwTotalClusters);

printf(("总簇数:%d\n可用簇数:%d\n簇内扇区数:%d\n扇区内字节数:%d\n"), dwTotalClusters, dwFreeClusters, dwSectPerClust, dwBytesPerSect);

//GetErrorMessage(GetLastError(),0);

}

//print buffer in byte

void printBuffer(PVOID buffer, __int64 size) {

BYTE *p = (BYTE*)buffer;

__int64 pos = 0;

while (pos < size) {

fprintf(fp,"%+02X ", *(p++));

//printf("%+02X ", *(p++));

if (++pos % 16 == 0) { fprintf(fp,"\n"); /*printf("\n");*/}

}

void printBuffer2(PVOID buffer, __int64 size) {

BYTE *p = (BYTE*)buffer;

__int64 pos = 0;

while (pos < size) {

/*fprintf(fp, "%+02X ", *(p++));*/

printf("%+02X ", *(p++));

if (++pos % 16 == 0) { /*fprintf(fp, "\n");*/ printf("\n"); }

}

//不固定字节数的number转为带符号的INT64

INT64 Bytes2Int64(BYTE *num,UINT8 bytesCnt) {

INT64 ret = 0; bool isNegative = false;

memcpy(&ret, num, bytesCnt);

if (ret&(1 << (bytesCnt * 8 - 1))) {

isNegative = true;

INT64 tmp = (INT64(0X01)) << bytesCnt * 8;

for (int i = 0; i < 64 - bytesCnt * 8; i++) {

ret |= (tmp);

tmp <<= 1;

}

return isNegative ? -(~(ret)+1) : ret;

}

//获取物理磁盘设备号

vectorgetPhyDriverNumber() {

//这个地方应该有更好的实现方法

vectorphyvols[32];

DWORD dwSize = GetLogicalDriveStrings(0, NULL);

char* drivers = (char*)malloc(dwSize * 2);

DWORD dwRet = GetLogicalDriveStrings(dwSize, (LPWSTR)drivers);

wchar_t* lp = (wchar_t*)drivers;//所有逻辑驱动器的根驱动器路径用0隔开

DWORD tmpNum = 0;

while (*lp) {

tmpNum = GetPhysicalDriveFromPartitionLetter(lp[0]);

phyvols[tmpNum].push_back(lp[0]);

lp += (wcslen(lp) + 1);//下一个根驱动器路径

}

vectortmpPhyInfo;

for (int i = 0; i < 32; i++) {

if (phyvols[i].size() != 0) {

PHY_INFO tmp;

tmp.number = i;

tmp.vols = phyvols[i];

tmpPhyInfo.push_back(tmp);

}

return tmpPhyInfo;

}

void parseMFTEntry(PVOID MFTEntry, DWORD IndexEntrySize,

DWORD phyDriverNumber, UINT64 volByteOffset, UINT8 secPerCluster,

UINT64 mftOffset, WCHAR *filePath);

void dfsIndexEntry(PVOID IndexEntryBuf, DWORD IndexEntrySize,

DWORD phyDriverNumber, UINT64 volByteOffset, UINT8 secPerCluster,

UINT64 mftOffset, WCHAR *filePath);

//DFS 索引项

//索引项物理磁盘设备号每个簇的扇区数卷的物理偏移(字节) MFT的相对偏移(相对于本分区)

void dfsIndexEntry(PVOID IndexEntryBuf, DWORD IndexEntrySize,

DWORD phyDriverNumber, UINT64 volByteOffset, UINT8 secPerCluster, UINT64 mftOffset, WCHAR *filePath) {

printf("dfsIndexEntry\n");

//getchar();

//printf("IndexEntryBuf:\n");

//printBuffer2(IndexEntryBuf, IndexEntrySize);

//printf("\n");

//getchar();

pSTD_INDEX_ENTRY ptrIndexEntry = (pSTD_INDEX_ENTRY)IndexEntryBuf;

//BYTE *ptrOfIndexEntry = (BYTE*)IndexEntryBuf;

//获取MFT编号

UINT64 mftReferNumber = (ptrIndexEntry->SIE_MFTReferNumber) & 0XFFFFFFFFFFFF;//取低六字节

printf("SIE_MFTReferNumber is 0X%X\n", mftReferNumber);

fprintf(fp,"SIE_MFTReferNumber is 0X%X\n", mftReferNumber);

//读取文件名

//ptrOfIndexEntry = ptrIndexEntry->SIE_FileNameAndFill;

//UINT32 fileNameBytes = (ptrIndexEntry->SIE_FileNameSize) * 2;

//WCHAR *fileName = (WCHAR *)malloc(fileNameBytes + 2);

//memset(fileName, 0, fileNameBytes + 2);

//memcpy(fileName, ptrIndexEntry->SIE_FileNameAndFill, fileNameBytes);

//printf("SIE_FileName is %ls\n", fileName);

//读取该索引项对应的MFT

UINT64 mftEntryByteOffset = mftReferNumber * MFTEntrySize + mftOffset + volByteOffset;

printf("mftOffset is %llu\n", mftOffset);

printf("volByteOffset is %llu\n", volByteOffset);

printf("mftEntryByteOffset is %llu\n", mftEntryByteOffset);

PVOID mftEntryBuf = malloc(MFTEntrySize);

ReadDisk(phyDriverNumber, mftEntryByteOffset, MFTEntrySize, mftEntryBuf);

//printf("mftEntryBuf:\n");

//printBuffer2(mftEntryBuf, MFTEntrySize);

//printf("\n");

//getchar();

//解析MFT的0X90 0XA0属性

parseMFTEntry(mftEntryBuf, MFTEntrySize, phyDriverNumber, volByteOffset, secPerCluster, mftOffset, filePath);

}

//解析MFT表项获取0X90 0XA0属性

//MFT表项物理设备号卷物理偏移(字节) 每个簇的扇区数

void parseMFTEntry(PVOID MFTEntry, DWORD IndexEntrySize, DWORD phyDriverNumber,

UINT64 volByteOffset, UINT8 secPerCluster, UINT64 mftOffset, WCHAR *filePath) {

printf("parseMFTEntry\n");

//getchar();

//printf("MFTEntry:\n");

//printBuffer2(MFTEntry, MFTEntrySize);

//printf("\n");

//getchar();

pFILE_RECORD_HEADER MFTEntryHeader = (pFILE_RECORD_HEADER)malloc(sizeof(FILE_RECORD_HEADER));

memcpy(MFTEntryHeader, MFTEntry, sizeof(FILE_RECORD_HEADER));

fprintf(fp, "MFTEntry : BytesAllocated is %u\n", MFTEntryHeader->BytesAllocated);

fprintf(fp, "MFTEntry : BytesInUse is %u\n", MFTEntryHeader->BytesInUse);

fprintf(fp,"MFTEntry : MFTRecordNumber is 0X%0X\n", UINT32((MFTEntryHeader->MFTRecordNumber)));

////

printf("MFTEntry : BytesAllocated is %u\n", MFTEntryHeader->BytesAllocated);

printf("MFTEntry : BytesInUse is %u\n", MFTEntryHeader->BytesInUse);

printf("MFTEntry : MFTRecordNumber is 0X%X\n", UINT32((MFTEntryHeader->MFTRecordNumber)));

////

//UINT32 MFTEntryNumber = MFTEntryHeader->MFTRecordNumber;

//printBuffer2(MFTEntryHeader, sizeof(FILE_RECORD_HEADER));

UINT16 attriOffset = MFTEntryHeader->AttributeOffset;//第一个属性偏移

printf("MFTEntry : AttributeOffset is %hu\n", MFTEntryHeader->AttributeOffset);

UINT8 *pointerInMFTEntry;

pointerInMFTEntry = (UINT8*)MFTEntry;

pointerInMFTEntry += attriOffset;

BYTE *pIndexOfMFTEntry = (BYTE*)MFTEntry;

pIndexOfMFTEntry += attriOffset;//pIndexOfMFTEntry偏移MFT头部大小指向第一个属性头

UINT32 attriType, attriLen;

//BYTE ATTR_ResFlagAttri;

//get attribute

pCommonAttributeHeader pComAttriHeader = (pCommonAttributeHeader)malloc(sizeof(CommonAttributeHeader));

//存放目录下所有索引项的vector

vectorindexEntryOfDir;

//一个set 删除重复索引项

mapvisMftReferNum;

bool finishFlag = FALSE;

UINT32 attrCnt = 0;

//file path

WCHAR currentFilePath[2048] = { 0 };

//MFT项的类型 00表示删除文件,01表示正常文件,02表示删除目录,03表示正常目录

printf("isDirectoryOrFile[00删除文件,01正常文件,02删除目录,03正常目录]: %hu\n", MFTEntryHeader->Flags);

while (TRUE) {

//pIndexOfMFTEntry 现在指向属性头，后面会加上这个属性的总长指向下一个属性头

memcpy(&attriType, pIndexOfMFTEntry, 4);//attri type

if (attriType == 0xFFFFFFFF) { fprintf(fp, "\nATTR_Type is 0xFFFFFFFF, break\n"); break; }

fprintf(fp, "\nattrCnt : %u\n", attrCnt++);

fprintf(fp, "##### AttributeHeader #####\n");

memset(pComAttriHeader, 0, sizeof(CommonAttributeHeader));

//属性头的通用部分

memcpy(pComAttriHeader, pIndexOfMFTEntry, sizeof(CommonAttributeHeader));

fprintf(fp, "ATTR_Type is 0X%XATTR_Size is %d\n", pComAttriHeader->ATTR_Type, pComAttriHeader->ATTR_Size);

//如果属性总长>1024 先break

if (pComAttriHeader->ATTR_Size > 0x400) { fprintf(fp, "\attriLen is more than 1024, break\n"); break; }

fprintf(fp, "ATTR_NamOff is %huATTR_NamSz is %d", pComAttriHeader->ATTR_NamOff, pComAttriHeader->ATTR_NamSz);

//如果当前指针偏移大于MFT已用字节数 break

if ((pIndexOfMFTEntry - MFTEntry) > MFTEntryHeader->BytesInUse) {

fprintf(fp, "\nreach end of BytesInUse, break\n");

break;

}

//resolve attribute header

UINT16 attriHeaderSize = 0;

bool isResidentAttri = false;

switch (pComAttriHeader->ATTR_ResFlag)//是否常驻属性

{

case BYTE(0x00): {

isResidentAttri = true;

//get attribute header

pResidentAttributeHeader residentAttriHeader = (pResidentAttributeHeader)malloc(sizeof(ResidentAttributeHeader));

memcpy(residentAttriHeader, pIndexOfMFTEntry, sizeof(ResidentAttributeHeader));

fprintf(fp, "\n\n常驻属性\n\n");

//fprintf(fp, "ATTR_Size is %u\n", residentAttriHeader->ATTR_Size);

fprintf(fp, "ATTR_DatOff[属性头长度] is %hu\n", residentAttriHeader->ATTR_DatOff);

attriHeaderSize = residentAttriHeader->ATTR_DatOff;

UINT16 ResidentAttributeHeaderSize = residentAttriHeader->ATTR_DatOff;

residentAttriHeader = (pResidentAttributeHeader)realloc(residentAttriHeader, ResidentAttributeHeaderSize);

memcpy(residentAttriHeader, pIndexOfMFTEntry, ResidentAttributeHeaderSize);

//fprintf(fp, "ATTR_AttrNam[属性名] is %ls\n", residentAttriHeader->ATTR_AttrNam);

fprintf(fp, "ATTR_DatSz[属性体长度] is %u\n", residentAttriHeader->ATTR_DatSz);

fprintf(fp, "ATTR_Indx[属性索引] is %u\n", residentAttriHeader->ATTR_Indx);

break;

}

case BYTE(0x01): {

isResidentAttri = false;

//get attribute header

fprintf(fp, "\n\n非常驻属性\n\n");

pNonResidentAttributeHeader nonResidentAttriHeader = (pNonResidentAttributeHeader)malloc(sizeof(NonResidentAttributeHeader));

memcpy(nonResidentAttriHeader, pIndexOfMFTEntry, sizeof(NonResidentAttributeHeader));

//fprintf(fp, "\n\n非常驻属性\nATTR_Type is 0x%X\n", nonResidentAttriHeader->ATTR_Type);

fprintf(fp, "ATTR_DatOff[属性头长度] is %hu\n", nonResidentAttriHeader->ATTR_DatOff);

attriHeaderSize = nonResidentAttriHeader->ATTR_DatOff;

UINT16 NonResidentAttributeHeaderSize = nonResidentAttriHeader->ATTR_DatOff;

nonResidentAttriHeader = (pNonResidentAttributeHeader)realloc(nonResidentAttriHeader, NonResidentAttributeHeaderSize);

memcpy(nonResidentAttriHeader, pIndexOfMFTEntry, NonResidentAttributeHeaderSize);

fprintf(fp, "ATTR_StartVCN[起始VCN] is %llu\n", nonResidentAttriHeader->ATTR_StartVCN);

fprintf(fp, "ATTR_EndVCN[终止VCN] is %llu\n", nonResidentAttriHeader->ATTR_EndVCN);

fprintf(fp, "ATTR_ValidSz[属性实际长度 is %llu\n", nonResidentAttriHeader->ATTR_ValidSz);

fprintf(fp, "ATTR_AllocSz[属性分配长度] is %llu\n", nonResidentAttriHeader->ATTR_AllocSz);

fprintf(fp, "ATTR_InitedSz[属性初始长度] is %llu\n", nonResidentAttriHeader->ATTR_InitedSz);

//fprintf(fp, "ATTR_AttrNam[属性名] is %ls\n", nonResidentAttriHeader->ATTR_AttrNam);

break;

}

default:

break;

}

fprintf(fp, "\n##### END of AttributeHeader #####\n");

//resolve attribute data

BYTE *tmpAttriDataIndex = pIndexOfMFTEntry;

//待修改

//tmpAttriDataIndex += (pComAttriHeader->ATTR_ResFlag == BYTE(0x00) ? sizeof(ResidentAttributeHeader) : sizeof(NonResidentAttributeHeader));

tmpAttriDataIndex += (attriHeaderSize);

//tmpAttriDataIndex指向属性体

switch (pComAttriHeader->ATTR_Type)

{

case 0x00000030: {

//文件名属性可能多个

pFILE_NAME ptrFileName = (pFILE_NAME)malloc(sizeof(FILE_NAME));

memcpy(ptrFileName, tmpAttriDataIndex, sizeof(FILE_NAME));

if (ptrFileName->FN_NamSpace == 0X02) { break; }

fprintf(fp, "\n##### FILE_NAME #####\n");

printf("\n##### FILE_NAME #####\n");

fprintf(fp, "FN_NameSz is %d\n", ptrFileName->FN_NameSz);

printf("FN_NameSz is %d\n", ptrFileName->FN_NameSz);

fprintf(fp, "FN_NamSpace is %d\n", ptrFileName->FN_NamSpace);

printf("FN_NamSpace is %d\n", ptrFileName->FN_NamSpace);

//get file name

UINT32 fileNameLen = UINT32(0xFFFF & (ptrFileName->FN_NameSz) + 1) << 1;

WCHAR *fileName = (WCHAR*)malloc(fileNameLen);

memset(fileName, 0, fileNameLen);

memcpy(fileName, tmpAttriDataIndex + sizeof(FILE_NAME), fileNameLen - 2);

//printf("FILENAME[0X] is:\n");

//printBuffer2(fileName, fileNameLen);

//printf("\n");

fprintf(fp, "FILENAME is %ls\n", fileName);

printf("FILENAME is %ls\n", fileName);

memset(currentFilePath, 0, sizeof(currentFilePath));

wcscpy(currentFilePath, filePath);

wcscat(currentFilePath,L"\\");

wcscat(currentFilePath, fileName);

printf("\n\n------>\ncurrentFilePath is %ls\n", currentFilePath);

fprintf(fp, "---> currentFilePath is %ls\n", currentFilePath);

fprintf(fp, "\n##### END of FILE_NAME #####\n");

printf("\n##### END of FILE_NAME #####\n");

getchar();

break;

}

case 0x00000090: {//INDEX_ROOT 索引根

pINDEX_ROOT pIndexRoot = (INDEX_ROOT*)malloc(sizeof(INDEX_ROOT));

memcpy(pIndexRoot, tmpAttriDataIndex, sizeof(INDEX_ROOT));

fprintf(fp, "\n##### INDEX_ROOT #####\n");

fprintf(fp, "IR_EntrySz[目录项的大小,一般是一个簇] is %u\n", pIndexRoot->IR_EntrySz);

fprintf(fp, "IR_ClusPerRec[目录项占用的簇数,一般是一个] is %u\n", pIndexRoot->IR_ClusPerRec);

fprintf(fp, "IH_TalSzOfEntries[索引根和紧随其后的索引项的大小] is %u\n", pIndexRoot->IH.IH_TalSzOfEntries);

fprintf(fp, "IH_EntryOff[第一个索引项的偏移] is %u\n", pIndexRoot->IH.IH_EntryOff);

printf("\n##### INDEX_ROOT #####\n");

printf("IR_EntrySz[目录项的大小,一般是一个簇] is %u\n", pIndexRoot->IR_EntrySz);

printf("IR_ClusPerRec[目录项占用的簇数,一般是一个] is %u\n", pIndexRoot->IR_ClusPerRec);

printf("IH_TalSzOfEntries[索引根和紧随其后的索引项的大小] is %u\n", pIndexRoot->IH.IH_TalSzOfEntries);

printf("IH_EntryOff[第一个索引项的偏移] is %u\n", pIndexRoot->IH.IH_EntryOff);

//0X90属性的实际大小

UINT32 attri90Size = sizeof(INDEX_ROOT) - sizeof(INDEX_HEADER) + pIndexRoot->IH.IH_TalSzOfEntries;

pIndexRoot = (INDEX_ROOT*)realloc(pIndexRoot, attri90Size);

memcpy(pIndexRoot, tmpAttriDataIndex, attri90Size);

//获取90属性中的索引头

INDEX_HEADER IR_IH = pIndexRoot->IH;

UINT32 indexTotalSize = pIndexRoot->IH.IH_TalSzOfEntries;//索引头和接下来的索引项的总大小注意可能没有索引项

//获取90属性中的索引项

BYTE *pIndexOfEntry, *ptrIndexHeaderStart;//索引项的指针索引头的指针

pIndexOfEntry = pIndexRoot->IR_IndexEntry;

ptrIndexHeaderStart = (BYTE*)(&(pIndexRoot->IH));

UINT32 indexEntryIn90AttriCnt = 0;

while (TRUE) {

UINT64 isIndexEntryFinish = 0;

memcpy(&isIndexEntryFinish, pIndexOfEntry, 8);

if (isIndexEntryFinish == 0X00) {

//MFT号是0 break

break;

}

if (pIndexOfEntry - ptrIndexHeaderStart > indexTotalSize) {

//超出有效长度 break

break;

}

INDEX_ENTRY *pIndexEntry = (INDEX_ENTRY *)pIndexOfEntry;

//printf("IE_FileNameSize is %d\n", pIndexEntry->IE_FileNameSize);

UINT32 fileNameBytes = (pIndexEntry->IE_FileNameSize) * 2;

WCHAR *fileName = (WCHAR *)malloc(fileNameBytes + 2);

memset(fileName, 0, fileNameBytes + 2);

memcpy(fileName, pIndexEntry->IE_FileNameAndFill, fileNameBytes);

//printf("IE_FileName is %ls\n", fileName);

indexEntryIn90AttriCnt++;

//printBuffer2(pIndexEntry, pIndexEntry->IE_Size);

//printf("\n");

//getchar();

/*******************************/

if (visMftReferNum.find((pIndexEntry->IE_MftReferNumber) & 0XFFFFFFFFFFFF) == visMftReferNum.end() && ((((pIndexEntry->IE_MftReferNumber) >> (8 * 6)) & 0XFFFF) != 0X00)) {

// $ObjId的索引项正常但其指向的MFT的90属性异常其中该MFT号的高2位为0 90属性中的MFT引用号异常

//这里读到了索引项

printf("find index entry in 90 attribute, cnt is %d\n", indexEntryIn90AttriCnt);

fprintf(fp, "find index entry in 90 attribute, cnt is %d\n", indexEntryIn90AttriCnt);

indexEntryOfDir.push_back(pSTD_INDEX_ENTRY(pIndexEntry));

visMftReferNum.insert(pair((pIndexEntry->IE_MftReferNumber) & 0XFFFFFFFFFFFF, TRUE));

}

//dfsIndexEntry((PVOID)pIndexEntry, pIndexEntry->IE_Size, phyDriverNumber, volByteOffset, secPerCluster, mftOffset);

/*******************************/

pIndexOfEntry += pIndexEntry->IE_Size;

//getchar();

}

printf("\n##### END of INDEX_ROOT #####\n");

break;

}

case 0x000000A0: {//INDEX_ALLOCATION

fprintf(fp, "\n##### INDEX_ALLOCATION #####\n");

printf("\n##### INDEX_ALLOCATION #####\n");

//A0属性体

//存放VCN LCN

vectordataRuns;

//data runs 起始指针

BYTE *dataRunsStartOffset = tmpAttriDataIndex;

//data runs 总字节数

UINT32 attriBodySize = (pIndexOfMFTEntry + pComAttriHeader->ATTR_Size) - tmpAttriDataIndex;

//printf("attriBodySize is %u\n", attriBodySize);

//getchar();

UINT64 vcnCnt = 0;

while ((*dataRunsStartOffset) != 0X00 && dataRunsStartOffset - tmpAttriDataIndex < attriBodySize) {

UINT8 bytesClustersOfStdIndex = (*dataRunsStartOffset) & 0X0F, bytesCluOffsetOfStdIndex = (*dataRunsStartOffset >> 4) & 0X0F;

UINT32 totalBytes = bytesClustersOfStdIndex + bytesCluOffsetOfStdIndex;

//VCN.push_back(vcnCnt++);

UINT64 clustersOfStdIndex = 0;

INT64 cluOffsetOfStdIndex = 0;

//BYTE *ptrInDataRuns = (BYTE *)(&dataRuns);

memcpy(&clustersOfStdIndex, dataRunsStartOffset + 1, bytesClustersOfStdIndex);

//memcpy(&cluOffsetOfStdIndex, dataRunsStartOffset + 1 + bytesClustersOfStdIndex, bytesCluOffsetOfStdIndex);

cluOffsetOfStdIndex = Bytes2Int64(dataRunsStartOffset + 1 + bytesClustersOfStdIndex, bytesCluOffsetOfStdIndex);

//printf("Bytes2Int64 is %lld\n",Bytes2Int64(dataRunsStartOffset + 1 + bytesClustersOfStdIndex, bytesCluOffsetOfStdIndex));

if (vcnCnt == 0) {

dataRuns.push_back(VCN_LCN_SIZE(vcnCnt, cluOffsetOfStdIndex, clustersOfStdIndex));

}

else {

dataRuns.push_back(VCN_LCN_SIZE(vcnCnt, dataRuns[vcnCnt-1].LCN + cluOffsetOfStdIndex, clustersOfStdIndex));

}

vcnCnt++;

dataRunsStartOffset += (totalBytes + 1);

}

printf("-->INDEX_ALLOCATION Cluster Info\n");

for (int i = 0; i < dataRuns.size(); i++) {

printf("VCN, LCN, SIZE: %llu, %llu, %llu\n",dataRuns[i].VCN, dataRuns[i].LCN, dataRuns[i].SIZE);

}

printf("-->End of INDEX_ALLOCATION Cluster Info\n");

getchar();

for (int i = 0; i < dataRuns.size(); i++) {

DWORD stdIndexSize = dataRuns[i].SIZE * secPerCluster*SectorSize;//标准索引占用的总字节数

UINT64 stdIndexByteOffset = volByteOffset + dataRuns[i].LCN * secPerCluster*SectorSize;//标准索引的物理偏移

//读取标准索引区的数据该data run 的N个簇全部读取

PVOID pStdIndexBuffer = malloc(stdIndexSize);

ReadDisk(phyDriverNumber, stdIndexByteOffset, stdIndexSize, pStdIndexBuffer);

fprintf(fp, "->data run cnt: %d\n", i);

printf("->data run cnt: %d\n", i);

UINT32 indexClusterCnt = 0;

//逐个簇分析

UINT32 indexEntryInIndxArea = 0;

while (indexClusterCnt < dataRuns[i].SIZE) {

fprintf(fp, "->cluster cnt: %d\n", indexClusterCnt);

printf("->cluster cnt: %d\n", indexClusterCnt);

//读取标准索引的头部

BYTE *ptrOfStdIndexBuffer = (BYTE*)pStdIndexBuffer + (indexClusterCnt*secPerCluster*SectorSize);//标准索引的指针

indexClusterCnt++;

//ptrIndex指向该索引簇的起始位置

BYTE *ptrIndex = ptrOfStdIndexBuffer;

pSTD_INDEX_HEADER pStdIndexHeader = (pSTD_INDEX_HEADER)malloc(sizeof(STD_INDEX_HEADER));

memcpy(pStdIndexHeader, ptrOfStdIndexBuffer, sizeof(STD_INDEX_HEADER));

UINT32 SIH_Flag;

memcpy(&SIH_Flag, pStdIndexHeader->SIH_Flag, 4);

if (SIH_Flag == 0X00000000) { break; }

//标准索引头的大小=第一个索引项的偏移+24字节

UINT32 stdIndexHeaderSize = pStdIndexHeader->SIH_IndexEntryOffset + 8 * 3;

pStdIndexHeader = (pSTD_INDEX_HEADER)realloc(pStdIndexHeader, stdIndexHeaderSize);

memcpy(pStdIndexHeader, ptrOfStdIndexBuffer, stdIndexHeaderSize);

//print

fprintf(fp, "\n##### STD_INDEX_HEADER #####\n");

fprintf(fp, "SIH_IndexEntryOffset[索引项偏移,从此位置开始] is %u\n", pStdIndexHeader->SIH_IndexEntryOffset);

fprintf(fp, "SIH_IndexEntrySize[索引项总大小] is %u\n", pStdIndexHeader->SIH_IndexEntrySize);

printf("\n##### STD_INDEX_HEADER #####\n");

printf("SIH_IndexEntryOffset[索引项偏移,从此位置开始] is %u\n", pStdIndexHeader->SIH_IndexEntryOffset);

printf("SIH_IndexEntrySize[索引项总大小] is %u\n", pStdIndexHeader->SIH_IndexEntrySize);

UINT32 stdIndexTotalSize = pStdIndexHeader->SIH_IndexEntrySize;

printf("SIH_IndexEntryAllocSize[索引项总分配大小] is %u\n", pStdIndexHeader->SIH_IndexEntryAllocSize);

printf("\n##### END of STD_INDEX_HEADER #####\n");

fprintf(fp, "SIH_IndexEntryAllocSize[索引项总分配大小] is %u\n", pStdIndexHeader->SIH_IndexEntryAllocSize);

fprintf(fp, "\n##### END of STD_INDEX_HEADER #####\n");

//指针移动到索引项

ptrOfStdIndexBuffer += stdIndexHeaderSize;

//BYTE *ptrIndexEntryStartOffset = ptrOfStdIndexBuffer;

while (TRUE) {

//MFT编号为0 break

UINT64 isIndexEntryFinish = 0;

memcpy(&isIndexEntryFinish, ptrOfStdIndexBuffer, 8);

//超出有效长度 break

if (ptrOfStdIndexBuffer - ptrIndex > stdIndexTotalSize) {

fprintf(fp, "超出INDEX有效范围, break\n");

printf("超出INDEX有效范围, break\n");

break;

}

//if (isIndexEntryFinish == UINT64(0)) { break; }

if (isIndexEntryFinish == UINT64(0)) { fprintf(fp, "find mft refer number[00]\n"); }

if (isIndexEntryFinish == UINT64(0)) { printf("find mft refer number[00]\n"); }

//printf("ptrOfStdIndexBuffer - ptrIndexEntryStartOffset is %d\n", ptrOfStdIndexBuffer - ptrIndexEntryStartOffset);

//逐个读取索引项

pSTD_INDEX_ENTRY pStdIndexEntry = (pSTD_INDEX_ENTRY)malloc(sizeof(STD_INDEX_ENTRY));

memcpy(pStdIndexEntry, ptrOfStdIndexBuffer, sizeof(STD_INDEX_ENTRY));

UINT32 stdIndexEntrySize = pStdIndexEntry->SIE_IndexEntrySize;

pStdIndexEntry = (pSTD_INDEX_ENTRY)realloc(pStdIndexEntry, stdIndexEntrySize);

memcpy(pStdIndexEntry, ptrOfStdIndexBuffer, stdIndexEntrySize);

if (pStdIndexEntry->SIE_MFTReferNumber == UINT64(0)) { break; }

//printf("\n##### STD_INDEX_ENTRY #####\n");

//fprintf(fp, "\n");

//printBuffer(pStdIndexEntry, stdIndexEntrySize);

//fprintf(fp, "\n");

//printf("SIE_MFTReferNumber is %d\n", (pStdIndexEntry->SIE_MFTReferNumber) & 0XFFFFFFFFFFFF);

//printf("SIE_IndexEntrySize[索引项大小] is %u\n", (pStdIndexEntry->SIE_IndexEntrySize));

//printf("SIE_FileNameSize is %d\n", (pStdIndexEntry->SIE_FileNameSize));

//printf("SIE_FileAllocSize is %llu\n", (pStdIndexEntry->SIE_FileAllocSize));

//printf("SIE_FileRealSize is %llu\n", (pStdIndexEntry->SIE_FileRealSize));

//UINT8 fileNameBytes = (pStdIndexEntry->SIE_FileNameSize) * 2;

//WCHAR *fileName = (WCHAR *)malloc(fileNameBytes + 2);

//memcpy(fileName, pStdIndexEntry->SIE_FileNameAndFill, fileNameBytes);

//printf("SIE_FileName is %ls\n", fileName);

//printf("\n##### END of STD_INDEX_ENTRY #####\n");

//这里读到了索引项

/********************************/

if (visMftReferNum.find((pStdIndexEntry->SIE_MFTReferNumber) & 0XFFFFFFFFFFFF) == visMftReferNum.end() && ((((pStdIndexEntry->SIE_MFTReferNumber) >> (8 * 6)) & 0XFFFF) != 0X00)) {

printf("find index entry in INDX area, cnt is %d\n", indexEntryInIndxArea);

fprintf(fp, "find index entry in INDX area, cnt is %d\n", indexEntryInIndxArea);

indexEntryInIndxArea++;

indexEntryOfDir.push_back(pSTD_INDEX_ENTRY(pStdIndexEntry));

visMftReferNum.insert(pair((pStdIndexEntry->SIE_MFTReferNumber) & 0XFFFFFFFFFFFF, TRUE));

}

//dfsIndexEntry((PVOID)pStdIndexEntry, stdIndexEntrySize, phyDriverNumber, volByteOffset, secPerCluster, mftOffset);

/********************************/

//ptrOfStdIndexBuffer指向下一个索引项

ptrOfStdIndexBuffer += stdIndexEntrySize;

//getchar();

}

//printBuffer2(pStdIndexBuffer, stdIndexSize);

//getchar();

//fprintf(fp, "\n##### END of INDEX_ALLOCATION #####\n");

//printf("\n##### END of INDEX_ALLOCATION #####\n");

}

fprintf(fp,"\n##### END of INDEX_ALLOCATION #####\n");

printf("\n##### END of INDEX_ALLOCATION #####\n");

break;

}

case 0x00000010: {

break;

}

case 0x00000020: {

break;

}

case 0x00000040: {

break;

}

case 0x00000050: {

break;

}

case 0x00000060: {

break;

}

case 0x00000070: {

break;

}

case 0x00000080: {

//文件数据属性

//80属性体长度

UINT32 attriBodySize = (pIndexOfMFTEntry + pComAttriHeader->ATTR_Size) - tmpAttriDataIndex;

//属性体

pDATA ptrData = (pDATA)malloc(attriBodySize);

memcpy(ptrData, tmpAttriDataIndex, attriBodySize);

//如果是常驻属性 80属性体就是文件内容

if (isResidentAttri) {

//80属性体中的文件内容

printf("content in 0X80[resident]:\n");

printBuffer2(ptrData, attriBodySize);

printf("\n");

}

//如果是非常驻属性 80属性体是data runs

else {

printf("content in 0X80[nonresident]:\n");

printBuffer2(ptrData, attriBodySize);

printf("\n");

//存放VCN LCN

vectordataRuns;

//data runs 起始指针

BYTE *dataRunsStartOffset = tmpAttriDataIndex;

//data runs 总字节数

UINT32 attriBodySize = (pIndexOfMFTEntry + pComAttriHeader->ATTR_Size) - tmpAttriDataIndex;

//printf("attriBodySize is %u\n", attriBodySize);

//getchar();

UINT64 vcnCnt = 0;

while ((*dataRunsStartOffset) != 0X00 && dataRunsStartOffset - tmpAttriDataIndex < attriBodySize) {

UINT8 bytesClustersOfStdIndex = (*dataRunsStartOffset) & 0X0F, bytesCluOffsetOfStdIndex = (*dataRunsStartOffset >> 4) & 0X0F;

UINT32 totalBytes = bytesClustersOfStdIndex + bytesCluOffsetOfStdIndex;

//VCN.push_back(vcnCnt++);

UINT64 clustersOfStdIndex = 0;

INT64 cluOffsetOfStdIndex = 0;

//BYTE *ptrInDataRuns = (BYTE *)(&dataRuns);

memcpy(&clustersOfStdIndex, dataRunsStartOffset + 1, bytesClustersOfStdIndex);

//memcpy(&cluOffsetOfStdIndex, dataRunsStartOffset + 1 + bytesClustersOfStdIndex, bytesCluOffsetOfStdIndex);

cluOffsetOfStdIndex = Bytes2Int64(dataRunsStartOffset + 1 + bytesClustersOfStdIndex, bytesCluOffsetOfStdIndex);

//printf("Bytes2Int64 is %lld\n",Bytes2Int64(dataRunsStartOffset + 1 + bytesClustersOfStdIndex, bytesCluOffsetOfStdIndex));

if (vcnCnt == 0) {

dataRuns.push_back(VCN_LCN_SIZE(vcnCnt, cluOffsetOfStdIndex, clustersOfStdIndex));

}

else {

dataRuns.push_back(VCN_LCN_SIZE(vcnCnt, dataRuns[vcnCnt - 1].LCN + cluOffsetOfStdIndex, clustersOfStdIndex));

}

vcnCnt++;

dataRunsStartOffset += (totalBytes + 1);

}

printf("-->DATA Cluster Info\n");

for (int i = 0; i < dataRuns.size(); i++) {

printf("VCN, LCN, SIZE: %llu, %llu, %llu\n", dataRuns[i].VCN, dataRuns[i].LCN, dataRuns[i].SIZE);

}

//拿到了文件每一块的LCN和对应的簇数

//能够直接读取文件内容了

printf("-->End of DATA Cluster Info\n");

getchar();

}

break;

}

case 0x000000B0: {

break;

}

case 0x000000C0: {

break;

}

case 0x000000D0: {

break;

}

case 0x000000E0: {

break;

}

case 0x000000F0: {

break;

}

case 0x00000100: {

break;

}

default: {

finishFlag = TRUE;

break;

}

pIndexOfMFTEntry += pComAttriHeader->ATTR_Size;

if (finishFlag) { break; }

}

for (int i = 0; i < indexEntryOfDir.size(); i++) {

fprintf(fp,"WATCH :: IndexEntryOfDir -> %d:\n", i);

printBuffer(indexEntryOfDir[i], indexEntryOfDir[i]->SIE_IndexEntrySize);

fprintf(fp,"\n");

//printf("WATCH :: IndexEntryOfDir -> %d:\n", i);

//printBuffer2(indexEntryOfDir[i], indexEntryOfDir[i]->SIE_IndexEntrySize);

//printf("\n");

//getchar();

//dfsIndexEntry((PVOID)(indexEntryOfDir[i]), indexEntryOfDir[i]->SIE_IndexEntrySize, phyDriverNumber, volByteOffset, secPerCluster, mftOffset);

}

for (int i = 0; i < indexEntryOfDir.size(); i++) {

//printf("indexEntryOfDir of root:\n");

//printBuffer2(indexEntryOfDir[i], indexEntryOfDir[i]->SIE_IndexEntrySize);

//printf("\n");

//getchar();

fprintf(fp,"begin DFS in Dir\n");

fprintf(fp,"Index Entry Buff:\n");

printBuffer(indexEntryOfDir[i], indexEntryOfDir[i]->SIE_IndexEntrySize);

fprintf(fp,"\n");

printf("begin DFS in Dir\n");

//printf("Index Entry Buff:\n");

//printBuffer2(indexEntryOfDir[i], indexEntryOfDir[i]->SIE_IndexEntrySize);

printf("\n");

if (UINT64((indexEntryOfDir[i]->SIE_MFTReferNumber) & 0XFFFFFFFFFFFF) < 16) {

fprintf(fp,"SIE_MFTReferNumber < 16, continue\n");

//printf("SIE_MFTReferNumber < 16, continue\n");

}

else {

fprintf(fp,"SIE_MFTReferNumber >= 16, begin search\n");

//printf("SIE_MFTReferNumber >= 16, begin search\n");

dfsIndexEntry((PVOID)(indexEntryOfDir[i]), indexEntryOfDir[i]->SIE_IndexEntrySize, phyDriverNumber, volByteOffset, secPerCluster, mftOffset, currentFilePath);

}

//dfsIndexEntry((PVOID)(indexEntryOfDir[i]), indexEntryOfDir[i]->SIE_IndexEntrySize, phyDriverNumber, volByteOffset, secPerCluster, mftOffset);

}

indexEntryOfDir.clear();

visMftReferNum.clear();

//getchar();

}

//解析MFT表项

void resolveMFTEntry(PVOID MFTEntry, DWORD phyDriverNumber, UINT64 volByteOffset, UINT8 secPerCluster, UINT64 mftOffset) {//MFT表项物理设备号卷物理偏移(字节) 每个簇的扇区数 mft相对于该分区的偏移

//printBuffer(MFTEntry, MFTEntrySize);

//get MFTEntryHeader

pFILE_RECORD_HEADER MFTEntryHeader = (pFILE_RECORD_HEADER)malloc(sizeof(FILE_RECORD_HEADER));

memcpy(MFTEntryHeader, MFTEntry, sizeof(FILE_RECORD_HEADER));

fprintf(fp, "MFTEntry : BytesAllocated is %u\n", MFTEntryHeader->BytesAllocated);

fprintf(fp, "MFTEntry : BytesInUse is %u\n", MFTEntryHeader->BytesInUse);

fprintf(fp, "MFTEntry : MFTRecordNumber is %u\n", MFTEntryHeader->MFTRecordNumber);

UINT32 MFTEntryNumber = MFTEntryHeader->MFTRecordNumber;