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

驱动,开发,内核,文件,读写,系列,函数 · 浏览次数 : 204

小编点评

**代码概述** **文件连接** ```c++ HANDLE handle = CreateFileA("\\\\??\\\\ReadWriteSymbolName", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); ``` **读文件长度** ```c++ DeviceIoControl(handle, READ_FILE_SIZE_CODE, 0, 0, &data, sizeof(data), &dwSize, NULL); ``` **读取机器码** ```c++ data.data = new BYTE[data.size]; DeviceIoControl(handle, READ_FILE_CODE, &data, sizeof(data), &data, sizeof(data), &dwSize, NULL); ``` **输出文件数据** ```c++ for (int i = 0; i < data.size; i++) { printf("0x%02X \", data.data[i]); } ``` **其他** * 代码使用 PowerBy 库进行文件连接和设备管理。 * 在读取机器码之前分配内存。 * 输出数据使用十六进制格式输出。

正文

在应用层下的文件操作只需要调用微软应用层下的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属性则默认为创建目录,该函数的微软定义以及备注信息如下所示;

NTSYSAPI NTSTATUS ZwCreateFile(
  [out]          PHANDLE            FileHandle,        // 指向HANDLE变量的指针,该变量接收文件的句柄。
  [in]           ACCESS_MASK        DesiredAccess,     // 指定一个ACCESS_MASK值,该值确定对对象的请求访问权限。
  [in]           POBJECT_ATTRIBUTES ObjectAttributes,  // 指向OBJECT_ATTRIBUTES结构的指针,该结构指定对象名称和其他属性。
  [out]          PIO_STATUS_BLOCK   IoStatusBlock,     // 指向IO_STATUS_BLOCK结构的指针,该结构接收最终完成状态和有关所请求操作的其他信息。 
  [in, optional] PLARGE_INTEGER     AllocationSize,    // 指向LARGE_INTEGER的指针,其中包含创建或覆盖的文件的初始分配大小(以字节为单位)。
  [in]           ULONG              FileAttributes,    // 指定一个或多个FILE_ATTRIBUTE_XXX标志,这些标志表示在创建或覆盖文件时要设置的文件属性。
  [in]           ULONG              ShareAccess,       // 共享访问的类型,指定为零或以下标志的任意组合。
  [in]           ULONG              CreateDisposition, // 指定在文件存在或不存在时要执行的操作。
  [in]           ULONG              CreateOptions,     // 指定要在驱动程序创建或打开文件时应用的选项。
  [in, optional] PVOID              EaBuffer,          // 对于设备和中间驱动程序,此参数必须是NULL指针。
  [in]           ULONG              EaLength           // 对于设备和中间驱动程序,此参数必须为零。
);

参数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参数即可,其微软定义如下所示;

NTSYSAPI NTSTATUS ZwDeleteFile(
  [in] POBJECT_ATTRIBUTES ObjectAttributes
);

接下来我们就封装三个函数MyCreateFile()用于创建文件,MyCreateFileFolder()用于创建目录,MyDeleteFileOrFileFolder()用于删除空目录。

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#include <ntifs.h>
#include <ntstrsafe.h>

// 创建文件
BOOLEAN MyCreateFile(UNICODE_STRING ustrFilePath)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	// 初始化对象属性结构体 FILE_SYNCHRONOUS_IO_NONALERT
	InitializeObjectAttributes(&objectAttributes, &ustrFilePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 创建文件
	status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}

// 创建目录
BOOLEAN MyCreateFileFolder(UNICODE_STRING ustrFileFolderPath)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	// 初始化对象属性结构体
	InitializeObjectAttributes(&objectAttributes, &ustrFileFolderPath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 创建目录 FILE_DIRECTORY_FILE
	status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_CREATE, FILE_DIRECTORY_FILE, NULL, 0);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}
	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}

