内核文件管理-IRP 源代码

最新推荐文章于 2022-06-03 18:10:11 发布
最新推荐文章于 2022-06-03 18:10:11 发布
阅读量437 收藏 2
点赞数 2
分类专栏： 内核文件管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48995611/article/details/112386214
版权

IRP_FSD.h 头文件

#pragma once
#include <ntifs.h>

// 使用后需要调用ObRedeference函数关闭文件句柄
NTSTATUS IrpCreateFile(
	OUT PFILE_OBJECT* ppFileObject,					// 用于返回文件句柄的指针
	IN	ACCESS_MASK DesiredAccess,					// 指定访问权限
	IN	PUNICODE_STRING pustrFilePath,				// 文件路径
	OUT PIO_STATUS_BLOCK pIoStatusBlock,			// 用于返回最终完成的状态和其他请求操作的信息
	IN	PLARGE_INTEGER AllocationSize OPTIONAL,		// 包含初始分配大小的LARGE_INTEGER指针(用于文件创建或覆盖, NULL为不分配, 可选)
	IN	ULONG FileAttributes,						// 文件属性
	IN	ULONG ShareAccess,							// 共享访问类型
	IN	ULONG CreateDisposition,					// 指定在文件存在/不存在时要执行的操作
	IN	ULONG CreateOptions,						// 指定创建或打开文件时要应用的选项
	IN	PVOID EaBuffer OPTIONAL,					// 对于设备和中间驱动程序, 此参数必须是NULL指针。
	IN	ULONG EaLength);							//

NTSTATUS IrpQueryInformationFile(
	IN	PFILE_OBJECT pFileObject,						// 文件句柄
	OUT PIO_STATUS_BLOCK IoStatusBlock,					// 用于返回最终完成的状态和其他请求操作的信息
	OUT	PVOID FileInformation,							// 返回的文件信息
	IN	ULONG Length,									// FileInformation结构的长度
	IN	FILE_INFORMATION_CLASS FileInformationClass);	// FileInformatino的类型

NTSTATUS IrpSetInformationFile(
	IN	PFILE_OBJECT pFileObject,						// 文件句柄
	OUT PIO_STATUS_BLOCK IoStatusBlock,					// 用于返回最终完成的状态和其他请求操作的信息
	IN	PVOID FileInformation,							// 设置的文件信息
	IN	ULONG Length,									// FileInformation结构的长度
	IN	FILE_INFORMATION_CLASS FileInformationClass);	// FileInformatino的类型

NTSTATUS IrpReadFile(
	IN	PFILE_OBJECT pFileObject,						// 文件句柄
	OUT PIO_STATUS_BLOCK IoStatusBlock,					// 用于返回最终完成的状态和其他请求操作的信息
	OUT PVOID Buffer,									// 输出缓冲区
	IN	ULONG BufferLength,								// 缓冲区长度
	IN	PLARGE_INTEGER ByteOffset OPTIONAL);			// 读取偏移位置

NTSTATUS IrpWriteFile(
	IN	PFILE_OBJECT pFileObject,						// 文件句柄
	OUT PIO_STATUS_BLOCK IoStatusBlock,					// 用于返回最终完成的状态和其他请求操作的信息
	IN	PVOID Buffer,									// 输入缓冲区
	IN	ULONG BufferLength,								// 缓冲区长度
	IN	PLARGE_INTEGER ByteOffset OPTIONAL);			// 写入偏移位置

NTSTATUS IrpQueryDirectoryFile(
	IN	PFILE_OBJECT pFileObject,						// 文件句柄
	OUT PIO_STATUS_BLOCK IoStatusBlock,					// 用于返回最终完成的状态和其他请求操作的信息
	OUT PVOID FileInformation,							// 输出信息
	IN	ULONG Length,									// FileInformation分配的内存大小
	IN	FILE_INFORMATION_CLASS FileInformationClass,	// FileInformation类型
	IN	PUNICODE_STRING FileName OPTIONAL);				// 用作搜索(可选)

IRP_FSD.c 源文件

#include "IRP_FSD.h"

#define MAX_FILE_NAME_SIZE 512

typedef struct _AUX_ACCESS_DATA {
	PPRIVILEGE_SET PrivilegesUsed;
	GENERIC_MAPPING GenericMapping;
	ACCESS_MASK AccessesToAudit;
	ACCESS_MASK MaximumAuditMask;
	ULONG Unknown[256];
} AUX_ACCESS_DATA, * PAUX_ACCESS_DATA;

