登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›驱动开发：内核文件读写系列函数

驱动开发：内核文件读写系列函数

奄幂牛 2025-6-6 19:52:14
在应用层下的文件操作只需要调用微软应用层下的API函数及C库标准函数即可，而如果在内核中读写文件则应用层的API显然是无法被使用的，内核层需要使用内核专有API，某些应用层下的API只需要增加Zw开头即可在内核中使用，例如本章要讲解的文件与目录操作相关函数，多数ARK反内核工具都具有对文件的管理功能，实现对文件或目录的基本操作功能也是非常有必要的。
首先无论在内核态还是在用户态，我们调用的文件操作函数其最终都会转换为一个IRP请求，并发送到文件系统驱动上的IRP_MJ_READ派遣函数里面，这个读写流程大体上可分为如下四步；

  • 对于FAT32分区会默认分发到FASTFAT.SYS，而相对于NTFS分区则会分发到NTFS.SYS驱动上。
  • 文件系统驱动经过处理后，就把IRP传给磁盘类驱动的IRP_MJ_READ分发函数处理，当磁盘类驱动处理完毕后,又把IRP传给磁盘小端口驱动。
  • 在磁盘小端口驱动里，无论是读还是写，用的都是IRP_MJ_SCSI这个分发函数。
  • IRP被磁盘小端口驱动处理完之后，就要依靠HAL.DLL进行端口IO，此时数据就真的从硬盘里读取了出来。
创建文件或目录: 实现创建文件或目录，创建文件或目录都可调用ZwCreateFile()这个内核函数来实现，唯一不同的区别在于当用户传入参数中包含有FILE_SYNCHRONOUS_IO_NONALERT属性时则会默认创建文件，而如果包含有FILE_DIRECTORY_FILE属性则默认为创建目录，该函数的微软定义以及备注信息如下所示；
  1. NTSYSAPI NTSTATUS ZwCreateFile(
  2.   [out]          PHANDLE            FileHandle,        // 指向HANDLE变量的指针，该变量接收文件的句柄。
  3.   [in]           ACCESS_MASK        DesiredAccess,     // 指定一个ACCESS_MASK值，该值确定对对象的请求访问权限。
  4.   [in]           POBJECT_ATTRIBUTES ObjectAttributes,  // 指向OBJECT_ATTRIBUTES结构的指针，该结构指定对象名称和其他属性。
  5.   [out]          PIO_STATUS_BLOCK   IoStatusBlock,     // 指向IO_STATUS_BLOCK结构的指针，该结构接收最终完成状态和有关所请求操作的其他信息。
  6.   [in, optional] PLARGE_INTEGER     AllocationSize,    // 指向LARGE_INTEGER的指针，其中包含创建或覆盖的文件的初始分配大小（以字节为单位）。
  7.   [in]           ULONG              FileAttributes,    // 指定一个或多个FILE_ATTRIBUTE_XXX标志，这些标志表示在创建或覆盖文件时要设置的文件属性。
  8.   [in]           ULONG              ShareAccess,       // 共享访问的类型，指定为零或以下标志的任意组合。
  9.   [in]           ULONG              CreateDisposition, // 指定在文件存在或不存在时要执行的操作。
  10.   [in]           ULONG              CreateOptions,     // 指定要在驱动程序创建或打开文件时应用的选项。
  11.   [in, optional] PVOID              EaBuffer,          // 对于设备和中间驱动程序，此参数必须是NULL指针。
  12.   [in]           ULONG              EaLength           // 对于设备和中间驱动程序，此参数必须为零。
  13. );
复制代码
参数DesiredAccess用于指明对象访问权限的，常用的权限有FILE_READ_DATA读取文件，FILE_WRITE_DATA写入文件，FILE_APPEND_DATA追加文件，FILE_READ_ATTRIBUTES读取文件属性，以及FILE_WRITE_ATTRIBUTES写入文件属性。
参数ObjectAttributes指向了一个OBJECT_ATTRIBUTES指针，通常会通过InitializeObjectAttributes()宏对其进行初始化，当一个例程打开对象时由此结构体指定目标对象的属性。
参数ShareAccess用于指定访问属性，通常属性有FILE_SHARE_READ读取，FILE_SHARE_WRITE写入，FILE_SHARE_DELETE删除。
参数CreateDisposition用于指定在文件存在或不存在时要执行的操作，一般而言我们会指定为FILE_OPEN_IF打开文件，或FILE_OVERWRITE_IF打开文件并覆盖，FILE_SUPERSEDE替换文件。
参数CreateOptions用于指定创建文件或目录，一般FILE_SYNCHRONOUS_IO_NONALERT代表创建文件，参数FILE_DIRECTORY_FILE代表创建目录。
相对于创建文件而言删除文件或目录只需要调用ZwDeleteFile()系列函数即可，此类函数只需要传递一个OBJECT_ATTRIBUTES参数即可，其微软定义如下所示；
  1. NTSYSAPI NTSTATUS ZwDeleteFile(
  2.   [in] POBJECT_ATTRIBUTES ObjectAttributes
  3. );