// 删除文件或是空目录
BOOLEAN MyDeleteFileOrFileFolder(UNICODE_STRING ustrFileName)
{
	NTSTATUS status = STATUS_SUCCESS;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };

	// 初始化属性
	InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 执行删除操作
	status = ZwDeleteFile(&objectAttributes);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	return TRUE;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
	BOOLEAN ref = FALSE;

	// 删除文件
	UNICODE_STRING ustrDeleteFile;
	RtlInitUnicodeString(&ustrDeleteFile, L"\\??\\C:\\LySharkFolder\\lyshark.txt");
	ref = MyDeleteFileOrFileFolder(ustrDeleteFile);
	if (ref != FALSE)
	{
		DbgPrint("[LyShark] 删除文件成功 \n");
	}
	else
	{
		DbgPrint("[LyShark] 删除文件失败 \n");
	}

	// 删除空目录
	UNICODE_STRING ustrDeleteFilder;
	RtlInitUnicodeString(&ustrDeleteFilder, L"\\??\\C:\\LySharkFolder");
	ref = MyDeleteFileOrFileFolder(ustrDeleteFilder);
	if (ref != FALSE)
	{
		DbgPrint("[LyShark] 删除空目录成功 \n");
	}
	else
	{
		DbgPrint("[LyShark] 删除空目录失败 \n");
	}

	DbgPrint("驱动卸载 \n");
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
	DbgPrint("hello lyshark.com \n");

	BOOLEAN ref = FALSE;


	// 创建目录
	UNICODE_STRING ustrDirectory;
	RtlInitUnicodeString(&ustrDirectory, L"\\??\\C:\\LySharkFolder");
	ref = MyCreateFileFolder(ustrDirectory);
	if (ref != FALSE)
	{
		DbgPrint("[LyShark] 创建目录成功 \n");
	}
	else
	{
		DbgPrint("[LyShark] 创建文件失败 \n");
	}

	// 创建文件
	UNICODE_STRING ustrCreateFile;
	RtlInitUnicodeString(&ustrCreateFile, L"\\??\\C:\\LySharkFolder\\lyshark.txt");
	ref = MyCreateFile(ustrCreateFile);
	if (ref != FALSE)
	{
		DbgPrint("[LyShark] 创建文件成功 \n");
	}
	else
	{
		DbgPrint("[LyShark] 创建文件失败 \n");
	}

	Driver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

运行如上代码,分别创建LySharkFolder目录,并在其中创建lyshark.txt最终再将其删除,输出效果如下;

重命名文件或目录: 在内核中重命名文件或目录核心功能的实现依赖于ZwSetInformationFile()这个内核函数,该函数可用于更改有关文件对象的各种信息,其微软官方定义如下;

NTSYSAPI NTSTATUS ZwSetInformationFile(
  [in]  HANDLE                 FileHandle,          // 文件句柄
  [out] PIO_STATUS_BLOCK       IoStatusBlock,       // 指向 IO_STATUS_BLOCK 结构的指针
  [in]  PVOID                  FileInformation,     // 指向缓冲区的指针,该缓冲区包含要为文件设置的信息。
  [in]  ULONG                  Length,              // 缓冲区的大小(以字节为单位)
  [in]  FILE_INFORMATION_CLASS FileInformationClass // 为文件设置的类型
);

这其中最重要的参数就是FileInformationClass根据该参数的不同则对文件的操作方式也就不同,如果需要重命名文件则此处应使用FileRenameInformation而如果需要修改文件的当前信息则应使用FilePositionInformation创建链接文件则使用FileLinkInformation即可,以重命名为例,首先我们需要定义一个FILE_RENAME_INFORMATION结构并按照要求填充,最后直接使用ZwSetInformationFile()并传入相关信息后即可完成修改,其完整代码流程如下;

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#include <ntifs.h>
#include <ntstrsafe.h>