NTSTATUS ObCreateObject(
	__in KPROCESSOR_MODE ProbeMode,				// 决定是否要验证参数
	__in POBJECT_TYPE ObjectType,				// 对象类型指针
	__in POBJECT_ATTRIBUTES ObjectAttributes,	// 对象的属性, 最终会转化成ObAllocateObject需要的OBJECT_CREATE_INFORMATION结构
	__in KPROCESSOR_MODE OwnershipMode,			// 指定内核对象还是用户对象, 同上
	__inout_opt PVOID ParseContext,				// 这参数没用
	__in ULONG ObjectBodySize,					// 对象体大小
	__in ULONG PagedPoolCharge,					// ...
	__in ULONG NonPagedPoolCharge,				// ...
	__out PVOID* Object							// 接收对象体的指针
);

NTSTATUS SeCreateAccessState(
	PACCESS_STATE AccessState,
	PVOID AuxData,
	ACCESS_MASK DesiredAccess,
	PGENERIC_MAPPING GenericMapping
);


// 完成实例, 设置事件信号量, 并释放IRP
NTSTATUS CompleteRoutine(
	IN PDEVICE_OBJECT DeviceObject,
	IN PIRP pIRP,
	IN PVOID Context)
{
	*pIRP->UserIosb = pIRP->IoStatus;
	// 设置事件信号
	if (pIRP->UserEvent)
	{
		KeSetEvent(pIRP->UserEvent, IO_NO_INCREMENT, FALSE);
	}
	// 释放IRP
	IoFreeIrp(pIRP);
	pIRP = NULL;

	return STATUS_MORE_PROCESSING_REQUIRED;
}

