记录一下NTFS磁盘快速查找

于 2024-11-12 18:39:08 发布
阅读量198 收藏
点赞数 2
分类专栏： 杂项 文章标签： NTFS磁盘快速查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/maomao171314/article/details/143721118
版权 
#define _CRT_SECURE_NO_WARNINGS
#include <Windows.h>
#include <string>
#include <deque>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;

struct FileInfo
{
	DWORDLONG FileRefNo;
	DWORDLONG ParentRefNo;
	DWORD FileAttributes;
	WCHAR Name[MAX_PATH];
};
BOOL ActivateUSNState(HANDLE &hVol, USN_JOURNAL_DATA &journalData)   //激活USN状态
{
	BOOL bUSN = TRUE;
	DWORD br;
	CREATE_USN_JOURNAL_DATA cujd;
	DWORD dwBytes = 0;
	cujd.MaximumSize = 0; // 0表示使用默认值  
	cujd.AllocationDelta = 0; // 0表示使用默认值  
	BOOL status = DeviceIoControl(hVol, FSCTL_CREATE_USN_JOURNAL, &cujd, sizeof(cujd), NULL, 0, &br, NULL);

	if (0 != status)
	{
		BOOL bDioControl = DeviceIoControl(hVol, FSCTL_QUERY_USN_JOURNAL, NULL, 0, &journalData, sizeof(journalData), &dwBytes, NULL);
		if (!bDioControl)
		{
			bUSN = FALSE;
		}
	}
	else
	{
		//USN状态激活失败
		bUSN = FALSE;
	}

	return bUSN;
}
bool EnumUsnRecord(const char* drvname, std::deque<FileInfo>& con)
{
	bool ret = false;

	char FileSystemName[MAX_PATH + 1];
	DWORD MaximumComponentLength;
	if (GetVolumeInformationA((std::string(drvname) + ":\\").c_str(), 0, 0, 0, &MaximumComponentLength, 0, FileSystemName, MAX_PATH + 1)
		&& 0 == strcmp(FileSystemName, "NTFS")) // 判断是否为 NTFS 格式
	{
		HANDLE hVol = CreateFileA((std::string("\\\\.\\") + drvname + ":").c_str() // 需要管理员权限，无奈
			, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
		if (hVol != INVALID_HANDLE_VALUE)
		{
			DWORD br;
			CREATE_USN_JOURNAL_DATA cujd = { 0, 0 };
			if (DeviceIoControl(hVol, FSCTL_CREATE_USN_JOURNAL, &cujd, sizeof(cujd), NULL, 0, &br, NULL)) // 如果创建过，且没有用FSCTL_DELETE_USN_JOURNAL关闭，则可以跳过这一步
			{
				USN_JOURNAL_DATA qujd;
				if (!DeviceIoControl(hVol, FSCTL_QUERY_USN_JOURNAL, NULL, 0, &qujd, sizeof(qujd), &br, NULL))
				{
					int iError = GetLastError();
					if (iError == 1179)     //1179错误 USN状态未激活，需要激活一下
					{
						if (!ActivateUSNState(hVol, qujd))
						{
							CloseHandle(hVol);
							return FALSE;
						}
					}
					else
					{
						CloseHandle(hVol);
						return FALSE;
					}
				}


				{
					char buffer[0x1000]; // 缓冲区越大则DeviceIoControl调用次数越少，即效率越高
					DWORD BytesReturned;
					//{ // 使用FSCTL_READ_USN_JOURNAL可以只搜索指定change reason的记录，比如下面的代码只搜索被删除的文件信息，但即便rujd.ReasonMask设为-1，也列不出所有文件
					//    READ_USN_JOURNAL_DATA rujd = { 0, USN_REASON_FILE_DELETE, 0, 0, 0, qujd.UsnJournalID };
					//    for( ; DeviceIoControl(hVol,FSCTL_READ_USN_JOURNAL,&rujd,sizeof(rujd),buffer,_countof(buffer),&BytesReturned,NULL); rujd.StartUsn=*(USN*)&buffer )
					//    {
					//        DWORD dwRetBytes = BytesReturned - sizeof(USN);
					//        PUSN_RECORD UsnRecord = (PUSN_RECORD)((PCHAR)buffer+sizeof(USN));
					//        if( dwRetBytes==0 )
					//        {
					//            ret = true;
					//            break;
					//        }
					//
					//        while( dwRetBytes > 0 )
					//        {
					//            printf( "FRU %016I64x, PRU %016I64x, %.*S\n", UsnRecord->FileReferenceNumber, UsnRecord->ParentFileReferenceNumber
					//                , UsnRecord->FileNameLength/2, UsnRecord->FileName );
					//
					//            dwRetBytes -= UsnRecord->RecordLength;
					//            UsnRecord = (PUSN_RECORD)( (PCHAR)UsnRecord + UsnRecord->RecordLength );
					//        }
					//    }
					//}
					{ // 使用FSCTL_ENUM_USN_DATA可以列出所有存在的文件信息，但UsnRecord->Reason等信息是无效的
						MFT_ENUM_DATA_V0 med = { 0, 0, qujd.NextUsn }; //vs 2017 及以上版本请使用 MFT_ENUM_DATA_V0  否则DeviceIoControl会报87错误
						//MFT_ENUM_DATA med = { 0, 0, qujd.NextUsn };
						for (; DeviceIoControl(hVol, FSCTL_ENUM_USN_DATA, &med, sizeof(med), buffer, _countof(buffer), &BytesReturned, NULL); 
							med.StartFileReferenceNumber = *(USN*)&buffer)
						{
							DWORD dwRetBytes = BytesReturned - sizeof(USN);
							PUSN_RECORD UsnRecord = (PUSN_RECORD)((PCHAR)buffer + sizeof(USN));

							while (dwRetBytes > 0)
							{
								FileInfo finf;
								finf.FileRefNo = UsnRecord->FileReferenceNumber;
								finf.ParentRefNo = UsnRecord->ParentFileReferenceNumber;
								finf.FileAttributes = UsnRecord->FileAttributes;
								memcpy(finf.Name, UsnRecord->FileName, UsnRecord->FileNameLength);
								finf.Name[UsnRecord->FileNameLength / 2] = L'\0';
								con.push_back(finf);

								dwRetBytes -= UsnRecord->RecordLength;
								UsnRecord = (PUSN_RECORD)((PCHAR)UsnRecord + UsnRecord->RecordLength);
							}
						}
						DWORD dwErr = GetLastError();
						ret = GetLastError() == ERROR_HANDLE_EOF;
					}
					DELETE_USN_JOURNAL_DATA dujd = { qujd.UsnJournalID, USN_DELETE_FLAG_DELETE };
					DeviceIoControl(hVol, FSCTL_DELETE_USN_JOURNAL, &dujd, sizeof(dujd), NULL, 0, &br, NULL); // 关闭USN记录。如果是别人的电脑，当然可以不关^_^
				}
			}
		}
		CloseHandle(hVol);
	}

	return ret;
}

/// 以下为测试代码，输出D盘文件树结构 ///


#define _CRT_SECURE_NO_WARNINGS
struct FileNode
{
	WCHAR name[MAX_PATH];
	DWORD FileAttributes;
	std::vector<FileNode> subs;

	FileNode(const WCHAR* filename, DWORD fileattr) : FileAttributes(fileattr)
	{
		wcscpy_s(name, MAX_PATH, filename);
	}
};

int main()
{
	std::deque<FileInfo> con;// list不利于折半查找
	EnumUsnRecord("D", con);

	// 整理成树
	struct foo1
	{
		bool operator()(const FileInfo& a, const FileInfo& b) const
		{
			if (a.ParentRefNo != b.ParentRefNo)
				return a.ParentRefNo < b.ParentRefNo;
			if ((a.FileAttributes&FILE_ATTRIBUTE_DIRECTORY) != (b.FileAttributes&FILE_ATTRIBUTE_DIRECTORY))
				return (a.FileAttributes&FILE_ATTRIBUTE_DIRECTORY) > (b.FileAttributes&FILE_ATTRIBUTE_DIRECTORY);
			return _wcsicmp(a.Name, b.Name) < 0;
		}
	};
	std::sort(con.begin(), con.end(), foo1());
	FileNode root(L"D:\\", 0);
	std::deque< std::pair<DWORDLONG, std::vector<FileNode>*> > tmp;
	tmp.push_back(std::make_pair(0x5000000000005, &root.subs));
	for (; !tmp.empty(); )
	{
		DWORDLONG ParentRefNo = tmp.front().first;
		std::vector<FileNode>& subs = *tmp.front().second;
		tmp.pop_front();

		struct foo2 {
			bool operator()(DWORDLONG prn, const FileInfo& fi) const { return prn < fi.ParentRefNo; }
			bool operator()(const FileInfo& fi, DWORDLONG prn) const { return fi.ParentRefNo < prn; }
			bool operator()(const FileInfo& a, const FileInfo& b) const { return a.ParentRefNo < b.ParentRefNo; }
		};
		std::pair<std::deque<FileInfo>::iterator, std::deque<FileInfo>::iterator> r = std::equal_range(con.begin(), con.end(), ParentRefNo, foo2());
		subs.reserve(std::distance(r.first, r.second));
		for (std::deque<FileInfo>::iterator itor = r.first; itor != r.second; ++itor)
		{
			FileNode fn(itor->Name, itor->FileAttributes);
			subs.push_back(fn);
			tmp.push_front(std::make_pair(itor->FileRefNo, &subs.back().subs)); // 深度优先
		}
	}
	con.clear();

	// 输出树
	setlocale(LC_CTYPE, "chs");
	std::vector< std::pair<std::vector<FileNode>::iterator, std::vector<FileNode>::iterator> > path;
	printf("%s\n", "D:");
	path.push_back(std::make_pair(root.subs.begin(), root.subs.end()));
	for (; !path.empty(); )
	{
		if (path.back().first != path.back().second)
		{
			printf("%*s%S\n", path.size() * 2, "", path.back().first->name);
			path.push_back(std::make_pair(path.back().first->subs.begin(), path.back().first->subs.end()));
		}
		else
		{
			path.pop_back();
			if (path.empty()) break;
			++path.back().first;
		}
	}

	return 0;
}

// 根据 FileReferenceNumber 直接获得全路径 的方法二
//使用 NtCreatefile 和 NtQueryInformationFile ，但要求这个文件必须存在（in - used）
void GetFullPathByFileReferenceNumber(HANDLE hVol, DWORDLONG FileReferenceNumber)
{
	typedef ULONG(__stdcall *PNtCreateFile)(
		PHANDLE FileHandle,
		ULONG DesiredAccess,
		PVOID ObjectAttributes,
		PVOID IoStatusBlock,
		PLARGE_INTEGER AllocationSize,
		ULONG FileAttributes,
		ULONG ShareAccess,
		ULONG CreateDisposition,
		ULONG CreateOptions,
		PVOID EaBuffer,
		ULONG EaLength);
	PNtCreateFile NtCreatefile = (PNtCreateFile)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtCreateFile");

	typedef struct _UNICODE_STRING {
		USHORT Length, MaximumLength;
		PWCH Buffer;
	} UNICODE_STRING, *PUNICODE_STRING;
	UNICODE_STRING fidstr = { 8, 8, (PWSTR)&FileReferenceNumber };

	typedef struct _OBJECT_ATTRIBUTES {
		ULONG Length;
		HANDLE RootDirectory;
		PUNICODE_STRING ObjectName;
		ULONG Attributes;
		PVOID SecurityDescriptor;
		PVOID SecurityQualityOfService;
	} OBJECT_ATTRIBUTES;
	const ULONG OBJ_CASE_INSENSITIVE = 0x00000040UL;
	OBJECT_ATTRIBUTES oa = { sizeof(OBJECT_ATTRIBUTES), hVol, &fidstr, OBJ_CASE_INSENSITIVE, 0, 0 };

	HANDLE hFile;
	ULONG iosb[2];
	const ULONG FILE_OPEN_BY_FILE_ID = 0x00002000UL;
	const ULONG FILE_OPEN = 0x00000001UL;
	ULONG status = NtCreatefile(&hFile, GENERIC_ALL, &oa, iosb, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_OPEN_BY_FILE_ID, NULL, 0);
	if (status == 0)
	{
		typedef struct _IO_STATUS_BLOCK {
			union {
				NTSTATUS Status;
				PVOID Pointer;
			};
			ULONG_PTR Information;
		} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
		typedef enum _FILE_INFORMATION_CLASS {
			// ……
			FileNameInformation = 9
			// ……
		} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
		typedef NTSTATUS(__stdcall *PNtQueryInformationFile)(
			HANDLE FileHandle,
			PIO_STATUS_BLOCK IoStatusBlock,
			PVOID FileInformation,
			DWORD Length,
			FILE_INFORMATION_CLASS FileInformationClass);
		PNtQueryInformationFile NtQueryInformationFile = (PNtQueryInformationFile)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtQueryInformationFile");

		typedef struct _OBJECT_NAME_INFORMATION {
			UNICODE_STRING Name;
		} OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION;
		IO_STATUS_BLOCK IoStatus;
		size_t allocSize = sizeof(OBJECT_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR);
		POBJECT_NAME_INFORMATION pfni = (POBJECT_NAME_INFORMATION)operator new(allocSize);
		status = NtQueryInformationFile(hFile, &IoStatus, pfni, allocSize, FileNameInformation);
		if (status == 0)
		{
			printf("%.*S\n", pfni->Name.Length / 2, &pfni->Name.Buffer);
		}
		operator delete(pfni);

		CloseHandle(hFile);
	}
}

// 根据 FileReferenceNumber 直接获得全路径 的方法三
//使用 FSCTL_GET_NTFS_FILE_RECORD，但要求这个文件必须存在（in - used）
typedef struct {
	ULONG Type;
	USHORT UsaOffset;
	USHORT UsaCount;
	USN Usn;
} NTFS_RECORD_HEADER, *PNTFS_RECORD_HEADER;

typedef struct {
	NTFS_RECORD_HEADER Ntfs;
	USHORT SequenceNumber;
	USHORT LinkCount;
	USHORT AttributesOffset;
	USHORT Flags;               // 0x0001 = InUse, 0x0002 = Directory
	ULONG BytesInUse;
	ULONG BytesAllocated;
	ULONGLONG BaseFileRecord;
	USHORT NextAttributeNumber;
} FILE_RECORD_HEADER, *PFILE_RECORD_HEADER;

typedef enum {
	AttributeStandardInformation = 0x10,
	AttributeAttributeList = 0x20,
	AttributeFileName = 0x30,
	AttributeObjectId = 0x40,
	AttributeSecurityDescriptor = 0x50,
	AttributeVolumeName = 0x60,
	AttributeVolumeInformation = 0x70,
	AttributeData = 0x80,
	AttributeIndexRoot = 0x90,
	AttributeIndexAllocation = 0xA0,
	AttributeBitmap = 0xB0,
	AttributeReparsePoint = 0xC0,
	AttributeEAInformation = 0xD0,
	AttributeEA = 0xE0,
	AttributePropertySet = 0xF0,
	AttributeLoggedUtilityStream = 0x100
} ATTRIBUTE_TYPE, *PATTRIBUTE_TYPE;

typedef struct {
	ATTRIBUTE_TYPE AttributeType;
	ULONG Length;
	BOOLEAN Nonresident;
	UCHAR NameLength;
	USHORT NameOffset;
	USHORT Flags;               // 0x0001 = Compressed
	USHORT AttributeNumber;
} ATTRIBUTE, *PATTRIBUTE;

typedef struct {
	ATTRIBUTE Attribute;
	ULONGLONG LowVcn;
	ULONGLONG HighVcn;
	USHORT RunArrayOffset;
	UCHAR CompressionUnit;
	UCHAR AlignmentOrReserved[5];
	ULONGLONG AllocatedSize;
	ULONGLONG DataSize;
	ULONGLONG InitializedSize;
	ULONGLONG CompressedSize;    // Only when compressed
} NONRESIDENT_ATTRIBUTE, *PNONRESIDENT_ATTRIBUTE;

typedef struct {
	ATTRIBUTE Attribute;
	ULONG ValueLength;
	USHORT ValueOffset;
	USHORT Flags;               // 0x0001 = Indexed
} RESIDENT_ATTRIBUTE, *PRESIDENT_ATTRIBUTE;

typedef struct {
	ULONGLONG CreationTime;
	ULONGLONG ChangeTime;
	ULONGLONG LastWriteTime;
	ULONGLONG LastAccessTime;
	ULONG FileAttributes;
	ULONG AlignmentOrReservedOrUnknown[3];
	ULONG QuotaId;                        // NTFS 3.0 only
	ULONG SecurityId;                     // NTFS 3.0 only
	ULONGLONG QuotaCharge;                // NTFS 3.0 only
	USN Usn;                              // NTFS 3.0 only
} STANDARD_INFORMATION, *PSTANDARD_INFORMATION;

typedef struct {
	ULONGLONG DirectoryFileReferenceNumber;
	ULONGLONG CreationTime;   // Saved when filename last changed
	ULONGLONG ChangeTime;     // ditto
	ULONGLONG LastWriteTime;  // ditto
	ULONGLONG LastAccessTime; // ditto
	ULONGLONG AllocatedSize;  // ditto
	ULONGLONG DataSize;       // ditto
	ULONG FileAttributes;     // ditto
	ULONG AlignmentOrReserved;
	UCHAR NameLength;
	UCHAR NameType;           // 0x01 = Long, 0x02 = Short
	WCHAR Name[1];
} FILENAME_ATTRIBUTE, *PFILENAME_ATTRIBUTE;
/*
bool GetFullPathByFileReferenceNumber(HANDLE hVol, DWORDLONG FileReferenceNumber)
{
	if ((FileReferenceNumber & 0x0000FFFFFFFFFFFF) == 5)
		return true;

	bool ret = false;
	DWORD BytesReturned;
	NTFS_VOLUME_DATA_BUFFER nvdb;
	if (DeviceIoControl(hVol, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0
		, &nvdb, sizeof(nvdb), &BytesReturned, NULL)) // 仅是事例，没有作优化 1.作为递归调用，这一步应当提取出来 2.如果多次调用，DirectoryFileReferenceNumber没必要被重复获取
	{
		NTFS_FILE_RECORD_INPUT_BUFFER nfrib;
		nfrib.FileReferenceNumber.QuadPart = FileReferenceNumber;
		size_t len = sizeof(NTFS_FILE_RECORD_OUTPUT_BUFFER) + nvdb.BytesPerFileRecordSegment - 1;
		NTFS_FILE_RECORD_OUTPUT_BUFFER* nfrob = (PNTFS_FILE_RECORD_OUTPUT_BUFFER)operator new(len);
		if (DeviceIoControl(hVol, FSCTL_GET_NTFS_FILE_RECORD, &nfrib, sizeof(nfrib)
			, nfrob, len, &BytesReturned, NULL))
		{
			if ((nfrib.FileReferenceNumber.QuadPart & 0x0000FFFFFFFFFFFF) == nfrob->FileReferenceNumber.QuadPart) // a 48-bit index and a 16-bit sequence number
			{
				PFILE_RECORD_HEADER frh = (PFILE_RECORD_HEADER)nfrob->FileRecordBuffer;
				for (PATTRIBUTE attr = (PATTRIBUTE)((LPBYTE)frh + frh->AttributesOffset); attr->AttributeType != -1; attr = (PATTRIBUTE)((LPBYTE)attr + attr->Length))
				{
					if (attr->AttributeType == AttributeFileName)
					{
						PFILENAME_ATTRIBUTE name = (PFILENAME_ATTRIBUTE)((LPBYTE)attr + PRESIDENT_ATTRIBUTE(attr)->ValueOffset);
						if ((name->NameType & 1) == 1) // long name
						{
							if (GetFullPathByFileReferenceNumber(hVol, name->DirectoryFileReferenceNumber))
							{
								printf("\\%.*S", name->NameLength, name->Name);
								ret = true;
							}
						}
					}
				}
			}
		}
		operator delete(nfrob);
	}
	return ret;
}
*/

基于NTFS磁盘快速查找 - 依米荼蘼的博客 | yimitumi | yimitumi.com

NTFS格式及其在编程中的应用
DevGlider的博客
09-29 236
它是Windows操作系统中最常用的文件系统之一，具有许多优点，例如可靠性、安全性和性能优化。它是一个特殊的文件，用于存储文件和目录的元数据，例如文件名、创建时间、修改时间和文件权限等。在编程中，我们可以通过读取和解析MFT、访问文件属性以及读写文件数据，与NTFS文件系统进行交互。在编程中，我们通常不需要直接与引导记录进行交互，因为操作系统会负责引导和加载文件系统。NTFS文件系统由多个组件组成，包括引导记录、主文件表（Master File Table，MFT）、文件属性和文件数据。
C#实现获得磁盘的文件系统类型 （附完整源代码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-14 121
C#实现获得磁盘的文件系统类型 （附完整源代码）
C#快速NTFS硬盘文件索引
08-09
C#快速NTFS硬盘文件索引,基于 USN编程，范例很好，非本人原创。。。
C#理论 —— 文件操作、委托和事件
Adam's Rib for Antennnin
01-07 792
文章目录1. 文件操作1.1 获取计算机驱动器信息Driveinfo1.2 文件夹操作Directory、Directoryinfo1.3 文件操作File、FileInfo1.4 文件路径操作Path 1. 文件操作 操作变量和常量时这些值都是存放到内存中的，当程序运行结束后使用的数据全部被删除。若需要长久保存应用程序中的数据，需要选用文件或数据库来存储。 文件操作类在 System.IO 命名空间中，包括 Driveinfo 类、Directory 类、Directoryinfo 类、File 类、F
NTFS USN的Create和工具代码汇总
于大大大洋
09-29 1622
1、因为之前把相关代码放在了GitHub上，后来突然有人帮忙改了些个BUG，非常感谢 760193107，所以就写了个完整点的例子，希望对别人有所帮助。GitHub项目地址2、错误码：ERROR_JOURNAL_NOT_ACTIVE在测试时，执行：QueryUSNJournal();方法的时候，查询USN失败了，返回　ERROR_JOURNAL_NOT_ACTIVE　原因是NTFS的USN是禁止状态
读取NTFS的USN（快速检索文件）
blackbean的专栏
11-23 4848
有个名叫Everything的软件，搜索文件飞快，看了一下原理，原来NTFS会记录文件的所有操作，也就是说即便文件被删除了，通过USN记录仍然可以知道文件名等部分信息。于是准备写个程序删掉这个信息，但研究了一下，发现它默认其实是关闭的，也就是没必要担心信息外漏。 #define _CRT_SECURE_NO_WARNINGS #include #include #include
Get file path by File reference number
michaego的专栏
09-26 1469
通过FRN直接得到文件路径, 纠正或者说补强网络上盛传的一段代码 前言: 1. NTFS的设计者希望我们在数据库里建立表结构来映射FRN和文件地址. 但是是有办法直接通过FRN和盘符拿到完整的路径 2. 方法通过调用内核API:NtCreatefile和NtQueryInf
NTFS 磁盘搜索
10-29
在NTFS磁盘搜索中，我们通常需要快速查找特定的文件或信息，而传统的搜索方法可能效率较低。本示例代码不依赖于`DeviceIoControl`函数，而是直接解析MFT（主文件表）来实现快速搜索。 主文件表（MFT）是NTFS的核心...
NTFS快速磁盘搜索技巧：直接分析MFT示例
【标签】中的"NTFS 磁盘 快速 搜索"说明了这是一个针对NTFS文件系统优化的搜索技术，旨在提升搜索性能。 【压缩包子文件的文件名称列表】中的"NTFS-Search"表明这是一个专门针对NTFS格式磁盘进行搜索功能的工具或...
毕业设计：NTFS磁盘文件快速定位
05-16 1448
2012-5-27 6:03:53 1、最小化到系统托盘，右键弹出菜单 2、防止重复启动 3、添加排除文件夹 2012-5-20 11:24:06 加了个状态提示 ———————————————————— NTFS磁盘文件（夹）快速定位 只在NTFS、win2k及以后的windows版本适用 输入要查找的文件名中的关键字，列出路径，双击可打开文
提升搜索速度的文件快速查找器
NTFS（New Technology File System）是微软开发的一种高级文件系统，它为文件快速查找器提供了直接读取文件表的能力。文件表记录了文件系统的元数据，包括文件名、文件大小、文件属性、文件位置等，而无需访问整个...
ntfs.zip_ntfs
09-20
- **VFT（Volume File Table）**：卷文件表是一个指向MFT记录的索引，用于快速查找文件。 - **$Bitmap**：位图文件记录了磁盘上的簇是否被占用。 - **$MFTMirr**：MFT镜像文件，用于备份MFT，提高数据可靠性。 - **$...
C#极速NTFS硬盘文件索引VS2010
12-22
此代码是基于VS2010，C#下的超级极速文件索引软件，可在10秒内整理出硬盘上的所有文件列表。对于研究USN编程具有很不错的指引。 只支持NTFS操作系统。 代码来源于网络，非本人原创。
读取NTFS的USN（获取文件的历史操作记录，即使这个文件已被删除）
blackbean的专栏
11-23 3952
上回说到NTFS USN会记录下文件的所有操作，但默认情况下并没有激活这一功能，所以不用担心。在非激活状态，它也只剩下快速查找文件的功能。 这回，假设USN JOURNAL被激活了（你可以用控制台命令fsutil usn，或上回说到的FSCTL_CREATE_USN_JOURNAL来开启这一功能），怎么回窥过去的操作？ 为此，写了段代码来进行试验，程序是检索 123.txt 操作历史（记录空间
NTFSLib 使用教程
最新发布
gitblog_01018的博客
08-25 921
NTFSLib 使用教程 NtfsLibNTFS parsing library in C#. Allows one to parse and read NTFS structures on disk.项目地址:https://gitcode.com/gh_mirrors/nt/NtfsLib 项目介绍 NTFSLib 是一个由 LordMike 开发的 .NET 库，专门用于在 C# 中解析和...
NTFS Change Journal（USN Journal）详解
热门推荐
于大大大洋
07-18 1万+
写在前面最近又用了一下usn日志来获取所有文件列表，在分多次加载文件列表的时候发现有文件丢失的情况，后来发现一篇文章比较详细的讲了usn。用cmd来读取usn日志如图： 以下是转载内容：还是那个文件监控的应用，发现使用Windows API（ReadDirectoryChangesW）还是不能满足要求，如果变化量大又密集时，丢失通知现象很严重。好在需要监控的大部分的Windows用户都转到NTFS
C# 控制NTFS目录权限
水工鸟的专栏
03-27 1660
using System;using System.Collections.Generic;using System.Security.AccessControl;using System.IO;namespace SovSafe{    class NTFS_Control    {        public NTFS_Control()        { }         // 添加
C#解析ntfs下的$usnjrnl($J)文件
ach60390的博客
08-02 1089
园子里面已经有文章介绍如何在windows下如何借助windows提供的原生API读取USN日志，本随笔介绍的是解析现有的$usnjrnl文件,得到其中的内容。 经过分析msdn对usn记录的描述(传送门https://docs.microsoft.com/en-us/windows/desktop/api/winioctl/ns-winioctl-usn_journal_data_v...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值