// 重命名文件或文件夹
BOOLEAN MyRename(UNICODE_STRING ustrSrcFileName, UNICODE_STRING ustrDestFileName)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	PFILE_RENAME_INFORMATION pRenameInfo = NULL;

	ULONG ulLength = (1024 + sizeof(FILE_RENAME_INFORMATION));

	// 为PFILE_RENAME_INFORMATION结构申请内存
	pRenameInfo = (PFILE_RENAME_INFORMATION)ExAllocatePool(NonPagedPool, ulLength);
	if (NULL == pRenameInfo)
	{
		return FALSE;
	}

	// 设置重命名信息
	RtlZeroMemory(pRenameInfo, ulLength);

	// 设置文件名长度以及文件名
	pRenameInfo->FileNameLength = ustrDestFileName.Length;
	wcscpy(pRenameInfo->FileName, ustrDestFileName.Buffer);
	pRenameInfo->ReplaceIfExists = 0;
	pRenameInfo->RootDirectory = NULL;

	// 初始化结构
	InitializeObjectAttributes(&objectAttributes, &ustrSrcFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 打开文件
	status = ZwCreateFile(&hFile, SYNCHRONIZE | DELETE, &objectAttributes, &iosb, NULL, 0, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT | FILE_NO_INTERMEDIATE_BUFFERING, NULL, 0);
	if (!NT_SUCCESS(status))
	{
		ExFreePool(pRenameInfo);
		return FALSE;
	}
	// 利用ZwSetInformationFile来设置文件信息
	status = ZwSetInformationFile(hFile, &iosb, pRenameInfo, ulLength, FileRenameInformation);
	if (!NT_SUCCESS(status))
	{
		ZwClose(hFile);
		ExFreePool(pRenameInfo);
		return FALSE;
	}

	// 释放内存,关闭句柄
	ExFreePool(pRenameInfo);
	ZwClose(hFile);

	return TRUE;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
	DbgPrint("驱动卸载 \n");
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
	DbgPrint("hello lyshark.com \n");

	// 重命名文件
	UNICODE_STRING ustrOldFile, ustrNewFile;
	RtlInitUnicodeString(&ustrOldFile, L"\\??\\C:\\MyCreateFolder\\lyshark.txt");
	RtlInitUnicodeString(&ustrNewFile, L"\\??\\C:\\MyCreateFolder\\hello_lyshark.txt");
	BOOLEAN ref = MyRename(ustrOldFile, ustrNewFile);
	if (ref == TRUE)
	{
		DbgPrint("已完成改名 \n");
	}

	Driver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

运行后将会把C:\\MyCreateFolder\\lyshark.txt目录下的文件改名为hello_lyshark.txt,前提是该目录与该文件必须存在;

那么如果你需要将文件设置为只读模式或修改文件的创建日期,那么你就需要看一下微软的定义FILE_BASIC_INFORMATION结构,依次填充此结构体并调用ZwSetInformationFile()即可实现修改,该结构的定义如下所示;

typedef struct _FILE_BASIC_INFORMATION {
    LARGE_INTEGER CreationTime;
    LARGE_INTEGER LastAccessTime;
    LARGE_INTEGER LastWriteTime;
    LARGE_INTEGER ChangeTime;
    ULONG FileAttributes;
} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;

当然如果你要修改日期你还需要自行填充LARGE_INTEGER结构,该结构的微软定义如下所示,分为高位和低位依次填充即可;

#if defined(MIDL_PASS)
typedef struct _LARGE_INTEGER {
#else // MIDL_PASS
typedef union _LARGE_INTEGER {
    struct {
        ULONG LowPart;
        LONG HighPart;
    } DUMMYSTRUCTNAME;
    struct {
        ULONG LowPart;
        LONG HighPart;
    } u;
#endif //MIDL_PASS
    LONGLONG QuadPart;
} LARGE_INTEGER;

我们就以修改文件属性为只读模式为例,其核心代码可以被描述为如下样子,相比于改名而言其唯一的变化就是更换了PFILE_BASIC_INFORMATION结构体,其他的基本一致;

HANDLE hFile = NULL;
OBJECT_ATTRIBUTES objectAttributes = { 0 };
IO_STATUS_BLOCK iosb = { 0 };
NTSTATUS status = STATUS_SUCCESS;

PFILE_BASIC_INFORMATION pReplaceInfo = NULL;

ULONG ulLength = (1024 + sizeof(FILE_BASIC_INFORMATION));

// 为FILE_POSITION_INFORMATION结构申请内存
pReplaceInfo = (PFILE_BASIC_INFORMATION)ExAllocatePool(NonPagedPool, ulLength);
if (NULL == pReplaceInfo)
{
  return FALSE;
}

RtlZeroMemory(pReplaceInfo, ulLength);

// 设置文件基础信息,将文件设置为只读模式
pReplaceInfo->FileAttributes |= FILE_ATTRIBUTE_READONLY;

读取文件大小: 读取特定文件的所占空间,核心原理是调用了ZwQueryInformationFile()这个内核函数,该函数可以返回有关文件对象的各种信息,参数传递上与ZwSetInformationFile()很相似,其FileInformationClass都需要传入一个文件类型结构,该函数的完整定义如下;

NTSYSAPI NTSTATUS ZwQueryInformationFile(
  [in]  HANDLE                 FileHandle,          // 文件句柄。
  [out] PIO_STATUS_BLOCK       IoStatusBlock,       // 指向接收最终完成状态和操作相关信息的 IO_STATUS_BLOCK 结构的指针。
  [out] PVOID                  FileInformation,     // 指向调用方分配的缓冲区的指针,例程将请求的有关文件对象的信息写入其中。
  [in]  ULONG                  Length,              // 长度。
  [in]  FILE_INFORMATION_CLASS FileInformationClass // 指定要在 FileInformation 指向的缓冲区中返回的有关文件的信息类型。
);

本例中我们需要读入文件的所占字节数,那么FileInformation字段就需要传入FileStandardInformation来获取文件的基本信息,获取到的信息会被存储到FILE_STANDARD_INFORMATION结构内,用户只需要解析该结构体fsi.EndOfFile.QuadPart即可得到文件长度,其完整代码如下所示;

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#include <ntifs.h>
#include <ntstrsafe.h>

// 获取文件大小
ULONG64 MyGetFileSize(UNICODE_STRING ustrFileName)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;
	FILE_STANDARD_INFORMATION fsi = { 0 };

	// 初始化结构
	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))
	{
		return 0;
	}

	// 获取文件大小信息
	status = ZwQueryInformationFile(hFile, &iosb, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
	if (!NT_SUCCESS(status))
	{
		ZwClose(hFile);
		return 0;
	}

	return fsi.EndOfFile.QuadPart;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
	DbgPrint("驱动卸载 \n");
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
	DbgPrint("hello lyshark.com \n");

	// 获取文件大小
	UNICODE_STRING ustrFileSize;
	RtlInitUnicodeString(&ustrFileSize, L"\\??\\C:\\lyshark.exe");
	ULONG64 ullFileSize = MyGetFileSize(ustrFileSize);
	DbgPrint("获取文件大小: %I64d Bytes \n", ullFileSize);

	Driver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

编译并运行如上程序,即可读取到C盘下的lyshark.exe程序的大小字节数,如下图所示;

内核文件读写: 内核读取文件可以使用ZwReadFile(),内核写入文件则可使用ZwWriteFile(),这两个函数的参数传递基本上一致,如下是读写两个函数的对比参数。

NTSYSAPI NTSTATUS ZwReadFile(
  [in]           HANDLE           FileHandle,      // 文件对象的句柄。
  [in, optional] HANDLE           Event,           // (可选)事件对象的句柄,在读取操作完成后设置为信号状态。
  [in, optional] PIO_APC_ROUTINE  ApcRoutine,      // 此参数为保留参数。
  [in, optional] PVOID            ApcContext,      // 此参数为保留参数。
  [out]          PIO_STATUS_BLOCK IoStatusBlock,   // 接收实际从文件读取的字节数。
  [out]          PVOID            Buffer,          // 指向调用方分配的缓冲区的指针,该缓冲区接收从文件读取的数据。
  [in]           ULONG            Length,          // 缓冲区指向的缓冲区的大小(以字节为单位)。
  [in, optional] PLARGE_INTEGER   ByteOffset,      // 指定将开始读取操作的文件中的起始字节偏移量。
  [in, optional] PULONG           Key
);

NTSYSAPI NTSTATUS ZwWriteFile(
  [in]           HANDLE           FileHandle,
  [in, optional] HANDLE           Event,
  [in, optional] PIO_APC_ROUTINE  ApcRoutine,
  [in, optional] PVOID            ApcContext,
  [out]          PIO_STATUS_BLOCK IoStatusBlock,
  [in]           PVOID            Buffer,
  [in]           ULONG            Length,
  [in, optional] PLARGE_INTEGER   ByteOffset,
  [in, optional] PULONG           Key
);

读取文件的代码如下所示,分配非分页pBuffer内存,然后调用MyReadFile()函数,将数据读入到pBuffer并输出,完整代码如下所示;

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#include <ntifs.h>
#include <ntstrsafe.h>

// 读取文件数据
BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
{
	HANDLE hFile = NULL;
	IO_STATUS_BLOCK iosb = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	// 初始化结构
	InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 打开文件
	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);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 初始化
	RtlZeroMemory(&iosb, sizeof(iosb));

	// 读入文件
	status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
	if (!NT_SUCCESS(status))
	{
		*pulReadDataSize = iosb.Information;
		ZwClose(hFile);
		return FALSE;
	}

	// 获取实际读取的数据
	*pulReadDataSize = iosb.Information;

	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
	DbgPrint("驱动卸载 \n");
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
	DbgPrint("hello lyshark.com \n");

	UNICODE_STRING ustrScrFile;
	ULONG ulBufferSize = 40960;
	LARGE_INTEGER liOffset = { 0 };


	// 初始化需要读取的文件名
	RtlInitUnicodeString(&ustrScrFile, L"\\??\\C:\\lyshark.exe");

	// 分配非分页内存
	PUCHAR pBuffer = ExAllocatePool(NonPagedPool, ulBufferSize);

	// 读取文件
	MyReadFile(ustrScrFile, liOffset, pBuffer, &ulBufferSize);

	// 输出文件前16个字节
	for (size_t i = 0; i < 16; i++)
	{
		DbgPrint("%02X \n", pBuffer[i]);
	}

	Driver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

编译并运行这段代码,并循环输出lyshark.exe文件的头16个字节的数据,效果图如下所示;

文件写入MyWriteFile()与读取类似,如下通过运用文件读写实现了文件拷贝功能,实现完整代码如下所示;

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#include <ntifs.h>
#include <ntstrsafe.h>

// 读取文件数据
BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
{
	HANDLE hFile = NULL;
	IO_STATUS_BLOCK iosb = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	// 初始化结构
	InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 打开文件
	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);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 初始化
	RtlZeroMemory(&iosb, sizeof(iosb));

	// 读入文件
	status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
	if (!NT_SUCCESS(status))
	{
		*pulReadDataSize = iosb.Information;
		ZwClose(hFile);
		return FALSE;
	}

	// 获取实际读取的数据
	*pulReadDataSize = iosb.Information;

	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}

