驱动开发：驱动与应用的通信

微软技术分享

已于 2023-10-31 15:24:49 修改

阅读量5.7k

点赞数 1

分类专栏：《Windows 内核安全编程技术实践》文章标签：驱动开发 Windows汇编信息安全汇编

于 2019-09-23 09:05:00 首次发布

本文链接：https://blog.csdn.net/lyshark_csdn/article/details/124939323

版权

《Windows 内核安全编程技术实践》专栏收录该内容

97 篇文章 166 订阅

订阅专栏

驱动程序与应用程序的通信离不开派遣函数，派遣函数是Windows驱动编程中的重要概念，一般情况下驱动程序负责处理I/O特权请求，而大部分IO的处理请求是在派遣函数中处理的，当用户请求数据时，操作系统会提前处理好请求，并将其派遣到指定的内核函数中执行，接下来将详细说明派遣函数的使用并通过派遣函数读取Shadow SSDT中的内容。

先来简单介绍一下 IRP(I/O Request Package) 输入输出请求包，该请求包在Windows内核中是一个非常重要的数据结构，当我们的上层应用与底层的驱动程序通信时，应用程序就会发出I/O请求，操作系统将该请求转化为相应的IRP数据，然后会根据不同的请求数据将请求派遣到相应的驱动函数中执行，这一点有点类似于Windows的消息机制。

创建设备对象

在使用派遣函数的之前需要创建设备对象，因为后期的读写都要通过设备对象来连接。

#include <ntddk.h>

VOID UnDriver(PDRIVER_OBJECT pDriver)
{
	PDEVICE_OBJECT pDev;         // 用来取得要删除设备对象
	UNICODE_STRING SymLinkName;  // 局部变量symLinkName

	//删掉所有设备
	pDev = pDriver->DeviceObject;
	IoDeleteDevice(pDev);                                       // 调用IoDeleteDevice用于删除设备
	RtlInitUnicodeString(&SymLinkName, L"\\??\\My_Driver");  	// 初始化字符串将symLinkName定义成需要删除的符号链接名称
	IoDeleteSymbolicLink(&SymLinkName);	                        // 调用IoDeleteSymbolicLink删除符号链接
	DbgPrint("删除设备与符号链接成功...");
}

NTSTATUS CreateDriverObject(IN PDRIVER_OBJECT pDriver)
{
	NTSTATUS Status;               // 接收驱动程序的返回状态
	PDEVICE_OBJECT pDevObj;        // 用于返回创建设备
	UNICODE_STRING DriverName;     // 用于存放设备的名称
	UNICODE_STRING SymLinkName;    // 用于存放符号链接名称

	RtlInitUnicodeString(&DriverName, L"\\Device\\My_Device");  // 将DrvierName填充为\\Device\\My_Device

	// 使用命令IoCreateDevice用来创建设备，并将创建后的状态保存在status
	Status = IoCreateDevice(pDriver, 0, &DriverName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
	DbgPrint("当前命令IoCreateDevice状态: %d", Status);
	if (!NT_SUCCESS(Status))
	{
		// 调用IoCreateDevice成功与失败都会返回参数,将返回参数给Status用于判断
		// STATUS_INSUFFICIENT_RESOURCES   资源不足
		// STATUS_OBJECT_NAME_EXISTS       指定对象名存在
		// STATUS_OBJECT_NAME_COLLISION    对象名有冲突
		if (Status == STATUS_OBJECT_NAME_COLLISION)
		{
			DbgPrint("对象名冲突..");
		}
		DbgPrint("创建失败.");
	}

	pDevObj->Flags |= DO_BUFFERED_IO;                            // flags 标识有没有do_buffered_io位标识
	RtlInitUnicodeString(&SymLinkName, L"\\??\\My_Device");      // 对symLinkName初始化字串为 "\\??\\My_Device"
	// 创建设备链接,驱动程序虽然有设备名称,但是这种设备名只能在内核态可见
	// 而对于应用程序是不可见的,因此驱动需要要暴露一个符号链接,该链接指向真正的设备名称
	Status = IoCreateSymbolicLink(&SymLinkName, &DriverName);    // 调用命令IoCreateSymbolicLink用于创建符号链接
	DbgPrint("当前命令IoCreateSymbolicLink状态: %d", Status);
	if (!NT_SUCCESS(Status)) // 如果status不等于0 就执行
	{
		IoDeleteDevice(pDevObj);  // 调用命令IoDeleteDevice删除当前pDevObj设备
		DbgPrint("删除设备成功...");
		return Status;
	}
	else
	{
		DbgPrint("创建符号链接成功...");
	}
	return STATUS_SUCCESS;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING RegistryPath)
{
	CreateDriverObject(pDriver);
	pDriver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

简单的驱动通信

注册两个派遣函数，当设备创建的时候触发，以及关闭时触发。

#include <ntddk.h>

VOID UnDriver(PDRIVER_OBJECT pDriver)
{
	PDEVICE_OBJECT pDev;         // 用来取得要删除设备对象
	UNICODE_STRING SymLinkName;  // 局部变量symLinkName

	pDev = pDriver->DeviceObject;
	IoDeleteDevice(pDev);                                       // 调用IoDeleteDevice用于删除设备
	RtlInitUnicodeString(&SymLinkName, L"\\??\\My_Driver");  	// 初始化字符串将symLinkName定义成需要删除的符号链接名称
	IoDeleteSymbolicLink(&SymLinkName);	                        // 调用IoDeleteSymbolicLink删除符号链接
	DbgPrint("删除设备与符号链接成功...");
}

NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	pIrp->IoStatus.Status = STATUS_SUCCESS;          // 返回成功
	DbgPrint("派遣函数 IRP_MJ_CREATE 成功执行 !\n");
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);        // 指示完成此IRP
	return STATUS_SUCCESS;                           // 返回成功
}

NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	pIrp->IoStatus.Status = STATUS_SUCCESS;          // 返回成功
	DbgPrint("派遣函数 IRP_MJ_CLOSE 成功执行 !\n");
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);        // 指示完成此IRP
	return STATUS_SUCCESS;                           // 返回成功

}

NTSTATUS CreateDriverObject(IN PDRIVER_OBJECT pDriver)
{
	NTSTATUS Status;
	PDEVICE_OBJECT pDevObj;
	UNICODE_STRING DriverName;
	UNICODE_STRING SymLinkName;

	RtlInitUnicodeString(&DriverName, L"\\Device\\My_Device");
	Status = IoCreateDevice(pDriver, 0, &DriverName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
	DbgPrint("命令 IoCreateDevice 状态: %d", Status);

	// DO_BUFFERED_IO 设置读写方式 Flags的三个不同的值分别为：DO_BUFFERED_IO、DO_DIRECT_IO和0
	pDevObj->Flags |= DO_BUFFERED_IO;
	RtlInitUnicodeString(&SymLinkName, L"\\??\\My_Device");
	Status = IoCreateSymbolicLink(&SymLinkName, &DriverName);
	DbgPrint("当前命令IoCreateSymbolicLink状态: %d", Status);
	return STATUS_SUCCESS;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING RegistryPath)
{
	CreateDriverObject(pDriver);           // 调用创建设备子过程
	// 注册两个派遣函数,分别对应创建与关闭,派遣函数名可自定义
	pDriver->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;    // 创建成功派遣函数
	pDriver->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;      // 关闭派遣函数

	DbgPrint("驱动加载完成...");
	pDriver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

客户端代码

#include <windows.h>
#include <stdio.h>
#include <winioctl.h>

int main()
{
	HANDLE hDevice = CreateFile(L"\\\\.\\My_Device", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hDevice == INVALID_HANDLE_VALUE) //判断hDevice返回值是否为空
	{
		printf("获取驱动句柄失败!错误: %d\n", GetLastError());
		getchar();
	}

	getchar();
	CloseHandle(hDevice);
	return 0;
}

读取驱动中的数据

实现读取内核缓冲区中的数据，并打印出来。

#include <ntddk.h>

VOID UnDriver(PDRIVER_OBJECT pDriver)
{
	PDEVICE_OBJECT pDev;         // 用来取得要删除设备对象
	UNICODE_STRING SymLinkName;  // 局部变量symLinkName
	pDev = pDriver->DeviceObject;
	IoDeleteDevice(pDev);                                       // 调用IoDeleteDevice用于删除设备
	RtlInitUnicodeString(&SymLinkName, L"\\??\\My_Driver");     // 初始化字符串将symLinkName定义成需要删除的符号链接名称
	IoDeleteSymbolicLink(&SymLinkName);                         // 调用IoDeleteSymbolicLink删除符号链接
	DbgPrint("删除设备与符号链接成功...");
}
NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	pIrp->IoStatus.Status = STATUS_SUCCESS;          // 返回成功
	DbgPrint("派遣函数 IRP_MJ_CREATE 成功执行 !\n");
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);        // 指示完成此IRP
	return STATUS_SUCCESS;                           // 返回成功
}
NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	pIrp->IoStatus.Status = STATUS_SUCCESS;          // 返回成功
	DbgPrint("派遣函数 IRP_MJ_CLOSE 成功执行 !\n");
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);        // 指示完成此IRP
	return STATUS_SUCCESS;                           // 返回成功
}