// 创建或打开文件
NTSTATUS IrpCreateFile(
	OUT PFILE_OBJECT* ppFileObject,
	IN ACCESS_MASK DesiredAccess,
	IN PUNICODE_STRING pustrFilePath,
	OUT PIO_STATUS_BLOCK pIoStatusBlock,
	IN PLARGE_INTEGER AllocationSize OPTIONAL,
	IN ULONG FileAttributes,
	IN ULONG ShareAccess,
	IN ULONG CreateDisposition,
	IN ULONG CreateOptions,
	IN PVOID EaBuffer OPTIONAL,
	IN ULONG EaLength)
{
	NTSTATUS status = STATUS_SUCCESS;
	UNICODE_STRING ustrRootPath;
	WCHAR wszRootPath[10] = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	HANDLE hDriver;
	PFILE_OBJECT pDriverFileObject = NULL, pFileObject = NULL;
	KEVENT kEvent = { 0 };
	PDEVICE_OBJECT pDeviceObject = NULL, pRealDevice = NULL;
	PIRP pIRP = NULL;
	AUX_ACCESS_DATA auxAccessData = { 0 };
	ACCESS_STATE accessData = { 0 };
	IO_SECURITY_CONTEXT ioSecurityContext = { 0 };
	PIO_STACK_LOCATION pIoStackLocation = NULL;
	*ppFileObject = NULL;
	
	// 根据文件路径打开文件所在的驱动器，并获得驱动器句柄hDriver
	wcscpy(wszRootPath, L"\\??\\A:\\");
	wszRootPath[4] = pustrFilePath->Buffer[0];
	RtlInitUnicodeString(&ustrRootPath, wszRootPath);
	InitializeObjectAttributes(&objectAttributes, &ustrRootPath, OBJ_KERNEL_HANDLE, NULL, NULL);
	status = IoCreateFile(&hDriver, GENERIC_READ | SYNCHRONIZE, &objectAttributes,
		pIoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, 
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0, CreateFileTypeNone,
		NULL, IO_NO_PARAMETER_CHECKING);
	if (!NT_SUCCESS(status))
	{
		return status;
	}
	// 根据驱动器句柄获取驱动器中的文件对象pDriverFileObject
	status = ObReferenceObjectByHandle(hDriver, FILE_READ_ACCESS, *IoFileObjectType, KernelMode, &pDriverFileObject, NULL);
	if (!NT_SUCCESS(status))
	{
		ZwClose(hDriver);
		return status;
	}
	// 利用文件对象中的VPB获取文件系统逻辑卷对象和物理卷设备, 然后关闭驱动器句柄和文件对象
	pDeviceObject = pDriverFileObject->Vpb->DeviceObject;
	pRealDevice = pDriverFileObject->Vpb->RealDevice;
	ObDereferenceObject(pDriverFileObject);
	ZwClose(hDriver);
	// 根据物理卷设备栈大小创建IRP
	pIRP = IoAllocateIrp(pDeviceObject->StackSize, FALSE);
	if (NULL == pIRP)
	{
		return STATUS_UNSUCCESSFUL;
	}
	// 创建事件
	KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
	// 创建空文件对象pFileObject并设置
	InitializeObjectAttributes(&objectAttributes, NULL, OBJ_CASE_INSENSITIVE, NULL, NULL);
	status = ObCreateObject(KernelMode, *IoFileObjectType, &objectAttributes, KernelMode, NULL, sizeof(FILE_OBJECT), 0, 0, &pFileObject);
	if (!NT_SUCCESS(status))
	{
		IoFreeIrp(pIRP);
		return status;
	}
	RtlZeroMemory(pFileObject, sizeof(FILE_OBJECT));
	pFileObject->Type = IO_TYPE_FILE;
	pFileObject->Size = sizeof(FILE_OBJECT);
	pFileObject->DeviceObject = pRealDevice;
	pFileObject->Flags = FO_SYNCHRONOUS_IO;
	pFileObject->FileName.Buffer = (PWCHAR)ExAllocatePool(NonPagedPool, MAX_FILE_NAME_SIZE);
	if (pFileObject->FileName.Buffer == NULL)
	{
		IoFreeIrp(pIRP);
		ObDereferenceObject(pFileObject);
		return STATUS_UNSUCCESSFUL;
	}
	pFileObject->FileName.MaximumLength = MAX_FILE_NAME_SIZE;
	pFileObject->FileName.Length = pustrFilePath->Length - 4;
	RtlZeroMemory(pFileObject->FileName.Buffer, MAX_FILE_NAME_SIZE);
	RtlCopyMemory(pFileObject->FileName.Buffer, &pustrFilePath->Buffer[2], pFileObject->FileName.Length);
	KeInitializeEvent(&pFileObject->Lock, SynchronizationEvent, FALSE);
	KeInitializeEvent(&pFileObject->Event, NotificationEvent, FALSE);
	// 创建权限状态设置访问文件的权限
	RtlZeroMemory(&auxAccessData, sizeof(auxAccessData));
	status = SeCreateAccessState(&accessData, &auxAccessData, DesiredAccess, IoGetFileObjectGenericMapping());
	if (!NT_SUCCESS(status))
	{
		IoFreeIrp(pIRP);
		ObDereferenceObject(pFileObject);
		return status;
	}
	// 设置安全内容 IO_SECURITY_CONTEXT
	ioSecurityContext.SecurityQos = NULL;
	ioSecurityContext.AccessState = &accessData;
	ioSecurityContext.DesiredAccess = DesiredAccess;
	ioSecurityContext.FullCreateOptions = 0;
	// 设置IRP
	RtlZeroMemory(pIoStatusBlock, sizeof(IO_STATUS_BLOCK));
	pIRP->MdlAddress = NULL;
	pIRP->AssociatedIrp.SystemBuffer = EaBuffer;
	pIRP->Flags = IRP_CREATE_OPERATION | IRP_SYNCHRONOUS_API;
	pIRP->RequestorMode = KernelMode;
	pIRP->UserIosb = pIoStatusBlock;
	pIRP->UserEvent = &kEvent;
	pIRP->PendingReturned = FALSE;
	pIRP->Cancel = FALSE;
	pIRP->CancelRoutine = NULL;
	pIRP->Tail.Overlay.Thread = PsGetCurrentThread();
	pIRP->Tail.Overlay.AuxiliaryBuffer = NULL;
	pIRP->Tail.Overlay.OriginalFileObject = pFileObject;
	// 获取下一个IRP的IO_STACK_LOCATION并设置
	pIoStackLocation = IoGetNextIrpStackLocation(pIRP);
	pIoStackLocation->MajorFunction = IRP_MJ_CREATE;
	pIoStackLocation->DeviceObject = pDeviceObject;
	pIoStackLocation->FileObject = pFileObject;
	pIoStackLocation->Parameters.Create.SecurityContext = &ioSecurityContext;
	pIoStackLocation->Parameters.Create.Options = (CreateDisposition << 24) | CreateOptions;
	pIoStackLocation->Parameters.Create.FileAttributes = (USHORT)FileAttributes;
	pIoStackLocation->Parameters.Create.ShareAccess = (USHORT)ShareAccess;
	pIoStackLocation->Parameters.Create.EaLength = EaLength;
	// 设置完成实例, 以便通知IRP处理完成, 释放资源
	IoSetCompletionRoutine(pIRP, CompleteRoutine, NULL, TRUE, TRUE, TRUE);
	// 发送IRP
	status = IoCallDriver(pDeviceObject, pIRP);
	// 等待IRP处理完成
	if (STATUS_PENDING == status)
	{
		KeWaitForSingleObject(&kEvent, Executive, KernelMode, TRUE, NULL);
	}
	// 判断IRP处理结果
	status = pIoStatusBlock->Status;
	if (!NT_SUCCESS(status))
	{
		ObDereferenceObject(pFileObject);
		return status;
	}
	InterlockedIncrement(&pFileObject->DeviceObject->ReferenceCount);
	if (pFileObject->Vpb)
	{
		InterlockedIncrement(&pFileObject->Vpb->ReferenceCount);
	}
	// 返回文件对象
	*ppFileObject = pFileObject;
	
	return status;
}