// 向文件写入数据
BOOLEAN MyWriteFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pWriteData, PULONG pulWriteDataSize)
{
	HANDLE hFile = NULL;
	IO_STATUS_BLOCK iosb = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	// 初始化结构
	InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 打开文件
	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);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 初始化
	RtlZeroMemory(&iosb, sizeof(iosb));

	// 写出文件
	status = ZwWriteFile(hFile, NULL, NULL, NULL, &iosb, pWriteData, *pulWriteDataSize, &liOffset, NULL);
	if (!NT_SUCCESS(status))
	{
		*pulWriteDataSize = iosb.Information;
		ZwClose(hFile);
		return FALSE;
	}

	// 获取实际写入的数据
	*pulWriteDataSize = iosb.Information;
	
	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
	DbgPrint("驱动卸载 \n");
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
	DbgPrint("hello lyshark.com \n");

	// 文件读写
	UNICODE_STRING ustrScrFile, ustrDestFile;
	RtlInitUnicodeString(&ustrScrFile, L"\\??\\C:\\lyshark.exe");
	RtlInitUnicodeString(&ustrDestFile, L"\\??\\C:\\LyShark\\new_lyshark.exe");

	ULONG ulBufferSize = 40960;
	ULONG ulReadDataSize = ulBufferSize;
	LARGE_INTEGER liOffset = { 0 };

	// 分配非分页内存
	PUCHAR pBuffer = ExAllocatePool(NonPagedPool, ulBufferSize);

	do
	{
		// 读取文件
		ulReadDataSize = ulBufferSize;
		MyReadFile(ustrScrFile, liOffset, pBuffer, &ulReadDataSize);

		// 数据为空则读取结束
		if (0 >= ulReadDataSize)
		{
			break;
		}

		// 写入文件
		MyWriteFile(ustrDestFile, liOffset, pBuffer, &ulReadDataSize);

		// 更新偏移
		liOffset.QuadPart = liOffset.QuadPart + ulReadDataSize;
		DbgPrint("[+] 更新偏移: %d \n", liOffset.QuadPart);

	} while (TRUE);

	// 释放内存
	ExFreePool(pBuffer);
	DbgPrint("[*] 已将文件复制到新目录 \n");

	Driver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

