目录/参考资料：https://www.cnblogs.com/railgunRG/p/14412321.html

在阅读本节前，建议先阅读《Windows内核安全与驱动开发》第五章内容，并自行了解相关背景知识。

R0部分

创建项目，打开：项目属性->链接器->输入->附加依赖项(点开后选择【编辑】)，添加：

%(AdditionalDependencies)

$(DDK_LIB_PATH)\wdmsec.lib

参考代码：

#include <ntifs.h>

#include <wdmsec.h>

static PDEVICE_OBJECT g_cdo = NULL;

const GUID  CWK_GUID_CLASS_MYCDO =

{ 0x17a0d1e0L, 0x3249, 0x12e1, {0x92,0x16, 0x45, 0x1a, 0x21, 0x30, 0x29, 0x06} };

#define CWK_CDO_SYB_NAME    L"\\??\\slbkcdo_3948d33e"

// 从应用层给驱动发送一个字符串。

#define  CWK_DVC_SEND_STR \

	(ULONG)CTL_CODE( \

	FILE_DEVICE_UNKNOWN, \

	0x911,METHOD_BUFFERED, \

	FILE_WRITE_DATA)

// 从驱动读取一个字符串

#define  CWK_DVC_RECV_STR \

	(ULONG)CTL_CODE( \

	FILE_DEVICE_UNKNOWN, \

	0x912,METHOD_BUFFERED, \

	FILE_READ_DATA)

// 定义一个链表用来保存字符串

#define CWK_STR_LEN_MAX 512

typedef struct {

	LIST_ENTRY list_entry;

	char buf[CWK_STR_LEN_MAX];

} CWK_STR_NODE;

// 还必须有一把自旋锁来保证链表操作的安全性

KSPIN_LOCK g_cwk_lock;

// 一个事件来标识是否有字符串可以取

KEVENT  g_cwk_event;

// 必须有个链表头

LIST_ENTRY g_cwk_str_list;

#define MEM_TAG 'cwkr'

// 分配内存并初始化一个链表节点

CWK_STR_NODE *cwkMallocStrNode()

{

	CWK_STR_NODE *ret = ExAllocatePoolWithTag(

		NonPagedPool, sizeof(CWK_STR_NODE), MEM_TAG);

	if (ret == NULL)

		return NULL;

	return ret;

}

void cwkUnload(PDRIVER_OBJECT driver)

{

	DbgPrint("\r\n准备卸载\r\n");

	UNICODE_STRING cdo_syb = RTL_CONSTANT_STRING(CWK_CDO_SYB_NAME);

	CWK_STR_NODE *str_node;

	//ASSERT(g_cdo != NULL);//bug崩溃？

	DbgPrint("准备删除符号链接\r\n");

	IoDeleteSymbolicLink(&cdo_syb);

	DbgPrint("准备删除驱动对象\r\n");

	if(g_cdo!=NULL)IoDeleteDevice(g_cdo);

	else {

		DbgPrint("\r\n发生严重错误：g_cdo==NULL\r\n");

	}

	DbgPrint("\r\n准备释放内存\r\n");

	// 负责的编程态度：释放分配过的所有内核内存。

	while (TRUE)

	{

		str_node = (CWK_STR_NODE *)ExInterlockedRemoveHeadList(

			&g_cwk_str_list, &g_cwk_lock);

		// str_node = RemoveHeadList(&g_cwk_str_list);

		if (str_node != NULL)

			ExFreePool(str_node);

		else

			break;

	};

	DbgPrint("\r\n卸载完成\r\n");

}

NTSTATUS cwkDispatch(

	IN PDEVICE_OBJECT dev,

	IN PIRP irp)