复制代码
接下来我们就封装三个函数MyCreateFile()用于创建文件，MyCreateFileFolder()用于创建目录，MyDeleteFileOrFileFolder()用于删除空目录。
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include <ntifs.h>
  7. #include <ntstrsafe.h>
  9. // 创建文件
  10. BOOLEAN MyCreateFile(UNICODE_STRING ustrFilePath)
  11. {
  12.         HANDLE hFile = NULL;
  13.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  14.         IO_STATUS_BLOCK iosb = { 0 };
  15.         NTSTATUS status = STATUS_SUCCESS;
  17.         // 初始化对象属性结构体 FILE_SYNCHRONOUS_IO_NONALERT
  18.         InitializeObjectAttributes(&objectAttributes, &ustrFilePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  20.         // 创建文件
  21.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  22.         if (!NT_SUCCESS(status))
  23.         {
  24.                 return FALSE;
  25.         }
  27.         // 关闭句柄
  28.         ZwClose(hFile);
  30.         return TRUE;
  31. }
  33. // 创建目录
  34. BOOLEAN MyCreateFileFolder(UNICODE_STRING ustrFileFolderPath)
  35. {
  36.         HANDLE hFile = NULL;
  37.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  38.         IO_STATUS_BLOCK iosb = { 0 };
  39.         NTSTATUS status = STATUS_SUCCESS;
  41.         // 初始化对象属性结构体
  42.         InitializeObjectAttributes(&objectAttributes, &ustrFileFolderPath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  44.         // 创建目录 FILE_DIRECTORY_FILE
  45.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_CREATE, FILE_DIRECTORY_FILE, NULL, 0);
  46.         if (!NT_SUCCESS(status))
  47.         {
  48.                 return FALSE;
  49.         }
  50.         // 关闭句柄
  51.         ZwClose(hFile);
  53.         return TRUE;
  54. }
  56. // 删除文件或是空目录
  57. BOOLEAN MyDeleteFileOrFileFolder(UNICODE_STRING ustrFileName)
  58. {
  59.         NTSTATUS status = STATUS_SUCCESS;
  60.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  62.         // 初始化属性
  63.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  65.         // 执行删除操作
  66.         status = ZwDeleteFile(&objectAttributes);
  67.         if (!NT_SUCCESS(status))
  68.         {
  69.                 return FALSE;
  70.         }
  72.         return TRUE;
  73. }
  75. VOID UnDriver(PDRIVER_OBJECT driver)
  76. {
  77.         BOOLEAN ref = FALSE;
  79.         // 删除文件
  80.         UNICODE_STRING ustrDeleteFile;
  81.         RtlInitUnicodeString(&ustrDeleteFile, L"\\??\\C:\\LySharkFolder\\lyshark.txt");
  82.         ref = MyDeleteFileOrFileFolder(ustrDeleteFile);
  83.         if (ref != FALSE)
  84.         {
  85.                 DbgPrint("[LyShark] 删除文件成功 \n");
  86.         }
  87.         else
  88.         {
  89.                 DbgPrint("[LyShark] 删除文件失败 \n");
  90.         }
  92.         // 删除空目录
  93.         UNICODE_STRING ustrDeleteFilder;
  94.         RtlInitUnicodeString(&ustrDeleteFilder, L"\\??\\C:\\LySharkFolder");
  95.         ref = MyDeleteFileOrFileFolder(ustrDeleteFilder);
  96.         if (ref != FALSE)
  97.         {
  98.                 DbgPrint("[LyShark] 删除空目录成功 \n");
  99.         }
  100.         else
  101.         {
  102.                 DbgPrint("[LyShark] 删除空目录失败 \n");
  103.         }
  105.         DbgPrint("驱动卸载 \n");
  106. }
  108. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  109. {
  110.         DbgPrint("hello lyshark.com \n");
  112.         BOOLEAN ref = FALSE;
  115.         // 创建目录
  116.         UNICODE_STRING ustrDirectory;
  117.         RtlInitUnicodeString(&ustrDirectory, L"\\??\\C:\\LySharkFolder");
  118.         ref = MyCreateFileFolder(ustrDirectory);
  119.         if (ref != FALSE)
  120.         {
  121.                 DbgPrint("[LyShark] 创建目录成功 \n");
  122.         }
  123.         else
  124.         {
  125.                 DbgPrint("[LyShark] 创建文件失败 \n");
  126.         }
  128.         // 创建文件
  129.         UNICODE_STRING ustrCreateFile;
  130.         RtlInitUnicodeString(&ustrCreateFile, L"\\??\\C:\\LySharkFolder\\lyshark.txt");
  131.         ref = MyCreateFile(ustrCreateFile);
  132.         if (ref != FALSE)
  133.         {
  134.                 DbgPrint("[LyShark] 创建文件成功 \n");
  135.         }
  136.         else
  137.         {
  138.                 DbgPrint("[LyShark] 创建文件失败 \n");
  139.         }
  141.         Driver->DriverUnload = UnDriver;
  142.         return STATUS_SUCCESS;
  143. }
复制代码
运行如上代码，分别创建LySharkFolder目录，并在其中创建lyshark.txt最终再将其删除，输出效果如下；
1.png

重命名文件或目录: 在内核中重命名文件或目录核心功能的实现依赖于ZwSetInformationFile()这个内核函数，该函数可用于更改有关文件对象的各种信息，其微软官方定义如下；
  1. NTSYSAPI NTSTATUS ZwSetInformationFile(
  2.   [in]  HANDLE                 FileHandle,          // 文件句柄
  3.   [out] PIO_STATUS_BLOCK       IoStatusBlock,       // 指向 IO_STATUS_BLOCK 结构的指针
  4.   [in]  PVOID                  FileInformation,     // 指向缓冲区的指针，该缓冲区包含要为文件设置的信息。
  5.   [in]  ULONG                  Length,              // 缓冲区的大小（以字节为单位）
  6.   [in]  FILE_INFORMATION_CLASS FileInformationClass // 为文件设置的类型
  7. );
复制代码
这其中最重要的参数就是FileInformationClass根据该参数的不同则对文件的操作方式也就不同，如果需要重命名文件则此处应使用FileRenameInformation而如果需要修改文件的当前信息则应使用FilePositionInformation创建链接文件则使用FileLinkInformation即可，以重命名为例，首先我们需要定义一个FILE_RENAME_INFORMATION结构并按照要求填充，最后直接使用ZwSetInformationFile()并传入相关信息后即可完成修改，其完整代码流程如下；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include <ntifs.h>
  7. #include <ntstrsafe.h>
  9. // 重命名文件或文件夹
  10. BOOLEAN MyRename(UNICODE_STRING ustrSrcFileName, UNICODE_STRING ustrDestFileName)
  11. {
  12.         HANDLE hFile = NULL;
  13.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  14.         IO_STATUS_BLOCK iosb = { 0 };
  15.         NTSTATUS status = STATUS_SUCCESS;
  17.         PFILE_RENAME_INFORMATION pRenameInfo = NULL;
  19.         ULONG ulLength = (1024 + sizeof(FILE_RENAME_INFORMATION));
  21.         // 为PFILE_RENAME_INFORMATION结构申请内存
  22.         pRenameInfo = (PFILE_RENAME_INFORMATION)ExAllocatePool(NonPagedPool, ulLength);
  23.         if (NULL == pRenameInfo)
  24.         {
  25.                 return FALSE;
  26.         }
  28.         // 设置重命名信息
  29.         RtlZeroMemory(pRenameInfo, ulLength);
  31.         // 设置文件名长度以及文件名
  32.         pRenameInfo->FileNameLength = ustrDestFileName.Length;
  33.         wcscpy(pRenameInfo->FileName, ustrDestFileName.Buffer);
  34.         pRenameInfo->ReplaceIfExists = 0;
  35.         pRenameInfo->RootDirectory = NULL;
  37.         // 初始化结构
  38.         InitializeObjectAttributes(&objectAttributes, &ustrSrcFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  40.         // 打开文件
  41.         status = ZwCreateFile(&hFile, SYNCHRONIZE | DELETE, &objectAttributes, &iosb, NULL, 0, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT | FILE_NO_INTERMEDIATE_BUFFERING, NULL, 0);
  42.         if (!NT_SUCCESS(status))
  43.         {
  44.                 ExFreePool(pRenameInfo);
  45.                 return FALSE;
  46.         }
  47.         // 利用ZwSetInformationFile来设置文件信息
  48.         status = ZwSetInformationFile(hFile, &iosb, pRenameInfo, ulLength, FileRenameInformation);
  49.         if (!NT_SUCCESS(status))
  50.         {
  51.                 ZwClose(hFile);
  52.                 ExFreePool(pRenameInfo);
  53.                 return FALSE;
  54.         }
  56.         // 释放内存,关闭句柄
  57.         ExFreePool(pRenameInfo);
  58.         ZwClose(hFile);
  60.         return TRUE;
  61. }
  63. VOID UnDriver(PDRIVER_OBJECT driver)
  64. {
  65.         DbgPrint("驱动卸载 \n");
  66. }
  68. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  69. {
  70.         DbgPrint("hello lyshark.com \n");
  72.         // 重命名文件
  73.         UNICODE_STRING ustrOldFile, ustrNewFile;
  74.         RtlInitUnicodeString(&ustrOldFile, L"\\??\\C:\\MyCreateFolder\\lyshark.txt");
  75.         RtlInitUnicodeString(&ustrNewFile, L"\\??\\C:\\MyCreateFolder\\hello_lyshark.txt");
  76.         BOOLEAN ref = MyRename(ustrOldFile, ustrNewFile);
  77.         if (ref == TRUE)
  78.         {
  79.                 DbgPrint("已完成改名 \n");
  80.         }
  82.         Driver->DriverUnload = UnDriver;
  83.         return STATUS_SUCCESS;
  84. }
复制代码
运行后将会把C:\\MyCreateFolder\\lyshark.txt目录下的文件改名为hello_lyshark.txt，前提是该目录与该文件必须存在；
2.png

那么如果你需要将文件设置为只读模式或修改文件的创建日期，那么你就需要看一下微软的定义FILE_BASIC_INFORMATION结构，依次填充此结构体并调用ZwSetInformationFile()即可实现修改，该结构的定义如下所示；
  1. typedef struct _FILE_BASIC_INFORMATION {
  2.     LARGE_INTEGER CreationTime;
  3.     LARGE_INTEGER LastAccessTime;
  4.     LARGE_INTEGER LastWriteTime;
  5.     LARGE_INTEGER ChangeTime;
  6.     ULONG FileAttributes;
  7. } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
复制代码
当然如果你要修改日期你还需要自行填充LARGE_INTEGER结构，该结构的微软定义如下所示，分为高位和低位依次填充即可；
  1. #if defined(MIDL_PASS)
  2. typedef struct _LARGE_INTEGER {
  3. #else // MIDL_PASS
  4. typedef union _LARGE_INTEGER {
  5.     struct {
  6.         ULONG LowPart;
  7.         LONG HighPart;
  8.     } DUMMYSTRUCTNAME;
  9.     struct {
  10.         ULONG LowPart;
  11.         LONG HighPart;
  12.     } u;
  13. #endif //MIDL_PASS
  14.     LONGLONG QuadPart;
  15. } LARGE_INTEGER;
复制代码
我们就以修改文件属性为只读模式为例，其核心代码可以被描述为如下样子，相比于改名而言其唯一的变化就是更换了PFILE_BASIC_INFORMATION结构体，其他的基本一致；
  1. HANDLE hFile = NULL;
  2. OBJECT_ATTRIBUTES objectAttributes = { 0 };
  3. IO_STATUS_BLOCK iosb = { 0 };
  4. NTSTATUS status = STATUS_SUCCESS;
  6. PFILE_BASIC_INFORMATION pReplaceInfo = NULL;
  8. ULONG ulLength = (1024 + sizeof(FILE_BASIC_INFORMATION));
  10. // 为FILE_POSITION_INFORMATION结构申请内存
  11. pReplaceInfo = (PFILE_BASIC_INFORMATION)ExAllocatePool(NonPagedPool, ulLength);
  12. if (NULL == pReplaceInfo)
  13. {
  14.   return FALSE;
  15. }
  17. RtlZeroMemory(pReplaceInfo, ulLength);
  19. // 设置文件基础信息,将文件设置为只读模式
  20. pReplaceInfo->FileAttributes |= FILE_ATTRIBUTE_READONLY;
复制代码
读取文件大小: 读取特定文件的所占空间，核心原理是调用了ZwQueryInformationFile()这个内核函数，该函数可以返回有关文件对象的各种信息，参数传递上与ZwSetInformationFile()很相似，其FileInformationClass都需要传入一个文件类型结构，该函数的完整定义如下；
  1. NTSYSAPI NTSTATUS ZwQueryInformationFile(
  2.   [in]  HANDLE                 FileHandle,          // 文件句柄。
  3.   [out] PIO_STATUS_BLOCK       IoStatusBlock,       // 指向接收最终完成状态和操作相关信息的 IO_STATUS_BLOCK 结构的指针。
  4.   [out] PVOID                  FileInformation,     // 指向调用方分配的缓冲区的指针，例程将请求的有关文件对象的信息写入其中。
  5.   [in]  ULONG                  Length,              // 长度。
  6.   [in]  FILE_INFORMATION_CLASS FileInformationClass // 指定要在 FileInformation 指向的缓冲区中返回的有关文件的信息类型。
  7. );
复制代码
本例中我们需要读入文件的所占字节数，那么FileInformation字段就需要传入FileStandardInformation来获取文件的基本信息，获取到的信息会被存储到FILE_STANDARD_INFORMATION结构内，用户只需要解析该结构体fsi.EndOfFile.QuadPart即可得到文件长度，其完整代码如下所示；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include <ntifs.h>
  7. #include <ntstrsafe.h>
  9. // 获取文件大小
  10. ULONG64 MyGetFileSize(UNICODE_STRING ustrFileName)
  11. {
  12.         HANDLE hFile = NULL;
  13.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  14.         IO_STATUS_BLOCK iosb = { 0 };
  15.         NTSTATUS status = STATUS_SUCCESS;
  16.         FILE_STANDARD_INFORMATION fsi = { 0 };
  18.         // 初始化结构
  19.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  21.         // 打开文件
  22.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, 0, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  23.         if (!NT_SUCCESS(status))
  24.         {
  25.                 return 0;
  26.         }
  28.         // 获取文件大小信息
  29.         status = ZwQueryInformationFile(hFile, &iosb, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
  30.         if (!NT_SUCCESS(status))
  31.         {
  32.                 ZwClose(hFile);
  33.                 return 0;
  34.         }
  36.         return fsi.EndOfFile.QuadPart;
  37. }
  39. VOID UnDriver(PDRIVER_OBJECT driver)
  40. {
  41.         DbgPrint("驱动卸载 \n");
  42. }
  44. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  45. {
  46.         DbgPrint("hello lyshark.com \n");
  48.         // 获取文件大小
  49.         UNICODE_STRING ustrFileSize;
  50.         RtlInitUnicodeString(&ustrFileSize, L"\\??\\C:\\lyshark.exe");
  51.         ULONG64 ullFileSize = MyGetFileSize(ustrFileSize);
  52.         DbgPrint("获取文件大小: %I64d Bytes \n", ullFileSize);
  54.         Driver->DriverUnload = UnDriver;
  55.         return STATUS_SUCCESS;
  56. }
复制代码
编译并运行如上程序，即可读取到C盘下的lyshark.exe程序的大小字节数，如下图所示；
3.png

内核文件读写: 内核读取文件可以使用ZwReadFile()，内核写入文件则可使用ZwWriteFile()，这两个函数的参数传递基本上一致，如下是读写两个函数的对比参数。
  1. NTSYSAPI NTSTATUS ZwReadFile(
  2.   [in]           HANDLE           FileHandle,      // 文件对象的句柄。
  3.   [in, optional] HANDLE           Event,           // （可选）事件对象的句柄，在读取操作完成后设置为信号状态。
  4.   [in, optional] PIO_APC_ROUTINE  ApcRoutine,      // 此参数为保留参数。
  5.   [in, optional] PVOID            ApcContext,      // 此参数为保留参数。
  6.   [out]          PIO_STATUS_BLOCK IoStatusBlock,   // 接收实际从文件读取的字节数。
  7.   [out]          PVOID            Buffer,          // 指向调用方分配的缓冲区的指针，该缓冲区接收从文件读取的数据。
  8.   [in]           ULONG            Length,          // 缓冲区指向的缓冲区的大小（以字节为单位）。
  9.   [in, optional] PLARGE_INTEGER   ByteOffset,      // 指定将开始读取操作的文件中的起始字节偏移量。
  10.   [in, optional] PULONG           Key
  11. );
  13. NTSYSAPI NTSTATUS ZwWriteFile(
  14.   [in]           HANDLE           FileHandle,
  15.   [in, optional] HANDLE           Event,
  16.   [in, optional] PIO_APC_ROUTINE  ApcRoutine,
  17.   [in, optional] PVOID            ApcContext,
  18.   [out]          PIO_STATUS_BLOCK IoStatusBlock,
  19.   [in]           PVOID            Buffer,
  20.   [in]           ULONG            Length,
  21.   [in, optional] PLARGE_INTEGER   ByteOffset,
  22.   [in, optional] PULONG           Key
  23. );
复制代码
读取文件的代码如下所示，分配非分页pBuffer内存，然后调用MyReadFile()函数，将数据读入到pBuffer并输出，完整代码如下所示；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include <ntifs.h>
  7. #include <ntstrsafe.h>
  9. // 读取文件数据
  10. BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
  11. {
  12.         HANDLE hFile = NULL;
  13.         IO_STATUS_BLOCK iosb = { 0 };
  14.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  15.         NTSTATUS status = STATUS_SUCCESS;
  17.         // 初始化结构
  18.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  20.         // 打开文件
  21.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL,FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN,FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  22.         if (!NT_SUCCESS(status))
  23.         {
  24.                 return FALSE;
  25.         }
  27.         // 初始化
  28.         RtlZeroMemory(&iosb, sizeof(iosb));
  30.         // 读入文件
  31.         status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
  32.         if (!NT_SUCCESS(status))
  33.         {
  34.                 *pulReadDataSize = iosb.Information;
  35.                 ZwClose(hFile);
  36.                 return FALSE;
  37.         }
  39.         // 获取实际读取的数据
  40.         *pulReadDataSize = iosb.Information;
  42.         // 关闭句柄
  43.         ZwClose(hFile);
  45.         return TRUE;
  46. }
  48. VOID UnDriver(PDRIVER_OBJECT driver)
  49. {
  50.         DbgPrint("驱动卸载 \n");
  51. }
  53. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  54. {
  55.         DbgPrint("hello lyshark.com \n");
  57.         UNICODE_STRING ustrScrFile;
  58.         ULONG ulBufferSize = 40960;
  59.         LARGE_INTEGER liOffset = { 0 };
  62.         // 初始化需要读取的文件名
  63.         RtlInitUnicodeString(&ustrScrFile, L"\\??\\C:\\lyshark.exe");
  65.         // 分配非分页内存
  66.         PUCHAR pBuffer = ExAllocatePool(NonPagedPool, ulBufferSize);
  68.         // 读取文件
  69.         MyReadFile(ustrScrFile, liOffset, pBuffer, &ulBufferSize);
  71.         // 输出文件前16个字节
  72.         for (size_t i = 0; i < 16; i++)
  73.         {
  74.                 DbgPrint("%02X \n", pBuffer[i]);
  75.         }
  77.         Driver->DriverUnload = UnDriver;
  78.         return STATUS_SUCCESS;
  79. }
复制代码
编译并运行这段代码，并循环输出lyshark.exe文件的头16个字节的数据，效果图如下所示；
4.png

文件写入MyWriteFile()与读取类似，如下通过运用文件读写实现了文件拷贝功能，实现完整代码如下所示；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include <ntifs.h>
  7. #include <ntstrsafe.h>
  9. // 读取文件数据
  10. BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
  11. {
  12.         HANDLE hFile = NULL;
  13.         IO_STATUS_BLOCK iosb = { 0 };
  14.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  15.         NTSTATUS status = STATUS_SUCCESS;
  17.         // 初始化结构
  18.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  20.         // 打开文件
  21.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL,FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN,FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  22.         if (!NT_SUCCESS(status))
  23.         {
  24.                 return FALSE;
  25.         }
  27.         // 初始化
  28.         RtlZeroMemory(&iosb, sizeof(iosb));
  30.         // 读入文件
  31.         status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
  32.         if (!NT_SUCCESS(status))
  33.         {
  34.                 *pulReadDataSize = iosb.Information;
  35.                 ZwClose(hFile);
  36.                 return FALSE;
  37.         }
  39.         // 获取实际读取的数据
  40.         *pulReadDataSize = iosb.Information;
  42.         // 关闭句柄
  43.         ZwClose(hFile);
  45.         return TRUE;
  46. }
  48. // 向文件写入数据
  49. BOOLEAN MyWriteFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pWriteData, PULONG pulWriteDataSize)
  50. {
  51.         HANDLE hFile = NULL;
  52.         IO_STATUS_BLOCK iosb = { 0 };
  53.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  54.         NTSTATUS status = STATUS_SUCCESS;
  56.         // 初始化结构
  57.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  59.         // 打开文件
  60.         status = ZwCreateFile(&hFile, GENERIC_WRITE, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN_IF, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  61.         if (!NT_SUCCESS(status))
  62.         {
  63.                 return FALSE;
  64.         }
  66.         // 初始化
  67.         RtlZeroMemory(&iosb, sizeof(iosb));
  69.         // 写出文件
  70.         status = ZwWriteFile(hFile, NULL, NULL, NULL, &iosb, pWriteData, *pulWriteDataSize, &liOffset, NULL);
  71.         if (!NT_SUCCESS(status))
  72.         {
  73.                 *pulWriteDataSize = iosb.Information;
  74.                 ZwClose(hFile);
  75.                 return FALSE;
  76.         }
  78.         // 获取实际写入的数据
  79.         *pulWriteDataSize = iosb.Information;
  80.        
  81.         // 关闭句柄
  82.         ZwClose(hFile);
  84.         return TRUE;
  85. }
  87. VOID UnDriver(PDRIVER_OBJECT driver)
  88. {
  89.         DbgPrint("驱动卸载 \n");
  90. }
  92. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  93. {
  94.         DbgPrint("hello lyshark.com \n");
  96.         // 文件读写
  97.         UNICODE_STRING ustrScrFile, ustrDestFile;
  98.         RtlInitUnicodeString(&ustrScrFile, L"\\??\\C:\\lyshark.exe");
  99.         RtlInitUnicodeString(&ustrDestFile, L"\\??\\C:\\LyShark\\new_lyshark.exe");
  101.         ULONG ulBufferSize = 40960;
  102.         ULONG ulReadDataSize = ulBufferSize;
  103.         LARGE_INTEGER liOffset = { 0 };
  105.         // 分配非分页内存
  106.         PUCHAR pBuffer = ExAllocatePool(NonPagedPool, ulBufferSize);
  108.         do
  109.         {
  110.                 // 读取文件
  111.                 ulReadDataSize = ulBufferSize;
  112.                 MyReadFile(ustrScrFile, liOffset, pBuffer, &ulReadDataSize);
  114.                 // 数据为空则读取结束
  115.                 if (0 >= ulReadDataSize)
  116.                 {
  117.                         break;
  118.                 }
  120.                 // 写入文件
  121.                 MyWriteFile(ustrDestFile, liOffset, pBuffer, &ulReadDataSize);
  123.                 // 更新偏移
  124.                 liOffset.QuadPart = liOffset.QuadPart + ulReadDataSize;
  125.                 DbgPrint("[+] 更新偏移: %d \n", liOffset.QuadPart);
  127.         } while (TRUE);
  129.         // 释放内存
  130.         ExFreePool(pBuffer);
  131.         DbgPrint("[*] 已将文件复制到新目录 \n");
  133.         Driver->DriverUnload = UnDriver;
  134.         return STATUS_SUCCESS;
  135. }
复制代码
编译并运行这段程序，则自动将C:\\lyshark.exe盘符下的文件拷贝到C:\\LyShark\\new_lyshark.exe目录下，实现效果图如下所示；
5.png

实现文件读写传递: 通过如上学习相信你已经掌握了如何使用文件读写系列函数了，接下来将封装一个文件读写驱动，应用层接收，驱动层读取；
此驱动部分完整代码如下所示；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  5. #include <ntifs.h>
  6. #include <windef.h>
  8. #define READ_FILE_SIZE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
  9. #define READ_FILE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)
  11. #define DEVICENAME L"\\Device\\ReadWriteDevice"
  12. #define SYMBOLNAME L"\\??\\ReadWriteSymbolName"
  14. typedef struct
  15. {
  16.         ULONG64 size;      // 读写长度
  17.         BYTE* data;        // 读写数据集
  18. }FileData;
  20. // 获取文件大小
  21. ULONG64 MyGetFileSize(UNICODE_STRING ustrFileName)
  22. {
  23.         HANDLE hFile = NULL;
  24.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  25.         IO_STATUS_BLOCK iosb = { 0 };
  26.         NTSTATUS status = STATUS_SUCCESS;
  27.         FILE_STANDARD_INFORMATION fsi = { 0 };
  29.         // 初始化结构
  30.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  32.         // 打开文件
  33.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, 0, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  34.         if (!NT_SUCCESS(status))
  35.         {
  36.                 return 0;
  37.         }
  39.         // 获取文件大小信息
  40.         status = ZwQueryInformationFile(hFile, &iosb, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
  41.         if (!NT_SUCCESS(status))
  42.         {
  43.                 ZwClose(hFile);
  44.                 return 0;
  45.         }
  47.         return fsi.EndOfFile.QuadPart;
  48. }
  50. // 读取文件数据
  51. BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
  52. {
  53.         HANDLE hFile = NULL;
  54.         IO_STATUS_BLOCK iosb = { 0 };
  55.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  56.         NTSTATUS status = STATUS_SUCCESS;
  58.         // 初始化结构
  59.         InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
  61.         // 打开文件
  62.         status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
  63.         if (!NT_SUCCESS(status))
  64.         {
  65.                 return FALSE;
  66.         }
  68.         // 初始化
  69.         RtlZeroMemory(&iosb, sizeof(iosb));
  71.         // 读入文件
  72.         status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
  73.         if (!NT_SUCCESS(status))
  74.         {
  75.                 *pulReadDataSize = iosb.Information;
  76.                 ZwClose(hFile);
  77.                 return FALSE;
  78.         }
  80.         // 获取实际读取的数据
  81.         *pulReadDataSize = iosb.Information;
  83.         // 关闭句柄
  84.         ZwClose(hFile);
  86.         return TRUE;
  87. }
  89. NTSTATUS DriverIrpCtl(PDEVICE_OBJECT device, PIRP pirp)
  90. {
  91.         PIO_STACK_LOCATION stack;
  92.         stack = IoGetCurrentIrpStackLocation(pirp);
  93.         FileData* FileDataPtr;
  95.         switch (stack->MajorFunction)
  96.         {
  98.         case IRP_MJ_CREATE:
  99.         {
  100.                 break;
  101.         }
  103.         case IRP_MJ_CLOSE:
  104.         {
  105.                 break;
  106.         }
  108.         case IRP_MJ_DEVICE_CONTROL:
  109.         {
  110.                 // 获取应用层传值
  111.                 FileDataPtr = pirp->AssociatedIrp.SystemBuffer;
  112.                 switch (stack->Parameters.DeviceIoControl.IoControlCode)
  113.                 {
  114.                         // 读取内存函数
  115.                 case READ_FILE_SIZE_CODE:
  116.                 {
  117.                         LARGE_INTEGER liOffset = { 0 };
  118.                         UNICODE_STRING ustrFileSize;
  119.                         RtlInitUnicodeString(&ustrFileSize, L"\\??\\C:\\Windows\\system32\\ntoskrnl.exe");
  121.                         // 获取文件长度
  122.                         ULONG64 ulBufferSize = MyGetFileSize(ustrFileSize);
  123.                         DbgPrint("获取文件大小: %I64d Bytes \n", ulBufferSize);
  125.                         // 将长度返回应用层
  126.                         FileDataPtr->size = ulBufferSize;
  127.                         break;
  128.                 }
  130.                 // 读取文件
  131.                 case READ_FILE_CODE:
  132.                 {
  133.                         FileData ptr;
  135.                         LARGE_INTEGER liOffset = { 0 };
  136.                         UNICODE_STRING ustrFileSize;
  137.                         RtlInitUnicodeString(&ustrFileSize, L"\\??\\C:\\Windows\\system32\\ntoskrnl.exe");
  139.                         // 获取文件长度
  140.                         ULONG64 ulBufferSize = MyGetFileSize(ustrFileSize);
  141.                         DbgPrint("获取文件大小: %I64d Bytes \n", ulBufferSize);
  143.                         // 读取内存到缓冲区
  144.                         BYTE* pBuffer = ExAllocatePool(NonPagedPool, ulBufferSize);
  145.                         MyReadFile(ustrFileSize, liOffset, pBuffer, &ulBufferSize);
  147.                         // 返回数据
  148.                         FileDataPtr->size = ulBufferSize;
  149.                         RtlCopyMemory(FileDataPtr->data, pBuffer, FileDataPtr->size);
  151.                         break;
  152.                 }
  153.                 }
  155.                 pirp->IoStatus.Information = sizeof(FileDataPtr);
  156.                 break;
  157.         }
  159.         }
  161.         pirp->IoStatus.Status = STATUS_SUCCESS;
  162.         IoCompleteRequest(pirp, IO_NO_INCREMENT);
  163.         return STATUS_SUCCESS;
  164. }
  166. VOID UnDriver(PDRIVER_OBJECT driver)
  167. {
  168.         if (driver->DeviceObject)
  169.         {
  170.                 UNICODE_STRING SymbolName;
  171.                 RtlInitUnicodeString(&SymbolName, SYMBOLNAME);
  173.                 // 删除符号链接
  174.                 IoDeleteSymbolicLink(&SymbolName);
  175.                 IoDeleteDevice(driver->DeviceObject);
  176.         }
  177. }
  179. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  180. {
  181.         NTSTATUS status = STATUS_SUCCESS;
  182.         PDEVICE_OBJECT device = NULL;
  183.         UNICODE_STRING DeviceName;
  185.         DbgPrint("[LyShark] hello lyshark.com \n");
  187.         // 初始化设备名
  188.         RtlInitUnicodeString(&DeviceName, DEVICENAME);
  190.         // 创建设备
  191.         status = IoCreateDevice(Driver, sizeof(Driver->DriverExtension), &DeviceName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &device);
  192.         if (status == STATUS_SUCCESS)
  193.         {
  194.                 UNICODE_STRING SymbolName;
  195.                 RtlInitUnicodeString(&SymbolName, SYMBOLNAME);
  197.                 // 创建符号链接
  198.                 status = IoCreateSymbolicLink(&SymbolName, &DeviceName);
  200.                 // 失败则删除设备
  201.                 if (status != STATUS_SUCCESS)
  202.                 {
  203.                         IoDeleteDevice(device);
  204.                 }
  205.         }
  207.         // 派遣函数初始化
  208.         Driver->MajorFunction[IRP_MJ_CREATE] = DriverIrpCtl;
  209.         Driver->MajorFunction[IRP_MJ_CLOSE] = DriverIrpCtl;
  210.         Driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DriverIrpCtl;
  212.         // 卸载驱动
  213.         Driver->DriverUnload = UnDriver;
  215.         return STATUS_SUCCESS;
  216. }
复制代码
客户端完整代码如下所示；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #define _CRT_SECURE_NO_WARNINGS
  7. #include <Windows.h>
  8. #include <iostream>
  10. #define READ_FILE_SIZE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
  11. #define READ_FILE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)
  13. typedef struct
  14. {
  15.         DWORD size;      // 读写长度
  16.         BYTE* data;      // 读写数据集
  17. }FileData;
  19. int main(int argc, char* argv[])
  20. {
  21.         // 连接到驱动
  22.         HANDLE handle = CreateFileA("\\??\\ReadWriteSymbolName", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  24.         FileData data;
  25.         DWORD dwSize = 0;
  27.         // 首先得到文件长度
  28.         DeviceIoControl(handle, READ_FILE_SIZE_CODE, 0, 0, &data, sizeof(data), &dwSize, NULL);
  29.         printf("%d \n", data.size);
  31.         // 读取机器码到BYTE字节数组
  32.         data.data = new BYTE[data.size];
  34.         DeviceIoControl(handle, READ_FILE_CODE, &data, sizeof(data), &data, sizeof(data), &dwSize, NULL);
  35.         for (int i = 0; i < data.size; i++)
  36.         {
  37.                 printf("0x%02X ", data.data[i]);
  38.         }
  40.         printf("\n");
  41.         getchar();
  42.         CloseHandle(handle);
  43.         return 0;
  44. }
复制代码
通过驱动加载工具将WinDDK.sys拉起来，然后启动客户端进程，即可输出ntoskrnl.exe的文件数据，如下图所示；
6.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
奄幂牛
2025-6-6 19:52:14

0

粉丝关注

18

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