NTSTATUS DispatchRead(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(pIrp);
	ULONG ulReadLength = Stack->Parameters.Read.Length;
	pIrp->IoStatus.Status = Status;
	pIrp->IoStatus.Information = ulReadLength;
	DbgPrint("应用要读取的长度：%d\n", ulReadLength);

	// 将内核中的缓冲区全部填充为0x68 方便演示读取的效果
	memset(pIrp->AssociatedIrp.SystemBuffer, 0x68, ulReadLength);
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	return Status;
}

NTSTATUS CreateDriverObject(IN PDRIVER_OBJECT pDriver)
{
	NTSTATUS Status;
	PDEVICE_OBJECT pDevObj;
	UNICODE_STRING DriverName;
	UNICODE_STRING SymLinkName;

	RtlInitUnicodeString(&DriverName, L"\\Device\\My_Device");
	Status = IoCreateDevice(pDriver, 0, &DriverName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
	DbgPrint("命令 IoCreateDevice 状态: %d", Status);
	pDevObj->Flags |= DO_BUFFERED_IO;
	RtlInitUnicodeString(&SymLinkName, L"\\??\\My_Device");
	Status = IoCreateSymbolicLink(&SymLinkName, &DriverName);
	DbgPrint("当前命令IoCreateSymbolicLink状态: %d", Status);
	return STATUS_SUCCESS;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING RegistryPath)
{
	CreateDriverObject(pDriver);                               // 调用创建设备
	pDriver->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;    // 创建成功派遣函数
	pDriver->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;      // 关闭派遣函数
	pDriver->MajorFunction[IRP_MJ_READ] = DispatchRead;

	DbgPrint("驱动加载完成...");
	pDriver->DriverUnload = UnDriver;
	return STATUS_SUCCESS;
}

客户端代码

#include <windows.h>
#include <stdio.h>
#include <winioctl.h>

int main()
{
	HANDLE hDevice = CreateFile(L"\\\\.\\My_Device", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("获取驱动句柄失败: %d\n", GetLastError());
		getchar();
	}

	UCHAR buffer[10];
	ULONG ulRead;

	ReadFile(hDevice, buffer, 10, &ulRead, 0);
	for (int i = 0; i < (int)ulRead; i++)
	{
		printf("%02X", buffer[i]);
	}
	getchar();
	CloseHandle(hDevice);
	return 0;
}

向驱动派发命令

向驱动程序中发送一个结构，驱动程序内部通过DbgPrint打印出来。

#include <ntddk.h>
#define My_Code CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)

typedef struct Hread {
	ULONG Flage;
	ULONG Addr;
	ULONG WriteBufferAddr;
	ULONG Size;
	ULONG Pid;
}_Hread, *PtrHread;

typedef struct _DEVICE_EXTENSION {
	UNICODE_STRING SymLinkName;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
{
	PDEVICE_OBJECT pDevObj;
	pDevObj = pDriverObject->DeviceObject;
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	UNICODE_STRING pLinkName = pDevExt->SymLinkName;
	IoDeleteSymbolicLink(&pLinkName);
	IoDeleteDevice(pDevObj);
}
NTSTATUS DefDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	NTSTATUS status = STATUS_SUCCESS;
	pIrp->IoStatus.Status = status;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	return status;
}

NTSTATUS IoctlDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	NTSTATUS Status = STATUS_UNSUCCESSFUL;
	ULONG_PTR Informaiton = 0;
	PVOID InputData = NULL;
	ULONG InputDataLength = 0;
	PVOID OutputData = NULL;
	ULONG OutputDataLength = 0;
	PIO_STACK_LOCATION  IoStackLocation = IoGetCurrentIrpStackLocation(pIrp);              // Irp堆栈  
	InputData = pIrp->AssociatedIrp.SystemBuffer;
	OutputData = pIrp->AssociatedIrp.SystemBuffer;
	InputDataLength = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;      // 输入数据大小
	OutputDataLength = IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength;    // 输出数据大小
	ULONG Code = IoStackLocation->Parameters.DeviceIoControl.IoControlCode;

	switch (Code)
	{
	case My_Code:
		PtrHread PtrBuff = (PtrHread)InputData;
		ULONG RetFlage = PtrBuff->Flage;
		ULONG RetAddr = PtrBuff->Addr;
		ULONG RetBufferAddr = PtrBuff->WriteBufferAddr;
		ULONG Size = PtrBuff->Size;
		ULONG Pid = PtrBuff->Pid;

		DbgPrint("读取文件标志：%d", RetFlage);
		DbgPrint("读取写入地址：%x", RetAddr);
		DbgPrint("读取缓冲区大小：%d", RetBufferAddr);
		DbgPrint("读取当前大小：%d", Size);
		DbgPrint("要操作进程PID: %d", Pid);

		// 通过内存返回数据.
		char *retBuffer = "hello lyshark";
		memcpy(OutputData, retBuffer , strlen(retBuffer));
		Informaiton = strlen(retBuffer) + 1;
		Status = STATUS_SUCCESS;

		// 通过内存返回数据,另一种通信方式.
		PVOID addr = (PVOID)"ok";
		RtlCopyMemory(OutputData, addr, 4);
		Informaiton = 4;
		Status = STATUS_SUCCESS;
		break;
	}

	pIrp->IoStatus.Status = Status;                   // 设置IRP完成状态，会设置用户模式下的GetLastError
	pIrp->IoStatus.Information = Informaiton;    // 设置操作的字节
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);         // 完成IRP，不增加优先级
	return Status;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath)
{
	pDriverObject->DriverUnload = DriverUnload;//注册驱动卸载函数
	pDriverObject->MajorFunction[IRP_MJ_CREATE] = DefDispatchRoutine;   // 注册派遣函数
	pDriverObject->MajorFunction[IRP_MJ_CLOSE] = DefDispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_WRITE] = DefDispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_READ] = DefDispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IoctlDispatchRoutine;

	NTSTATUS status;
	PDEVICE_OBJECT pDevObj;
	PDEVICE_EXTENSION pDevExt;

	//创建设备名称的字符串
	UNICODE_STRING devName;
	RtlInitUnicodeString(&devName, L"\\Device\\MyDevice");
	//创建设备
	status = IoCreateDevice(pDriverObject, sizeof(DEVICE_EXTENSION), &devName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
	pDevObj->Flags |= DO_BUFFERED_IO;//将设备设置为缓冲I/O设备
	pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;//得到设备扩展

	//创建符号链接
	UNICODE_STRING symLinkName;
	RtlInitUnicodeString(&symLinkName, L"\\??\\MyDevice");
	pDevExt->SymLinkName = symLinkName;
	status = IoCreateSymbolicLink(&symLinkName, &devName);
	return STATUS_SUCCESS;
}