编译并运行这段程序,则自动将C:\\lyshark.exe盘符下的文件拷贝到C:\\LyShark\\new_lyshark.exe目录下,实现效果图如下所示;

实现文件读写传递: 通过如上学习相信你已经掌握了如何使用文件读写系列函数了,接下来将封装一个文件读写驱动,应用层接收,驱动层读取;

此驱动部分完整代码如下所示;

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com
#include <ntifs.h>
#include <windef.h>

#define READ_FILE_SIZE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
#define READ_FILE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)

#define DEVICENAME L"\\Device\\ReadWriteDevice"
#define SYMBOLNAME L"\\??\\ReadWriteSymbolName"

typedef struct
{
	ULONG64 size;      // 读写长度
	BYTE* data;        // 读写数据集
}FileData;

// 获取文件大小
ULONG64 MyGetFileSize(UNICODE_STRING ustrFileName)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;
	FILE_STANDARD_INFORMATION fsi = { 0 };

	// 初始化结构
	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))
	{
		return 0;
	}

	// 获取文件大小信息
	status = ZwQueryInformationFile(hFile, &iosb, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
	if (!NT_SUCCESS(status))
	{
		ZwClose(hFile);
		return 0;
	}

	return fsi.EndOfFile.QuadPart;
}

// 读取文件数据
BOOLEAN MyReadFile(UNICODE_STRING ustrFileName, LARGE_INTEGER liOffset, PUCHAR pReadData, PULONG pulReadDataSize)
{
	HANDLE hFile = NULL;
	IO_STATUS_BLOCK iosb = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	// 初始化结构
	InitializeObjectAttributes(&objectAttributes, &ustrFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 打开文件
	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);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 初始化
	RtlZeroMemory(&iosb, sizeof(iosb));

	// 读入文件
	status = ZwReadFile(hFile, NULL, NULL, NULL, &iosb, pReadData, *pulReadDataSize, &liOffset, NULL);
	if (!NT_SUCCESS(status))
	{
		*pulReadDataSize = iosb.Information;
		ZwClose(hFile);
		return FALSE;
	}

	// 获取实际读取的数据
	*pulReadDataSize = iosb.Information;

	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}

