文件管理之内核API

ゞ浴缸里的玫瑰 2022-09-15 13:55 153阅读 0赞

// 创建文件或目录
    
    // PS：ZwCreateFile函数：
    // 功能：创建一个新文件/目录或打开一个已存在的文件/目录。
    // 原型：NTSTATUS ZwCreateFile(
    // _Out_ HANDLE FileHandle,
    // _In_ ACCESS_MASK DesiredAccess,
    // _In_ POBJECT_ATTRIBUTES ObjectAttributes,
    // _Out_ PIO_STATUS_BLOCK IoStatusBlock,
    // _In_opt_ PLARGE_INTERGER AllocationSize,
    // _In_ ULONG FileAttributes,
    // _In_ ULONG ShareAccess,
    // _In_ ULONG CreateDisposition,
    // _In_ ULONG CreateOptions,
    // _In_opt_ PVOID EaBuffer,
    // _In_ ULONG EaLength
    // )
    // 参数：FileHandle：接收创建或打开文件/目录的句柄。
    // DesiredAccess：访问权限，比如GENERIC_READ、GENERIC_WRITE。
    // ObjectAttributes：指定对象名称和其他信息的结构体，用InitializeObjectAttributes宏来初始化。
    // IoStatusBlock：接收最终完成状态以及所请求操作的其他信息。
    // AllocationSize：一种长整形指针(128位)，一般为NULL。
    // FileAttributes：表示创建或覆盖文件时要设置的文件属性，默认为FILE_ATTRIBUTE_NORMAL。
    // ShareAccess：共享的权限，为0表示不共享，独占文件。
    // CreateDispostion：文件存在或不存在时要执行的操作，比如，使用FILE_CREATE表示若文件存在，则返回一个错误，否则创建文件。
    // FILE_OPEN表示若文件不存在，则返回一个错误，否则打开文件。FILE_OPEN_IF表示文件不存在则创建文件，存在则打开文件。
    // CreateOptions：指定驱动程序创建或打开文件时使用的选项。其中FILE_DIRECTORY_FILE表示操作的是一个目录。
    // FILE_SYNCHRONOUS_IO_NONALERT表示文件中的所有操作都是同步执行的。
    // EaBuffer：设置为NULL。
    // EaLength：设置为NULL。
    // 结果：成功，返回STATUS_SUCCESS，失败，返回相应的NTSTATUS错误码。
    
    // PS：实现原理：在应用层，使用CreateFile创建或打开文件，使用OpenFile打开文件，使用CreateDirectory创建目录。在内核层，同意使用ZwCreateFile实现。
    
    // PS：步骤：
    // 1.调用InitializeObjectAttributes宏来初始化对象属性，主要是设置文件路径以及OBJ_KERNEL_HANDLE属性。
    // 2.调用ZwCreateFile函数，设置相应的参数来创建文件或目录。若创建目录，则CreateOptions必须设置为FILE_DIRECTORY_FILE。
    // 3.当文件句柄不再使用时，应当使用ZwClose来关闭句柄，释放资源。
    
    // PS：内核文件的路径是以 \??\开头的，比如: \??\C:\MyCreateFolder\MyCrateFile.txt
    
    // 示例代码：
    
    // 创建文件
    
    BOOLEAN MyCreateFile(UNICODE_STRING ustrFilePath)
    { 
        HANDLE hFile = NULL;
        OBJECT_ATTRIBUTES ObjectAttributes = { 0};
        IO_STATUS_BLOCK iosb = { 0};
        NTSTATUS status = STATUS_SUCCESS;
    
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttributes, &ustrFilePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
        // 创建文件
        status = ZwCreateFile(&hFile, GENERIC_READ, &ObjectAttributes, &iosb, NULL, FILE_ATTRIBUTES_NORMAL, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
        if (!NT_SUCCESS(status))
        { 
            ShowError("ZwCreateFile", status);
            return FALSE;
        }
    
        // 关闭句柄
        ZwClose(hFile);
    
        rturn TRUE;
    }
    
    // PS：删除文件或空目录
    
    // PS：ZwDeleteFile函数：
    // 功能：删除指定文件或空目录。
    // 原型：NTSTATUS ZwDeleteFile(
    // _In_ POBJECT_ATTRIBUTES ObjectAttributes
    // )
    // 参数：ObjectAttributes：对象属性，使用InitializeObjectAttributes宏来初始化，主要是设置文件路径以及OBJ_KERNEL_HANDLE属性。
    // 结果：成功，返回STATUS_SUCCESS，失败，返回相应的NTSTATUS错误码。
    
    // 实现原理：应用层使用DeleteFile删除文件，使用RemoveDirectory删除空目录，使用递归删除目录及子目录下的文件。在内核层，统一使用ZwDeleteFile来删除。
    
    // PS：步骤：
    // 1.使用InitializeObjectAttributes宏来初始化对象属性，设置文件路径以及OBJ_KERNEL_HANDLE属性。
    // 2.调用ZwDeleteFile函数，根据传入的对象属性来删除指定对象。如果对象是个文件，则删除文件，若对象是个空目录，则删除空目录，若对象是非空目录，则不操作。
    // 即不能通过ZwDeleteFile来删除非空目录。
    
    // 示例代码：
    
    BOOLEAN MyDeleteFileOrFolder(UNICODE_STRING ustrFileName)
    { 
        NTSTATUS status = STATUS_SUCCESS;
        OBJECT_ATTRIBUTES ObjectAttributes = { 0};
    
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttributes, &ustrFilePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
        // 删除文件或空目录
        status = ZwDeleteFile(&ObjectAttributes);
        if (!NT_SUCCESS(status))
        { 
            ShowError("ZwDeleteFile", status);
            return FALSE;
        }
    
        return TRUE;
    }
    
    // PS：获取文件大小
    
    // PS：ZwQueryInformationFile函数：
    // 功能：返回有关文件对象的各种信息。
    // 原型：NTSTATUS ZwQueryInformationFile(
    // _In_ HANDLE FileHandle,
    // _Out_ PIO_STATUS_BLOCK IO_Status_Block,
    // _Out_ PVOID FileInformation,
    // _In_ ULONG Length,
    // _In_ FILE_INFORMATION_CLASS FileInformationClass
    // )
    // 参数：FileHandle：由ZwCreateFile或ZwOpenFile函数获取的文件句柄。
    // IO_Status_Block：接收最终完成状态和有关操作的信息。包含写入到FileInformation缓存区的字节数。
    // FileInformation：缓存区，用于接收文件信息。
    // Length：缓存区大小。
    // FileInformationClass：文件信息的类，有很多，比如：FILE_STANDARD_INFORMATION表示标准文件信息类。FILE_RENAME_INFORMATION表示重命名文件信息类。
    // 结果：成功，返回STATUS_SUCCESS，失败，返回相应的NTSTATUS错误码。
    
    // PS：FILE_STANDARD_INFORMATION结构体：
    // 定义：typedef struct _FILE_STANDARD_INFORMATION { 
    // LARGE_INTERGER AllocationSize;
    // LARGE_INTERGER EndOfFile;
    // ULONG NumberOfLinks;
    // BOOLEAN DeletePendings;
    // BOOLEAN Directory;
    // }FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
    // 成员：AllocationSize：为文件分配大小(以字节为单位)，通常为底层物理设备的扇区或簇大小的倍数。
    // EndOfFile：文件位置的结尾作为偏移量，可以表示文件的大小。
    // NumberOfLinkes：到文件的硬链接数量。
    // DeletePending：删除挂起状态。TRUE表示已请求文件删除。
    // Directory：文件目录状态，TRUE表示文件对象是一个目录。
    
    // PS：实现原理：在应用层，使用GetFileSize函数获取文件的大小，在内核层，使用ZwQueryInformationFile，获取FILE_STANDARD_INFORMATION，其成员EndOfFile可以表示文件的大小。
    
    // PS：步骤：
    // 1.使用InitializeObjectAttributes宏来初始化对象属性，主要是设置文件路径以及OBJ_KERNEL_HANDLE属性。
    // 2.使用ZwCreateFile函数获取文件句柄，设置FILE_OPEN属性。
    // 3.使用ZwQueryInformationFile函数，获取FileStandardInformation信息类型，访问成员EndOfFile即可得文件大小。
    // 4.不再使用文件句柄时，应当使用ZwClose关闭文件句柄，释放资源。
    
    // 示例代码：
    
    ULONG64 MyGetFileSize(UNICODE_STRING ustrFileName)
    { 
        HANDLE hFile = NULL;
        OBJECT_ATTRIBUTES ObjectAttributes = { 0};
        IO_STATUS_BLOCK osib = { 0};
        FILE_STANDARD_INFORMATION fsi = { 0};
        NTSTATUS status = STATUS_SUCCESS;
    
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
        // 打开文件句柄
        status = ZwCreateFile(&hFile, GENERIC_READ, &ObjectAttributes, &iosb, NULL, 0, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
        if (!NT_SUCCESS(status))
        { 
            ShowError("ZwCreateFile", status);
            return FALSE;
        }
    
        //获取文件大小
        status = ZwQueryInformationFile(hFile, &iosb, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
        if (!NT_SUCCESS(status))
        { 
            ZwClose(hFile);
            ShowError("ZwQueryInformationFile");
            return FALSE;
        }
    
        return fsi.EndOfFile.QuadPardt;
    }
    
    // PS：读写文件
    
    // PS：ExAllocatePool函数：
    // 功能：指定分配类型的池内存，并返回指向分配块的指针。
    // 原型：PVOID ExAllocatePool (
    // _In_ POOL_TYPE PoolType,
    // _In_ SIZE_T NumberOfBytes
    // )
    // 参数：PoolType：指向分配的池内存类型。其中，NonPagedPool表示非分页内存池，它是不可分页的系统内存。非分页内存可以从任何IRQL上访问，但它是一个稀缺资源。
    // NumberOfBytes：指定要分配的字节数。
    // 结果：如果可用池中的内存不能满足请求时，ExAllocatePool将返回NULL。否则，返回分配的内存的指针。
    // PS：当内存不再使用时，应使用ExFreePool进行资源释放。
    
    // PS：ZwReadFile函数：
    // 功能：从打开的文件中读取数据。
    // 原型：NTSTATUS ZwReadFile(
    // _In_ HANDLE FileHandle,
    // _In_opt_ HANDLE Event,
    // _In_opt_ PIO_APC_ROUTINE ApcRoutine,
    // _In_opt_ PVOID ApcContext,
    // _Out_ PIO_STATUS_BLOCK IoStatusBlock,
    // _Out_ PVOID Buffer,
    // _In_ ULONG Length,
    // _In_opt_ PLARGE_INTERGER ByteOffset,
    // _In_opt_ PULONG Key
    // )
    // 参数：FileHandle：由ZwCreateFile或ZwOpenFile打开的文件句柄。
    // Event：在读取操作完成之后，事件对象的句柄设置为信号状态。
    // ApcRoutine：保留。
    // ApcContext：保留。
    // IoStatusBlock：接收最终完成状态的结构指针以及所请求读取操作的信息。信息成员接收从文件中实际读取的字节数。
    // Buffer：分配的缓存区，用于接收读取的数据。
    // Length：缓存区大小。
    // ByteOffset：指定开始读取操作的文件中的起始字节偏移量。
    // Key：设置为NULL。
    // 结果：成功，返回STATUS_SUCCESS，失败，返回相应的NTSTATUS错误代码。
    
    // PS：ZwWriteFile函数：
    // 功能：向一个打开的文件写入数据。
    // 原型：NTSTATUS ZwWriteFile (
    // _In_ HANDLE FileHandle,
    // _In_opt_ HANDLE Event,
    // _In_opt_ PIO_APC_ROUTINE ApcRoutine,
    // _In_opt_ PVOID ApcContext,
    // _Out_ PIO_STATUS_BLOCK IoStatusBlock,
    // _In_ PVOID Buffer,
    // _In_ ULONG Length,
    // _In_opt_ PLARGE_INTERGER ByteOffset,
    // _In_opt_ PULONG Key
    // )
    // 参数：FileHandle：由ZwCreateFile或ZwOpenFile打开的文件句柄。
    // Event：在写操作完成后，将事件对象的句柄置为信号状态。
    // ApcRoutine：保留。
    // ApcContext：保留。
    // IoStatusBlock：接收最终完成状态的结构指针以及所请求写入操作的信息。信息成员接收实际写入文件中的字节数。
    // Buffer：要写入数据的缓存区。
    // Length：缓存区大小。
    // ByteOffset：指定开始写入操作的文件中的起始字节偏移量。
    // Key：置为NULL。
    // 结果：成功，返回STATUS_SUCCESS，失败，返回相应的NTSTATSU错误码。
    
    // 实现原理：在应用层，使用CreateFile/OpenFile打开文件，获取句柄，然后调用WriteFile或ReadFile进行文件的读写操作。内核层由类型，使用ZwCrea，teFile/ZwOpenFile打开
    // 文件，获取句柄，然后调用ZwReadFile/ZwWriteFile进行读写操作。
    
    // 具体步骤：
    // 1.调用InitializeObjectAttributes宏来初始对象属性，主要设置文件路径和OBJ_KERNEL_HANDLE属性。
    // 2.调用ZwCreateFile函数，使用FILE_OPEN标记来打开文件获取文件句柄。对于读取操作，应设置GENERIC_READ权限，对于写入操作，应设置GENERIC_WRITE权限。
    // 3.调用ZwReadFile或ZwWriteFIle函数进行文件的读写，并设置指定偏移和数据缓存区。
    // 4.当不再使用文件句柄时，应当调用ZwClose函数进行关闭，释放资源。
    
    // 示例代码：
    
    // 读取文件数据
    
    BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTERGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
    { 
        // 变量(略)
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttribute, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
        // 打开文件
        status = ZwCreateFile(&hFile, GENERIC_READ, &ObjectAttribute, &iosb, NULL, FILE_ATTRIBUTES_NORMAL, 
                FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_NON_DIRECT_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
            
        if (!NT_SUCCESS(status))
        { 
            ShowError("ZwCreateFile", status);
            return FALSE;
        }
    
        // 读取文件数据
        RtlZeroMemory(&iosb, sizeof(iosb));
        status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
        if (!NT_SUCCESS(status))
        { 
            *pulReadDataSize = iosb.Inforamtion;
            ZwClose(hFile);
            ShowError("ZwReadFile", status);
            return FALSE;
        }
    
        // 获取实际读取的数据
        *pulReadDataSize = iosb.Information;
    
        // 关闭句柄
        ZwClose(pFile);
    
        return TRUE;
    }
    
    // 写入文件数据
    BOOLEAN MyWriteFile(UNICODE_STRING ustrFileName, LARGE_INTERGER liOffset, PUCHAR pWriteData, PULONG pulWriteDataSize)
    { 
        // 变量(略)
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttribute, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
        // 打开文件
        status = ZwCreateFile(&hFile, GENERIC_WRITE, &ObjectAttribute, &iosb, NULL, FILE_ATTRIBUTES_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_OEPN_IF, FILE_NON_DIRECT_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
        if (!NT_SUCCESS(status))
        { 
            ShowError("ZwCreateFile", status);
            return FALSE;
        }
    
        // 写入文件数据
        RtlZeroMemory(&iosb, sizeof(iosb));
        status = ZwWriteFile(hFile, NULL, NULL, NULL, &iosb, pWriteData, *pulReadDataSize, &liOffset, NULL);
        if (!NT_SUCCESS(status))
        { 
            *pulReadDataSize = iosb.Information;
            ZwClose(hFile);
            ShowError("ZwWriteFile", status);
            return FALSE;
        }
    
        // 获取实际写入的数据
        *pulReadDataSize = iosb.Information;
    
        // 关闭句柄
        ZwClose(hFile);
    
        return TRUE;
    }
    
    // PS：重命名文件名称
    
    // PS：ZwSetInformationFile函数：
    // 功能：更改有关文件对象的各种信息。
    // 原型：NTSTATUS ZwSetInformationFile (
    // _In_ HANDLE FileHandle,
    // _Out_ PIO_STATUS_BLOCK IoStatusBlock,
    // _In_ PVOID FileInformation,
    // _In_ ULONG Length,
    // _In_ FILE_INFORMATION_CLASS FileInformationClass
    // )
    // 参数：FileHandle：文件句柄，由ZwCreateFile或ZwOpenFile函数提供。
    // IoStatusBlock：接收最终完成状态的IO_STATUS_BLOCK结构的指针以及所请求操作的信息。
    // FileInformation：指向为文件信息设置的缓存区。此缓存区中的特定结构由FileInformationClass参数来确定。
    // Length：缓存区大小。
    // FileInformationClass：指定接收文件信息的类型，比如:FILE_RENAME_INFORMATION，其成员提供当前的文件名等。
    // 返回值：成功，返回STATUS_SUCCESS，失败，返回相应的NTSTATUS错误代码。
    
    // PS：FILE_RENAME_INFORMATION结构体
    // 定义：typedef struct _FILE_RENAME_INFORMATION { 
    // BOOLEAN ReplaceIfExists;
    // HANDLE RootDirectory;
    // ULONG FileNameLength;
    // WCHAR FileName[1];
    // } FILE_RENAME_INFORMATION, *PFILE_RENAME_INFORMATION;
    // 成员：ReplaceIfExists：若设置为TRUE，且具有给定名称的文件存在，则进行文件替换。若设置为FALSE，且具有给定名称的文件存在，则操作失败。
    // RootDirectory：如果文件未移动到不同的目录中，或者FileName中给定了绝对路径，则此成员为NULL。否则它就是文件在重命名后驻留根目录句柄。
    // FileNameLength：指定文件新名称的长度(以字节为单位)。
    // FileName：包含文件新名称字符串的第一个字符，紧接着的内存存储其余的字符串内容。
    
    // PS：实现步骤：
    // 1.调用InitializeObjectAttributes宏来初始化对象属性，主要是设置文件路径以及OBJ_KERNEL_HANDLE属性。
    // 2.调用ZwCreateFile函数，设置FILE_OPEN属性来打开文件，获取句柄。同时，需要设置删除权限，以便后续通过ZwSetInformationFile函数设置重命名信息。
    // 3.调用ZwSetInformationFile函数设置重命名信息。新的名称放在FILE_RENAME_INFORMATION结构中FileName指向的缓存区。
    // 4.调用ZwClose函数关闭文件句柄，释放资源。
    
    // 示例代码：
    
    // 重命名文件或文件夹
    BOOLEAN MyRenameFileOrFolder(UNICODE_STRING ustrFileName, UNICODE_STRING ustrDestFileName)
    { 
        // 变量(略)
        // 申请内存
        pRenameInfo = (PFILE_RENAME_INFORMATION)ExAllocatePool(NonPagedPool, ulLength);
        if (NULL == pRenameInfo)
        { 
            ShowError("ExAllocatePool");
            return FALSE;
        }
    
        // 设置结构信息
        RtlZeroMemory(pRenameInfo, ulLength);
        pRenameInfo->FileNameLength = ustrDestFileName.Length;
        wcscpy(pRenameInfo->FileName, ustrDestFileName.Buffer);
        pRenameInfo->ReplaceIfExists = FALSE;
        pRenameInfo->RootDirectory = NULL;
    
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttribute, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
        // 打开文件
        status = ZwCreateFile(&hFile, SYNCHRONIZE | DELETE, &ObjectAttribute, &iosb, NULL, 0, FILE_SHARE_READ, FILE_OPEN, 
                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NO_INTERMEDIATE_BUFFERING, NULL, 0);
        if (!NT_SUCCESS(status))
        { 
            ExFreePool(pRenameInfo);
            ShowError("ZwCreateFile", status);
            return FALSE;
        }
    
        // 设置文件信息
        status = ZwSetInformationFile(hFile, &iosb, pRenameInfo, ulLength, FileRenameInformation);
        if (!NT_SUCCESS(status))
        { 
            ZwClose(hFile);
            ExFreePool(pRenameInfo);
            ShowError("zwSetInformationFile", status);
            return FALSE;
        }
    
        // 关闭句柄，释放内存
        ExFreePool(pRenameInfo);
        ZwClose(hFile);
    
        return TRUE;
    }
    
    // PS：文件遍历：
    
    // PS：ZwQueryInformationFile函数：
    // 功能：在给定目录句柄指定的目录中返回文件的各种信息。
    // 原型：NTSTATUS ZwQueryInformationFile (
    // _In_ HANDLE FileHandle,
    // _In_opt_ HANDLE Event,
    // _In_opt_ PIO_APC_ROUTINE,
    // _In_opt_ PVOID ApcContext,
    // _Out_ PIO_STATUS_BLOCK IoStatusBlock,
    // _Out_ PVOID FileInformation,
    // _In_ ULONG Length,
    // _In_ FILE_INFORMATION_CLASS FileInformationClass,
    // _In_ BOOLEAN ReturnSingleEntry,
    // _In_opt_ PUNICODE_STRING FileName,
    // _In_ BOOLEAN RestartScan
    // )
    // 参数：FileHandle：打开的目录句柄。
    // Event：调用者创建事件的可选句柄。如果提供此参数，则调用者将会置于等待状态，直到请求的操作完成并且给定事件已设置为信号状态。
    // ApcRoutine：在请求操作完成时调用的APC例程的地址。
    // ApcContext：如果调用者提供APC或I/O完成对象与文件对象相关联，则可以指定由调用者确定的上下文区域。
    // IoStatusBlock：接收最终完成状态和有关操作的信息。
    // FileInformation：指向缓存区的指针，用于接收该文件所需的信息。
    // Length：缓存区大小。
    // FileInformationClass：指定接收文件信息的结构体类型，这里为FileBothDirectoryInformation，表示为每个文件返回FILE_BOTH_DIR_INFORMATION结构。
    // ReturnSingleEntry：如果只返回一个条目，则设置为TRUE，否则设置为FALSE。如果此参数为TRUE，则ZwQueryInformationFile仅返回找到的第一个条目。
    // FileName：指定目录的文件名称(搜索表达式)，如果为NULL，表示搜索所有的文件，否则，搜索匹配名称的文件。
    // RestartScan：如果为TRUE，表示从头开始扫描，否则，从上次呼叫开始恢复扫描。
    // 结果：成功，返回STATUS_SUCCESS，失败，返回适当的NTSTATUS错误码。
    
    // PS：FILE_BOTH_DIR_INFORMATION结构体：
    // 定义：typedef struct _FILE_BOTH_DIR_INFORMATION { 
    // ULONG NextRetryOffset;
    // ULONG FileIndex;
    // LARGE_INTERGER CreationTime;
    // LARGE_INTERGER LastAccessTime;
    // LARGE_INTERGER LastWriteTime;
    // LARGE_INTERGER ChagneTime;
    // LARGE_INTERGER EndOfFile;
    // LARGE_INTERGET AllocationSize;
    // ULONG FileAttributes;
    // ULONG FileNameLength;
    // ULONG EaSize;
    // ULONG ShortNameLength;
    // WCHAR ShortName[12];
    // WCHAR FileName[1];
    // } FILE_BOTH_DIR_INFORMATION, *PFILE_BOTH_DIR_INFORMATION;
    // 成员：NextEntryOffset：如果缓存区存在多个条目，则为下一个FILE_BOTH_DIR_INFORMATION条目的字节偏移量。如果没有其他条目跟随，则该成员为0。
    // FileIndex：文件的索引。
    // CreationTime：文件创建时间。
    // LastAccessTime：上一次访问该文件的时间。
    // LastWriteTime：上一次将信息写入文件的时间。
    // ChangeTime：上一次更改文件的时间(比如重命名等)。
    // EndOfFile：文件的大小。
    // AllocationSize：为文件分配的大小，以字节为单位。
    // FileAttributes：由以下值的组合而成：
    // FILE_ATTRIBUTE_READONLY
    // FILE_ATTRIBUTE_HIDDEN
    // FILE_ATTRIBUTE_SYSTEM
    // FILE_ATTRIBUTE_DIRECTORY
    // FILE_ATTRIBUTE_ARCHIVE
    // FILE_ATTRIBUTE_DEVICE
    // FILE_ATTRIBUTE_NORMAL
    // FILE_ATTRIBUTE_TEMPORARY
    // FILE_ATTRIBUTE_SPARSE_FILE
    // FILE_ATTRIBUTE_REPARSE_POINT
    // FILE_ATTRIBUTE_COMPRESSED
    // FILE_ATTRIBUTE_OFFLINE
    // FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
    // FILE_ATTRIBUTE_ENCRYPTED
    // FileNameLength：指定文件名的字符串长度。
    // EaSize：文件扩展属性的组合长度。
    // ShortNameLength：指定短文件名的字符串长度。
    // ShortName：Unicode字符串包含文件的短名称。
    // FileName：指定文件名称字符串的第一个字符。
    
    // PS：实现原理：在应用层，使用FindFirstFile和FindNextFile来遍历指定目录下的所有文件。内核下，只使用ZwQueryInformationFile函数来实现。
    
    // PS：具体步骤：
    // 1.调用InitializeObjectAttributes宏来初始化对象属性，主要是设置目录路径以及OBJ_KERNEL_HANDLE属性。
    // 2.调用ZwCreateFile函数设置FILE_DIRECTORY_FILE标记来打开目录。DesiredAccess参数设置为FILE_LIST_DIRECTORY。
    // 3.调用ZwQueryInformationFile函数，获取FileBothDirectoryInformation信息类型，获取的数据存放在FILE_BOTH_DIR_INFORMATION结构体的缓存区中。根据NextEntryOffset来进行循环遍历。
    // 4.调用ZwClose函数关闭句柄，释放资源。
    
    // 示例代码：
    
    // 遍历文件夹和文件：
    BOOLEAN MyQueryFileAndFolder(UNICODE_STRING ustrPath)
    { 
        // 变量(略)
        // 初始化对象属性
        InitializeObjectAttributes(&ObjectAttribute, &ustrPath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    
         // 打开目录，获取句柄
         status = ZwCreateFile(&hFile, FILE_LIST_DIRECTORY | SYNCHRONIZE | FILE_ANY_ACCESS, &ObjectAttribute, &iosb, NULL, 
                          FILE_ATTRIBUTES_NORMAL, FILE_SHARE_READ   FILE_SHARE_WRITE, FILE_OPEN, FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | 
                          FILE_OPEN_FOR_BACKUP_INTENT, NULL, 0);
        if (!NT_SUCCESS(status))
        { 
            ShowError("ZwCreateFile", status);
            return FALSE;
        }
    
        // 获取信息
        status = ZwQueryInformationFile(hFile, NULL, NULL, NULL, &iosb, pDir, ulLength, FileBothDirectoryInformation, FALSE, NULL, FALSE);
        if (!NT_SUCCESS(status))
        { 
            ExFreePool(pDir);
            ZwClose(hFile);
            ShowError("ZwQueryInformationFile", status);
            return FALSE;
        }
    
        RtlInitUnicodeString(&ustrOne, L".");
        RtlInitUnicodeString(&ustrTwo, L"..");
        WCHAR wcFileName[1024] = { 0};
    
        // 遍历
        while (TRUE)
        { 
            RtlZeroMemory(wcFileName, 1024);
            RtlCopyMemory(wcFileName, pDir->FileName, pDir->FileNameLength);
            RtlInitUnicodeString(&ustrTemp, wcFileName);
    
            // 判断是上级目录还是当前目录
            if ((0 != RtlCompareUnicodeString(&ustrTwo, &ustrOne, TRUE)) && (0 != RtlCompareUnicodeString(&ustrTemp, &ustrTemp, TRUE)))
            { 
                // 非".."、"."
                if (pDir->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                { 
                    // 目录
                    DbgPrint("[DIRECTORY]\t%wZ\n", &ustrTemp);
                }
                else
                { 
                    // 文件
                    DbgPrint("[FILE]\t\t%wZ\n", &ustrTemp);
                }
            }
    
            // 遍历完毕
            if (0 == pDir->NextRetryOffset)
            { 
                DbgPrint("\n[QUERY OVER]\n\n");
                break;
            }
    
            pDir = (PFILE_BOTH_DIR_INFORMATION)((PUCHAR)pDir + pDir->NextEntryOffset);
        }
    
        // 关闭句柄，释放内存(略)
    
        return TRUE;
    }