// 获取文件的信息
NTSTATUS IrpQueryInformationFile(
	IN	PFILE_OBJECT pFileObject,
	OUT PIO_STATUS_BLOCK IoStatusBlock,
	OUT	PVOID FileInformation,
	IN	ULONG Length,
	IN	FILE_INFORMATION_CLASS FileInformationClass)
{
	NTSTATUS status = STATUS_SUCCESS;
	PDEVICE_OBJECT pDevObj = NULL;
	PIRP pIRP = NULL;
	KEVENT kEvent = { 0 };
	PIO_STACK_LOCATION pIoStackLocation = NULL;

	// 判断参数, 并获得设备对象
	if (NULL == pFileObject)
	{
		return STATUS_UNSUCCESSFUL;
	}
	if (NULL == pFileObject->Vpb)
	{
		return STATUS_UNSUCCESSFUL;
	}
	pDevObj = pFileObject->Vpb->DeviceObject;
	if (NULL == pDevObj)
	{
		return STATUS_UNSUCCESSFUL;
	}
	// 创建IRP和等待IRP处理完成的事件
	pIRP = IoAllocateIrp(pDevObj->StackSize, FALSE);
	if (NULL == pIRP)
	{
		return STATUS_UNSUCCESSFUL;
	}
	KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
	// 设置IRP
	RtlZeroMemory(FileInformation, Length);
	pIRP->UserEvent = &kEvent;
	pIRP->UserIosb = IoStatusBlock;
	pIRP->AssociatedIrp.SystemBuffer = FileInformation;
	pIRP->RequestorMode = KernelMode;
	pIRP->Tail.Overlay.Thread = PsGetCurrentThread();
	pIRP->Tail.Overlay.OriginalFileObject = pFileObject;
	// 获取下一个IRP的IO_STACK_LOCATION并设置
	pIoStackLocation = IoGetNextIrpStackLocation(pIRP);
	pIoStackLocation->MajorFunction = IRP_MJ_QUERY_INFORMATION;
	pIoStackLocation->DeviceObject = pDevObj;
	pIoStackLocation->FileObject = pFileObject;
	pIoStackLocation->Parameters.QueryFile.Length = Length;
	pIoStackLocation->Parameters.QueryFile.FileInformationClass = FileInformationClass;
	// 设置完成实例, 以便通知IRP处理完成, 释放资源
	IoSetCompletionRoutine(pIRP, CompleteRoutine, NULL, TRUE, TRUE, TRUE);
	// 发送IRP
	status = IoCallDriver(pDevObj, pIRP);
	// 等待IRP处理完成
	if (STATUS_PENDING == status)
	{
		KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL);
	}
	// 返回结果
	return IoStatusBlock->Status;
}

// 设置文件信息
NTSTATUS IrpSetInformationFile(
	IN	PFILE_OBJECT pFileObject,
	OUT PIO_STATUS_BLOCK IoStatusBlock,
	IN	PVOID FileInformation,
	IN	ULONG Length,
	IN	FILE_INFORMATION_CLASS FileInformationClass
)
{
	NTSTATUS status = STATUS_SUCCESS;
	PDEVICE_OBJECT pDevObj = NULL;
	PIRP pIRP = NULL;
	KEVENT kEvent = { 0 };
	PIO_STACK_LOCATION pIoStackLocation = NULL;

	// 判断参数, 并获得设备对象
	if (NULL == pFileObject)
	{
		return STATUS_UNSUCCESSFUL;
	}
	if (NULL == pFileObject->Vpb)
	{
		return STATUS_UNSUCCESSFUL;
	}
	pDevObj = pFileObject->Vpb->DeviceObject;
	if (NULL == pDevObj)
	{
		return STATUS_UNSUCCESSFUL;
	}
	// 创建IRP和等待IRP处理完成的事件
	pIRP = IoAllocateIrp(pDevObj->StackSize, FALSE);
	if (NULL == pIRP)
	{
		return STATUS_UNSUCCESSFUL;
	}
	KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
	// 设置IRP
	pIRP->UserEvent = &kEvent;
	pIRP->UserIosb = IoStatusBlock;
	pIRP->AssociatedIrp.SystemBuffer = FileInformation;
	pIRP->RequestorMode = KernelMode;
	pIRP->Tail.Overlay.Thread = PsGetCurrentThread();
	pIRP->Tail.Overlay.OriginalFileObject = pFileObject;
	// 获取下一个IRP的IO_STACK_LOCATION并设置
	pIoStackLocation = IoGetNextIrpStackLocation(pIRP);
	pIoStackLocation->MajorFunction = IRP_MJ_SET_INFORMATION;
	pIoStackLocation->DeviceObject = pDevObj;
	pIoStackLocation->FileObject = pFileObject;
	pIoStackLocation->Parameters.SetFile.Length = Length;
	pIoStackLocation->Parameters.SetFile.FileInformationClass = FileInformationClass;
	// 设置完成实例, 以便通知IRP处理完成, 释放资源
	IoSetCompletionRoutine(pIRP, CompleteRoutine, NULL, TRUE, TRUE, TRUE);
	// 发送IRP
	status = IoCallDriver(pDevObj, pIRP);
	// 等待IRP的处理
	if (STATUS_PENDING == status)
	{
		KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL);
	}
	// 返回结果
	return IoStatusBlock->Status;
}