{

	PIO_STACK_LOCATION  irpsp = IoGetCurrentIrpStackLocation(irp);

	NTSTATUS status = STATUS_SUCCESS;

	ULONG ret_len = 0;

	while (1)

	{

		if (irpsp->MajorFunction == IRP_MJ_CREATE || irpsp->MajorFunction == IRP_MJ_CLOSE)

		{

			break;

		}

		if (irpsp->MajorFunction == IRP_MJ_DEVICE_CONTROL)

		{

			// 处理DeviceIoControl。

			PVOID buffer = irp->AssociatedIrp.SystemBuffer;

			ULONG inlen = irpsp->Parameters.DeviceIoControl.InputBufferLength;

			ULONG outlen = irpsp->Parameters.DeviceIoControl.OutputBufferLength;

			ULONG len;

			CWK_STR_NODE *str_node;

			switch (irpsp->Parameters.DeviceIoControl.IoControlCode)

			{

			case CWK_DVC_SEND_STR:

				ASSERT(buffer != NULL);

				ASSERT(outlen == 0);

				if (inlen > CWK_STR_LEN_MAX)

				{

					status = STATUS_INVALID_PARAMETER;

					break;

				}

				DbgPrint("\r\n接收到来自r3的信息:%s\r\n", (char *)buffer);

				str_node = cwkMallocStrNode();

				if (str_node == NULL)

				{

					status = STATUS_INSUFFICIENT_RESOURCES;

					break;

				}

				//char* tmpBuffer= RTL_CONSTANT_STRING(L"QWQ");//字符缓冲

				//strncpy(tmpBuffer, (char *)buffer, CWK_STR_LEN_MAX);

				strncpy(str_node->buf, (char *)buffer, CWK_STR_LEN_MAX);

				strncpy(str_node->buf, (char *)buffer, CWK_STR_LEN_MAX);

				char tmp1[512] = "Hello,Ring3!";

				strncpy(str_node->buf, tmp1, CWK_STR_LEN_MAX);

				// 插入到链表末尾。用锁来保证安全性。

				ExInterlockedInsertTailList(&g_cwk_str_list, (PLIST_ENTRY)str_node, &g_cwk_lock);

				// InsertTailList(&g_cwk_str_list, (PLIST_ENTRY)str_node);

				// 打印

				// DbgPrint((char *)buffer);

				// 那么现在就可以认为这个请求已经成功。因为刚刚已经插入了一

				// 个，那么可以设置事件来表明队列中已经有元素了。

				KeSetEvent(&g_cwk_event, 0, FALSE);//设为TRUE就是等死

				//DbgPrint("\r\n信息处理完成！\r\n");

				break;

			case CWK_DVC_RECV_STR:

				//ASSERT(buffer != NULL);

				//ASSERT(inlen == 0);

				if (outlen < CWK_STR_LEN_MAX)

				{

					DbgPrint("\r\n长度太短..\r\n");

					status = STATUS_INVALID_PARAMETER;

					break;

				}

				while (1)

				{

					// 插入到链表末尾。用锁来保证安全性。

					str_node = (CWK_STR_NODE *)ExInterlockedRemoveHeadList(&g_cwk_str_list, &g_cwk_lock);

					// str_node = RemoveHeadList(&g_cwk_str_list);

					if (str_node != NULL)

					{

						// 这种情况下，取得了字符串。那就拷贝到输出缓冲中。然后

						// 整个请求就返回了成功。

						strncpy((char *)buffer, str_node->buf, CWK_STR_LEN_MAX);

						ret_len = strnlen(str_node->buf, CWK_STR_LEN_MAX) + 1;

						DbgPrint("\r\n准备发送信息,%s\r\n", str_node->buf);

						ExFreePool(str_node);

						break;

					}

					else

					{

						// 对于合法的要求，在缓冲链表为空的情况下，等待事件进行

						// 阻塞。也就是说，如果缓冲区中没有字符串，就停下来等待

						// 。这样应用程序也会被阻塞住，DeviceIoControl是不会返回

						// 的。但是一旦有就会返回。等于驱动“主动”通知了应用。

						KeWaitForSingleObject(&g_cwk_event, Executive, KernelMode, 0, 0);

					}

				}

				break;

			default:

				// 到这里的请求都是不接受的请求。未知的请求一律返回非法参数错误。

				status = STATUS_INVALID_PARAMETER;

				DbgPrint("\r\n出现未知请求！！\r\n");

				break;

			}

		}

		break;

	}

	// 返回结果

	irp->IoStatus.Information = ret_len;

	irp->IoStatus.Status = status;

	IoCompleteRequest(irp, IO_NO_INCREMENT);

	//DbgPrint("\r\n成功返回结果！\r\n");

	return status;

}

NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)

{

	NTSTATUS status;

	ULONG i;

	UCHAR mem[256] = { 0 };

	// 生成一个控制设备。然后生成符号链接。

	UNICODE_STRING sddl = RTL_CONSTANT_STRING(L"D:P(A;;GA;;;WD)");

	UNICODE_STRING cdo_name = RTL_CONSTANT_STRING(L"\\Device\\cwk_3948d33e");

	UNICODE_STRING cdo_syb = RTL_CONSTANT_STRING(CWK_CDO_SYB_NAME);

	//KdBreakPoint();

	// 生成一个控制设备对象。

	status = IoCreateDeviceSecure(

		driver,

		0, &cdo_name,

		FILE_DEVICE_UNKNOWN,

		FILE_DEVICE_SECURE_OPEN,

		FALSE, &sddl,

		(LPCGUID)&CWK_GUID_CLASS_MYCDO,

		&g_cdo);

	if (!NT_SUCCESS(status))

		return status;

	// 生成符号链接.

	IoDeleteSymbolicLink(&cdo_syb);

	status = IoCreateSymbolicLink(&cdo_syb, &cdo_name);

	if (!NT_SUCCESS(status))

	{

		IoDeleteDevice(g_cdo);

		return status;

	}

	// 初始化事件、锁、链表头。

	KeInitializeEvent(&g_cwk_event, SynchronizationEvent, TRUE);

	KeInitializeSpinLock(&g_cwk_lock);

	InitializeListHead(&g_cwk_str_list);

	// 所有的分发函数都设置成一样的。

	for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)

	{

		driver->MajorFunction[i] = cwkDispatch;

	}

	//DbgPrint("test1\r\n");

	// 支持动态卸载。

	driver->DriverUnload = cwkUnload;

	//DbgPrint("test2\r\n");

	// 清除控制设备的初始化标记。

	//g_cdo->Flags &= ~DO_DEVICE_INITIALIZING;

	//DbgPrint("test3\r\n");

	return STATUS_SUCCESS;

}