NTSTATUS DriverIrpCtl(PDEVICE_OBJECT device, PIRP pirp)
{
	PIO_STACK_LOCATION stack;
	stack = IoGetCurrentIrpStackLocation(pirp);
	FileData* FileDataPtr;

	switch (stack->MajorFunction)
	{

	case IRP_MJ_CREATE:
	{
		break;
	}

	case IRP_MJ_CLOSE:
	{
		break;
	}

	case IRP_MJ_DEVICE_CONTROL:
	{
		// 获取应用层传值
		FileDataPtr = pirp->AssociatedIrp.SystemBuffer;
		switch (stack->Parameters.DeviceIoControl.IoControlCode)
		{
			// 读取内存函数
		case READ_FILE_SIZE_CODE:
		{
			LARGE_INTEGER liOffset = { 0 };
			UNICODE_STRING ustrFileSize;
			RtlInitUnicodeString(&ustrFileSize, L"\\??\\C:\\Windows\\system32\\ntoskrnl.exe");

			// 获取文件长度
			ULONG64 ulBufferSize = MyGetFileSize(ustrFileSize);
			DbgPrint("获取文件大小: %I64d Bytes \n", ulBufferSize);

			// 将长度返回应用层
			FileDataPtr->size = ulBufferSize;
			break;
		}

		// 读取文件
		case READ_FILE_CODE:
		{
			FileData ptr;

			LARGE_INTEGER liOffset = { 0 };
			UNICODE_STRING ustrFileSize;
			RtlInitUnicodeString(&ustrFileSize, L"\\??\\C:\\Windows\\system32\\ntoskrnl.exe");

			// 获取文件长度
			ULONG64 ulBufferSize = MyGetFileSize(ustrFileSize);
			DbgPrint("获取文件大小: %I64d Bytes \n", ulBufferSize);

			// 读取内存到缓冲区
			BYTE* pBuffer = ExAllocatePool(NonPagedPool, ulBufferSize);
			MyReadFile(ustrFileSize, liOffset, pBuffer, &ulBufferSize);

			// 返回数据
			FileDataPtr->size = ulBufferSize;
			RtlCopyMemory(FileDataPtr->data, pBuffer, FileDataPtr->size);

			break;
		}
		}

		pirp->IoStatus.Information = sizeof(FileDataPtr);
		break;
	}

	}

	pirp->IoStatus.Status = STATUS_SUCCESS;
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
	if (driver->DeviceObject)
	{
		UNICODE_STRING SymbolName;
		RtlInitUnicodeString(&SymbolName, SYMBOLNAME);

		// 删除符号链接
		IoDeleteSymbolicLink(&SymbolName);
		IoDeleteDevice(driver->DeviceObject);
	}
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
	NTSTATUS status = STATUS_SUCCESS;
	PDEVICE_OBJECT device = NULL;
	UNICODE_STRING DeviceName;

	DbgPrint("[LyShark] hello lyshark.com \n");

	// 初始化设备名
	RtlInitUnicodeString(&DeviceName, DEVICENAME);

	// 创建设备
	status = IoCreateDevice(Driver, sizeof(Driver->DriverExtension), &DeviceName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &device);
	if (status == STATUS_SUCCESS)
	{
		UNICODE_STRING SymbolName;
		RtlInitUnicodeString(&SymbolName, SYMBOLNAME);

		// 创建符号链接
		status = IoCreateSymbolicLink(&SymbolName, &DeviceName);

		// 失败则删除设备
		if (status != STATUS_SUCCESS)
		{
			IoDeleteDevice(device);
		}
	}

	// 派遣函数初始化
	Driver->MajorFunction[IRP_MJ_CREATE] = DriverIrpCtl;
	Driver->MajorFunction[IRP_MJ_CLOSE] = DriverIrpCtl;
	Driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DriverIrpCtl;

	// 卸载驱动
	Driver->DriverUnload = UnDriver;

	return STATUS_SUCCESS;
}