// 读取文件
NTSTATUS IrpReadFile(
	IN	PFILE_OBJECT pFileObject,
	OUT PIO_STATUS_BLOCK IoStatusBlock,
	OUT PVOID Buffer,
	IN	ULONG BufferLength,
	IN	PLARGE_INTEGER ByteOffset OPTIONAL)
{
	NTSTATUS status = STATUS_SUCCESS;
	PDEVICE_OBJECT pDevObj = NULL;
	PIRP pIRP = NULL;
	KEVENT kEvent = { 0 };
	PIO_STACK_LOCATION pIoStackLocation = NULL;

	// 判断参数, 并获得设备对象
	if (NULL == pFileObject)
	{
		return STATUS_UNSUCCESSFUL;
	}
	if (NULL == pFileObject->Vpb)
	{
		return STATUS_UNSUCCESSFUL;
	}
	pDevObj = pFileObject->Vpb->DeviceObject;
	if (NULL == pDevObj)
	{
		return STATUS_UNSUCCESSFUL;
	}
	// 调整参数
	if (NULL == ByteOffset)
	{
		if (0 == (FO_SYNCHRONOUS_IO & pFileObject->Flags))
		{
			return STATUS_INVALID_PARAMETER;
		}
		ByteOffset = &pFileObject->CurrentByteOffset;
	}
	// 创建IRP和等待IRP处理完成的事件
	pIRP = IoAllocateIrp(pDevObj->StackSize, FALSE);
	if (NULL == pIRP)
	{
		return STATUS_UNSUCCESSFUL;
	}
	KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
	// 设置IRP
	RtlZeroMemory(Buffer, BufferLength);
	pIRP->MdlAddress = MmCreateMdl(NULL, Buffer, BufferLength);	// 通过MDL修改内存
	if (NULL == pIRP->MdlAddress)
	{
		IoFreeIrp(pIRP);
		return STATUS_INSUFFICIENT_RESOURCES;
	}
	MmBuildMdlForNonPagedPool(pIRP->MdlAddress);
	pIRP->UserEvent = &kEvent;
	pIRP->UserIosb = IoStatusBlock;
	pIRP->Flags = IRP_READ_OPERATION;
	pIRP->RequestorMode = KernelMode;
	pIRP->Tail.Overlay.Thread = PsGetCurrentThread();
	pIRP->Tail.Overlay.OriginalFileObject = pFileObject;
	// 获取下一个IRP的IO_STACK_LOCATION并设置
	pIoStackLocation = IoGetNextIrpStackLocation(pIRP);
	pIoStackLocation->MajorFunction = IRP_MJ_READ;
	pIoStackLocation->MinorFunction = IRP_MN_NORMAL;
	pIoStackLocation->DeviceObject = pDevObj;
	pIoStackLocation->FileObject = pFileObject;
	pIoStackLocation->Parameters.Read.Length = BufferLength;
	pIoStackLocation->Parameters.Read.ByteOffset = *ByteOffset;
	// 设置完成实例, 以便通知IRP处理完成, 释放资源
	IoSetCompletionRoutine(pIRP, CompleteRoutine, NULL, TRUE, TRUE, TRUE);
	// 发送IRP
	status = IoCallDriver(pDevObj, pIRP);
	// 等待IRP的处理
	if (STATUS_PENDING == status)
	{
		KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL);
	}
	// 返回结果
	return IoStatusBlock->Status;
}