R3部分

参考代码：

#include <stdio.h>

#include <tchar.h>

#include <windows.h>

const char* CWK_DEV_SYM = "\\\\.\\slbkcdo_3948d33e";

// 从应用层给驱动发送一个字符串。

#define  CWK_DVC_SEND_STR \

	(ULONG)CTL_CODE( \

	FILE_DEVICE_UNKNOWN, \

	0x911,METHOD_BUFFERED, \

	FILE_WRITE_DATA)

// 从驱动读取一个字符串

#define  CWK_DVC_RECV_STR \

	(ULONG)CTL_CODE( \

	FILE_DEVICE_UNKNOWN, \

	0x912,METHOD_BUFFERED, \

	FILE_READ_DATA)

int _tmain(int argc, _TCHAR* argv[])

{

	HANDLE device = NULL;

	ULONG ret_len;

    int ret = 0;

	char tmp[] = "Hello driver, this is a message from app.\r\n";

    char* msg = tmp;

    char tst_msg[1024] = { 0 };

	// 打开设备.每次要操作驱动的时候，先以此为例子打开设备

	device=CreateFile(CWK_DEV_SYM,GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_SYSTEM,0);

	if (device == INVALID_HANDLE_VALUE)

	{

		printf("coworker demo: Open device failed.\r\n");

		int VAKb;

		scanf_s("%d", &VAKb);

		return -1;

	}

	else

		printf("coworker demo: Open device successfully.\r\n");

	///////

	// 这里开始，其实是对驱动的一系列测试。分配3个字符串：

	// 1.长度为0.应该可以正常输入。

	// 2.长度为511字节，应该可以正常输入。

	// 3.长度为512字节，应该返回失败。

	// 4.长度为1024字节的字符串，但声明缓冲区长度为128，应该返回失败。

	// 5.第一次读取，应该读出msg的内容。

	// 5.第一次读取，应该读出长度为511字节的字符串。

	// 6.第二次读取，应该读出长度为0的字符串。

	do {

		if (!DeviceIoControl(device, CWK_DVC_SEND_STR, msg, strlen(msg) + 1, NULL, 0, &ret_len, 0))

		{

			printf("coworker demo: Send message failed.\r\n");

			ret = -2;

		}

		else

			printf("发送信息:%s\n", msg);

		if (DeviceIoControl(device, CWK_DVC_RECV_STR, NULL, 0, tst_msg, 1024, &ret_len, 0) == 0)

		{

			ret = -6;

			break;

		}

		else

		{

			printf("收到的信息:%s\r\n",tst_msg);

		}

	} while (0);

	///////

    CloseHandle(device);

	int VAKb;

	scanf_s("%d", &VAKb);

	return ret;

}

虚拟机内可能无法运行。解决方法：选择静态编译。项目属性-配置属性-C/C+±代码生成-运行库-多线程调试(/MTd)。

测试图例：

Windows7下驱动开发与调试体系构建——2.R3与R0的通信示例

R0部分

Windows7下驱动开发与调试体系 构建——2.R3与R0的通信示例的相关教程结束。

相关推荐

valgrind 配合 gdb 调试程序

「学习笔记」gdb 调试的简单操作

Abstract Factory 抽象工厂模式简介与 C# 示例【创建型1】【设计模式来了_1】

Singleton Pattern 单例模式简介与 C# 示例【创建型】【设计模式来了】

2023-04-24：用go语言重写ffmpeg的muxing.c示例。

pytest数据参数化和数据驱动yaml的简单使用

2022-12-15：寻找用户推荐人。写一个查询语句，返回一个客户列表，列表中客户的推荐人的编号都不是 2。对于示例数据，结果为： +------+ | name | +------+ | Wil

Singleton 单例模式简介与 C# 示例【创建型】【设计模式来了】

Windows7下驱动开发与调试体系构建——2.R3与R0的通信示例

R0部分

Windows7下驱动开发与调试体系构建——2.R3与R0的通信示例的相关教程结束。

相关推荐

valgrind 配合 gdb 调试程序

「学习笔记」gdb 调试的简单操作

Abstract Factory 抽象工厂模式简介与 C# 示例【创建型1】【设计模式来了_1】

Singleton Pattern 单例模式简介与 C# 示例【创建型】【设计模式来了】

2023-04-24：用go语言重写ffmpeg的muxing.c示例。

pytest数据参数化和数据驱动yaml的简单使用

2022-12-15：寻找用户推荐人。写一个查询语句，返回一个客户列表，列表中客户的推荐人的编号都 不是 2。 对于示例数据，结果为： +------+ | name | +------+ | Wil

Singleton 单例模式简介与 C# 示例【创建型】【设计模式来了】

2022-12-15：寻找用户推荐人。写一个查询语句，返回一个客户列表，列表中客户的推荐人的编号都不是 2。对于示例数据，结果为： +------+ | name | +------+ | Wil