客户端完整代码如下所示;

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#define _CRT_SECURE_NO_WARNINGS
#include <Windows.h>
#include <iostream>

#define READ_FILE_SIZE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
#define READ_FILE_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)

typedef struct
{
	DWORD size;      // 读写长度
	BYTE* data;      // 读写数据集
}FileData;

int main(int argc, char* argv[])
{
	// 连接到驱动
	HANDLE handle = CreateFileA("\\??\\ReadWriteSymbolName", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	FileData data;
	DWORD dwSize = 0;

	// 首先得到文件长度
	DeviceIoControl(handle, READ_FILE_SIZE_CODE, 0, 0, &data, sizeof(data), &dwSize, NULL);
	printf("%d \n", data.size);

	// 读取机器码到BYTE字节数组
	data.data = new BYTE[data.size];

	DeviceIoControl(handle, READ_FILE_CODE, &data, sizeof(data), &data, sizeof(data), &dwSize, NULL);
	for (int i = 0; i < data.size; i++)
	{
		printf("0x%02X ", data.data[i]);
	}

	printf("\n");
	getchar();
	CloseHandle(handle);
	return 0;
}

通过驱动加载工具将WinDDK.sys拉起来,然后启动客户端进程,即可输出ntoskrnl.exe的文件数据,如下图所示;

与驱动开发:内核文件读写系列函数相似的内容:

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

在应用层下的文件操作只需要调用微软应用层下的`API`函数及`C库`标准函数即可,而如果在内核中读写文件则应用层的API显然是无法被使用的,内核层需要使用内核专有API,某些应用层下的API只需要增加Zw开头即可在内核中使用,例如本章要讲解的文件与目录操作相关函数,多数ARK反内核工具都具有对文件的管理功能,实现对文件或目录的基本操作功能也是非常有必要的。

驱动开发:内核遍历文件或目录

在笔者前一篇文章`《驱动开发:内核文件读写系列函数》`简单的介绍了内核中如何对文件进行基本的读写操作,本章我们将实现内核下遍历文件或目录这一功能,该功能的实现需要依赖于`ZwQueryDirectoryFile`这个内核API函数来实现,该函数可返回给定文件句柄指定的目录中文件的各种信息,此类信息会保存在`PFILE_BOTH_DIR_INFORMATION`结构下,通过遍历该目录即可获取到文件的

驱动开发:内核解析PE结构导出表

在笔者的上一篇文章`《驱动开发:内核特征码扫描PE代码段》`中`LyShark`带大家通过封装好的`LySharkToolsUtilKernelBase`函数实现了动态获取内核模块基址,并通过`ntimage.h`头文件中提供的系列函数解析了指定内核模块的`PE节表`参数,本章将继续延申这个话题,实现对PE文件导出表的解析任务,导出表无法动态获取,解析导出表则必须读入内核模块到内存才可继续解析,所

驱动开发:内核实现SSDT挂钩与摘钩

在前面的文章`《驱动开发:内核解析PE结构导出表》`中我们封装了两个函数`KernelMapFile()`函数可用来读取内核文件,`GetAddressFromFunction()`函数可用来在导出表中寻找指定函数的导出地址,本章将以此为基础实现对特定`SSDT`函数的`Hook`挂钩操作,与`《驱动开发:内核层InlineHook挂钩函数》`所使用的挂钩技术基本一致,不同点是前者使用了`CR3`

驱动开发:内核实现进程汇编与反汇编

在笔者上一篇文章`《驱动开发:内核MDL读写进程内存》`简单介绍了如何通过MDL映射的方式实现进程读写操作,本章将通过如上案例实现远程进程反汇编功能,此类功能也是ARK工具中最常见的功能之一,通常此类功能的实现分为两部分,内核部分只负责读写字节集,应用层部分则配合反汇编引擎对字节集进行解码,此处我们将运用`capstone`引擎实现这个功能。

驱动开发:摘除InlineHook内核钩子

在笔者上一篇文章`《驱动开发:内核层InlineHook挂钩函数》`中介绍了通过替换`函数`头部代码的方式实现`Hook`挂钩,对于ARK工具来说实现扫描与摘除`InlineHook`钩子也是最基本的功能,此类功能的实现一般可在应用层进行,而驱动层只需要保留一个`读写字节`的函数即可,将复杂的流程放在应用层实现是一个非常明智的选择,与`《驱动开发:内核实现进程反汇编》`中所使用的读写驱动基本一致,

驱动开发:内核扫描SSDT挂钩状态

在笔者上一篇文章`《驱动开发:内核实现SSDT挂钩与摘钩》`中介绍了如何对`SSDT`函数进行`Hook`挂钩与摘钩的,本章将继续实现一个新功能,如何`检测SSDT`函数是否挂钩,要实现检测`挂钩状态`有两种方式,第一种方式则是类似于`《驱动开发:摘除InlineHook内核钩子》`文章中所演示的通过读取函数的前16个字节与`原始字节`做对比来判断挂钩状态,另一种方式则是通过对比函数的`当前地址`

驱动开发:内核枚举LoadImage映像回调

在笔者之前的文章`《驱动开发:内核特征码搜索函数封装》`中我们封装实现了特征码定位功能,本章将继续使用该功能,本次我们需要枚举内核`LoadImage`映像回调,在Win64环境下我们可以设置一个`LoadImage`映像加载通告回调,当有新驱动或者DLL被加载时,回调函数就会被调用从而执行我们自己的回调例程,映像回调也存储在数组里,枚举时从数组中读取值之后,需要进行位运算解密得到地址。

驱动开发:内核解析PE结构节表

在笔者上一篇文章`《驱动开发:内核解析PE结构导出表》`介绍了如何解析内存导出表结构,本章将继续延申实现解析PE结构的PE头,PE节表等数据,总体而言内核中解析PE结构与应用层没什么不同,在上一篇文章中`LyShark`封装实现了`KernelMapFile()`内存映射函数,在之后的章节中这个函数会被多次用到,为了减少代码冗余,后期文章只列出重要部分,读者可以自行去前面的文章中寻找特定的片段。

驱动开发:内核解锁与强删文件

在某些时候我们的系统中会出现一些无法被正常删除的文件,如果想要强制删除则需要在驱动层面对其进行解锁后才可删掉,而所谓的解锁其实就是释放掉文件描述符(句柄表)占用,文件解锁的核心原理是通过调用`ObSetHandleAttributes`函数将特定句柄设置为可关闭状态,然后在调用`ZwClose`将其文件关闭,强制删除则是通过`ObReferenceObjectByHandle`在对象上提供相应的权