// 写入文件
NTSTATUS IrpWriteFile(
	IN	PFILE_OBJECT pFileObject,
	OUT PIO_STATUS_BLOCK IoStatusBlock,
	IN	PVOID Buffer,
	IN	ULONG BufferLength,
	IN	PLARGE_INTEGER ByteOffset OPTIONAL)
{
	NTSTATUS status = STATUS_SUCCESS;
	PDEVICE_OBJECT pDevObj = NULL;
	PIRP pIRP = NULL;
	KEVENT kEvent = { 0 };
	PIO_STACK_LOCATION pIoStackLocation = NULL;

	// 判断参数, 并获得设备对象
	if (NULL == pFileObject)
	{
		return STATUS_UNSUCCESSFUL;
	}
	if (NULL == pFileObject->Vpb)
	{
		return STATUS_UNSUCCESSFUL;
	}
	pDevObj = pFileObject->Vpb->DeviceObject;
	if (NULL == pDevObj)
	{
		return STATUS_UNSUCCESSFUL;
	}
	// 调整参数
	if (NULL == ByteOffset)
	{
		if (0 == (FO_SYNCHRONOUS_IO & pFileObject->Flags))
		{
			return STATUS_INVALID_PARAMETER;
		}
		ByteOffset = &pFileObject->CurrentByteOffset;
	}
	// 创建IRP和等待IRP处理完成的事件
	pIRP = IoAllocateIrp(pDevObj->StackSize, FALSE);
	if (NULL == pIRP)
	{
		return STATUS_UNSUCCESSFUL;
	}
	KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
	// 设置IRP
	pIRP->MdlAddress = MmCreateMdl(NULL, Buffer, BufferLength);
	if (NULL == pIRP->MdlAddress)
	{
		IoFreeIrp(pIRP);
		return STATUS_INSUFFICIENT_RESOURCES;
	}
	MmBuildMdlForNonPagedPool(pIRP->MdlAddress);
	pIRP->UserEvent = &kEvent;
	pIRP->UserIosb = IoStatusBlock;
	pIRP->Flags = IRP_WRITE_OPERATION;
	pIRP->RequestorMode = KernelMode;
	pIRP->Tail.Overlay.Thread = PsGetCurrentThread();
	pIRP->Tail.Overlay.OriginalFileObject = pFileObject;
	// 获取下一个IRP的IO_STACK_LOCATION并设置
	pIoStackLocation = IoGetNextIrpStackLocation(pIRP);
	pIoStackLocation->MajorFunction = IRP_MJ_WRITE;
	pIoStackLocation->MinorFunction = IRP_MN_NORMAL;
	pIoStackLocation->DeviceObject = pDevObj;
	pIoStackLocation->FileObject = pFileObject;
	pIoStackLocation->Parameters.Write.Length = BufferLength;
	pIoStackLocation->Parameters.Write.ByteOffset = *ByteOffset;
	// 设置完成实例, 以便通知IRP处理完成, 释放资源
	IoSetCompletionRoutine(pIRP, CompleteRoutine, NULL, TRUE, TRUE, TRUE);
	// 发送IRP
	status = IoCallDriver(pDevObj, pIRP);
	// 等待IRP的处理
	if (STATUS_PENDING == status)
	{
		KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL);
	}
	// 返回结果
	return IoStatusBlock->Status;
}