客户端

#include "stdafx.h"
#include<Windows.h>
// 自定义的控制信号
#define My_Code CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)

typedef struct Hread {
	ULONG Flage;
	ULONG Addr;
	ULONG WriteBufferAddr;
	ULONG Size;
	ULONG Pid;
}_Hread, *PtrHread;

int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE handle = CreateFileA("\\\\.\\MyDevice", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	unsigned char RetBufferData[20] = { 0 };
	DWORD ReturnLength = 4;
	_Hread buf;

	buf.Flage = 2;
	buf.Addr = 0x401234;
	buf.WriteBufferAddr = 1024;
	buf.Size = 100;
	buf.Pid = 2566;

	DeviceIoControl(handle, My_Code, &buf, 20, (LPVOID)RetBufferData, 4, &ReturnLength, 0);
	printf("返回的数据： %s", RetBufferData);

	getchar();
	CloseHandle(handle);
	return 0;
}

微软技术分享

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
驱动开发：驱动与应用的通信

驱动程序与应用程序的通信离不开派遣函数，派遣函数是Windows驱动编程中的重要概念，一般情况下驱动程序负责处理I/O特权请求，而大部分IO的处理请求是在派遣函数中处理的，当用户请求数据时，操作系统会提前处理好请求，并将其派遣到指定的内核函数中执行，接下来将详细说明派遣函数的使用并通过派遣函数读取Shadow SSDT中的内容。先来简单介绍一下。
复制链接

扫一扫