// 文件遍历
NTSTATUS IrpQueryDirectoryFile(
	IN	PFILE_OBJECT pFileObject,
	OUT PIO_STATUS_BLOCK IoStatusBlock,
	OUT PVOID FileInformation,
	IN	ULONG Length,
	IN	FILE_INFORMATION_CLASS FileInformationClass,
	IN	PUNICODE_STRING FileName OPTIONAL)
{
	NTSTATUS status = STATUS_SUCCESS;
	PIRP pIRP = NULL;
	KEVENT kEvent = { 0 };
	PIO_STACK_LOCATION pIoStackLocation = NULL;
	PDEVICE_OBJECT pDevObj = NULL;

	// 判断参数, 并获得设备对象
	if (NULL == pFileObject)
	{
		return STATUS_UNSUCCESSFUL;
	}
	if (NULL == pFileObject->Vpb)
	{
		return STATUS_UNSUCCESSFUL;
	}
	pDevObj = pFileObject->Vpb->DeviceObject;
	if (NULL == pDevObj)
	{
		return STATUS_UNSUCCESSFUL;
	}
	// 创建IRP和等待IRP处理完成的事件
	pIRP = IoAllocateIrp(pDevObj->StackSize, FALSE);
	if (NULL == pIRP)
	{
		return STATUS_UNSUCCESSFUL;
	}
	KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
	// 设置IRP
	RtlZeroMemory(FileInformation, Length);
	pIRP->UserEvent = &kEvent;
	pIRP->UserIosb = IoStatusBlock;
	pIRP->UserBuffer = FileInformation;
	pIRP->Tail.Overlay.Thread = PsGetCurrentThread();
	pIRP->Tail.Overlay.OriginalFileObject = pFileObject;
	pIRP->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
	// 获取下一个IRP的IO_STACK_LOCATION并设置
	pIoStackLocation = IoGetNextIrpStackLocation(pIRP);
	pIoStackLocation->MajorFunction = IRP_MJ_DIRECTORY_CONTROL;
	pIoStackLocation->MinorFunction = IRP_MN_QUERY_DIRECTORY;
	pIoStackLocation->FileObject = pFileObject;
	pIoStackLocation->Flags = SL_RESTART_SCAN;
	pIoStackLocation->Parameters.QueryDirectory.Length = Length;
	pIoStackLocation->Parameters.QueryDirectory.FileName = FileName;
	pIoStackLocation->Parameters.QueryDirectory.FileInformationClass = FileInformationClass;
	// 设置完成实例, 以便通知IRP处理完成, 释放资源
	IoSetCompletionRoutine(pIRP, CompleteRoutine, NULL, TRUE, TRUE, TRUE);
	// 发送IRP
	status = IoCallDriver(pDevObj, pIRP);
	// 等待IRP的处理
	if (STATUS_PENDING == status)
	{
		KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL);
	}
	// 返回结果
	return IoStatusBlock->Status;
}
江小辉9914
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内核-从IRP说起
m0_74282605的博客
02-10 301
每次调用 IoCopyCurrentStackLocationToNext()函数，就将本层的IRP stack 放当下层的IRP stack顶端，当IoCompleteRequest函数被调用也就是IRP包被处理完成之后，IRP stack 会一层层堆栈向上弹出，如果遇到IO_STACK_LOCATION的CompletionRoutine非空，则调用这个函数，另外传进这个完成例程的 是IO_STACK_LOCATION的子域Context。对于不会处理的IRP包需要提供一个默认的分 发函数来处理。
中文代码内核文件－－－时间管理
chiwei2926的博客
11-11 106
//版权声明： // 本代码为开源代码，作者拥有代码版权，但你可以在任何非商业用途程序中引用，但请标注出处，你 // 也可以对代码进行更改。作者对代码中所包括的错误以及所造成的一切后果将不负任何责任。如果你发 // 现代码中有任何问题或错误，请与我联系。 // 联系方法：QQ 23670...
内核文件管理-IRP(一)创建或打开文件
m0_48995611的博客
01-09 966
内核下通过直接向 FSD (File System Driver) 发送 IRP (I/O Request Packet)来管理文件，可以绕过一些 API Hook。 本文讲怎样通过向 FSD 发送 IRP_MJ_CREATE 消息的 IRP 来创建或打开文件(或目录)。 头文件及其他声明或定义 #include <ntifs.h> typedef struct _AUX_ACCESS_DATA { PPRIVILEGE_SET PrivilegesUsed; GENERIC_MAPPIN
内核学习笔记之IRP
nishuodeqianshou的专栏
10-17 901
文章作者：grayfox 作者主页：http://nokyo.blogbus.com 原始出处：http://www.blogbus.com/nokyo-logs/34005738.html       此前我们可能曾经多次听说过IRP这个名词，那么它究竟是什么呢？       IRP的全名是I/O Request Package，即输入输出请求包，它是Windows内核中的一种非常重要的
IRP操作文件填坑日记
zz_strive_2012的专栏
12-12 486
背景: 近段时间一个项目需要IRP操作文件.于是.搜索硬盘.把好几年前的代码找出来.说起这个代码,需要感谢黑月教主(achillis)和炉子.当时炉子开源了PsVoid. 里面就有Irp操作文件.但是抄了之后.win7蓝屏.当时水平太菜.只好在Q上麻烦教主帮忙.教主帮忙分析一番之后.于是网上就有了.那个经典的ULONG UnKnow[41]. 然后各个博客转载…当然了.当时我自己也先存了一份.不过...
Windows内核设计思想 光盘源代码
05-13
光盘源代码则提供了实践学习的宝贵素材，让读者能够直观地理解并研究Windows内核的实际实现。以下是关于Windows内核的一些关键知识点： 1. **微内核架构**：Windows NT系列操作系统采用的是混合微内核架构，这意味...
Windows-Dirver-SourceCode:Windows内核安全与驱动开发源代码
03-24
这个压缩包“Windows-Dirver-SourceCode”很可能包含了一些用于教学或研究目的的Windows驱动程序源代码，帮助开发者理解驱动开发原理以及如何确保内核的安全性。 在Windows内核驱动开发中，主要涉及以下几个知识点...
Windows 内核情景分析--采用开源代码ReactOS (上册) part01
03-28
全书从“内存管理”、“进程”、“进程间通信”、“设备驱动”等多个方面进行分析介绍，所有的分析都有ReactOS的源代码（以及部分由微软公开的源代码）作为依据，使读者能深入理解Windows内核的方方面面，也可以使...
Windows 内核情景分析--采用开源代码ReactOS
11-20
通过对ReactOS源代码的分析，我们可以深入了解Windows内核在不同场景下的工作方式，如进程调度、内存分配、设备管理等。这些情景分析可以帮助开发者解决实际问题，如性能优化、系统崩溃分析等。 六、实际应用 掌握...
寒江独钓-Windows内核安全编程 光盘源代码 谭文
05-15
通过《寒江独钓-Windows内核安全编程》这本书，读者不仅可以学习到这些核心概念和技术，还能通过光盘中的源代码实例进行实践操作，加深对理论知识的理解，提高实际编程能力。这本书对于想要从事系统级编程、驱动开发...
Linux系统内核文件Cache管理机制
03-04
自从诞生以来，Linux 就被不断完善和普及，目前它已经成为主流通用操作系统之一，使用得非常广泛，它与 Windows、UNIX 一起占据了操作系统领域几乎所有的市场份额。特别是在高性能计算领域，Linux 已经成为一个占主导地位的操作系统，在2005年6月全球TOP500 计算机中，有 301 台部署的是 Linux 操作系统。因此，研究和使用 Linux 已经成为开发者的不可回避的问题了。本文介绍一下 Linux 内核中文件 Cache 管理的机制。以 2.6 系列内核为基准，主要讲述工作原理、数据结构和算法，不涉及具体代码。
内核开发irp详解运行机制详解[学习]
SunShine的专栏
07-19 3168
I/O Request Packet （IRP）,设备栈,IO_STACK_LOCATION,IoCompletion函数
对象创建(ObCreateObject)和对象删除(ObDereferenceObject、ObpRemoveObjectRoutine)
qq492927689的博客
06-03 707
转载来源：https://blog.csdn.net/wzsy/article/details/6188554为对象分配内存看完了, 这次我们看一个比较高层的函数。 ObCreateObject, 这是内核的导出函数, 所有模块都可以使用(虽然它没有被文档化…) 它的作用是创建指定类型(OBJECT_TYPE)的对象示例。(注意ObAllocateObject只是分配了空间, 这里可以看到后续的操作) 这个函数的参数还真多啊。微软函数的参数一直都和火车一样。我们只能淡定。。。 NTSTATUS ObCrea
文件过滤驱动操作请求、结果
blackbean的专栏
08-05 855
IRP_MJ_CREATE：消息会在新建和打开的请求中产生。             设置完成函数,等待本次新建结束以后才能够判断是新建还是打开。            //操作的请求，保存在(currentIrpStack->Parameters.Create.Options >> 24)&0xFF。             即 currentIrpStack->Parameter
通过文件句柄取得到文件名(三)
Coder in Tokyo
03-25 5291
从文件句柄获得文件名方法(三)， 这次是用wdk函数ZwQueryInformationFile()，和GetVolumeInformation()。通过判断取得的dwVolumeSerialNumber来确定盘符。其他的内核函数比如说ObDereferenceObject()也可以。参考了Adlys blog 的 通过文件句柄得到文件所在路径的一种新方法 —— 得到完整路径名
文件操作---学mengwuji驱动编程笔记
zhuhuibeishadiao
04-02 1129
第六课  读写磁盘文件 相关内核API ZwCreateFile 是一个打开文件,这个AIP既可以创建一个,也可以打开文件,他具备创建和打开两种功能,共11个参数 NTSTATUS ZwCreateFile(//有11个参数   _Out_     PHANDLE FileHandle,//1.handle类型的指针,提供这个函数的,让这个函数输入一个句柄给我们,这个
less加管道tail_Linux之cat tail less常见用法
weixin_39957934的博客
12-21 195
1.cat通常查找出错误日志 cat error.log | grep 'foo' , 这时候我们还有个需求就是输出当前这个日志的前后几行：cat error.log | grep -C 10 'foo' #显示file文件里匹配foo字串那行以及上下10行cat error.log | grep -B 10 'foo' #显示foo及前10行cat error.log | grep -A 10 ...
发送请求_内核层自己发送IRP请求操作文件全面总结
weixin_35927281的博客
12-28 649
本文为看雪论精华文章看雪论坛作者ID：低调putchar 一、概述Windows操作系统中，文件系统过滤驱动的过滤设备绑定在文件系统(FSD)设备之上，监视和过滤我们的文件访问。当应用层发起文件操作调用时内核层都会转换为IRP发送到设备栈中位于栈顶的设备，然后通过IO栈单元(IO_STACK_LOCATION)保存一些参数把IRP请求继续向下层设备发送，最后至FSD，由FSD完成实际的文...
Windows XP驱动程序：IRP创建与处理详解
- WDM驱动程序（Windows Driver Model）：遵循电源管理和源代码兼容性，分为类驱动程序（管理特定设备类别）和小驱动程序（提供厂商定制的接口）。 - 显示驱动程序：运行在内核模式，负责图形显示和打印。 - 文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值