WindowsX86内核03.控制,通讯方式,分页

admin

控制

昨天我已经实现了 打开，关闭 ，读写功能，或许会有疑问，已经有了读写功能，为什么还要控制功能呢，那是因为读写传递的参数较少，有时候并不能满足需要，例如当设备或者功能较多时，我们无法知道应该操作哪个设备或者哪个功能

例如昨天的代码 ,我们再结构体里面再添加2个成员,那个我们进行读写时,无法确定操作哪个成员,因为缺少参数

struct MyDeviceExt {

int nVirtualReg;

int nVirtualReg2;

int nVirtualReg3;

};

//读操作

DevExt.nVirtualReg = -1;

​ if (!ReadFile(hFile, &DevExt, sizeof(DevExt), &dwBytes, NULL)) //从寄存器里面读值

​ {

​ DisplayErrorText();

​ }

​ else

​ {

​ printf("ReadFile dwBytes = %d VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);

​ }

如果我们把 DevExt 当做序号传递,可以解决无法知道访问哪个成员的问题,但是如果进程访问,例如A进程写

B进程读 就会出问题

因此我们希望 ReadFile 能够多传一个参数,这样问题就简单了,但是如果结构体是数组没那么一个参数将不够用,因此五门无法确定要用到定义的参数个数

解决办法 是 我们可以传一个 int cod , void* buff , int len ,void*可以转换成任何结构体指针,code 表示要进行的操作,这个就叫做控制

控制和读写没什么特别大的区别,就多了3个参数

跟读写相比 就多了 第 2,3,4个参数, 操作码 缓冲区 缓冲区大小

完成控制功能定义控制码

控制码是有规范的

一共32位 0-1 是类型 2 - 12才是真正的控制吗 14-15 是设备访问权限 16-30 是设备类型

可以看到定义控制码很麻烦,因此微软给出了一个宏来辅助用户定义

#define IOCTL_Device_Function CTL_CODE(DeviceType*,** Function*,** Method**,** *Access*)

我么只需要把四个成员填进去就行了

• 设备类型
• 控制码 (不能低于800,前面的被微软用了)
• 通讯方式 METHOD_BUFFERED
• 访问权限 (读 或 写 或 打开.....)
  

一般我们自己会在定义一个红包裹这个宏

这样我们就可以定义宏了

#define IOCTL_GET_REG1 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_GET_REG2 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)

但是定义吗我么后面可能会越来越多,后面如果改起来就很麻烦,例如 要修改设备类型,所以一般我们会再套一个宏

//定义控制码#define MY_CODE_BASE 0x800#define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_GET_REG1 MY_CTL_CODE(0)#define IOCTL_GET_REG2 MY_CTL_CODE(1)#define IOCTL_GET_REG3 MY_CTL_CODE(2)#define IOCTL_SET_REG1 MY_CTL_CODE(3)#define IOCTL_SET_REG2 MY_CTL_CODE(4)#define IOCTL_SET_REG3 MY_CTL_CODE(5)这样如果要改信息只需要修改 宏 MY_CTL_CODE  就可以了

实现控制函数

驱动代码

1. --------------Hello.h-----------------
   
2. #pragma once
   
3. 
   
4. extern "C" {
   
5. 
   
6. #include <Ntddk.h>
   
7. 
   
8.     struct MyDeviceExt {
   
9.         int nVirtualReg;
   
10.         int nVirtualReg2;
    
11.         int nVirtualReg3;
    
12.     };
    
13. 
    
14. 
    
15.     #define DEVICE_NAME  L"\\Device\\CR42"
    
16.     #define SYMBOL_NAME L"\\DosDevices\\CR42VirtualRegister"
    
17. 
    
18.         //定义控制码
    
19.     #define MY_CODE_BASE 0x800
    
20.     #define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
21.     #define IOCTL_GET_REG1 MY_CTL_CODE(0)
    
22.     #define IOCTL_GET_REG2 MY_CTL_CODE(1)
    
23.     #define IOCTL_GET_REG3 MY_CTL_CODE(2)
    
24.     #define IOCTL_SET_REG1 MY_CTL_CODE(3)
    
25.     #define IOCTL_SET_REG2 MY_CTL_CODE(4)
    
26.     #define IOCTL_SET_REG3 MY_CTL_CODE(5)
    
27. 
    
28. 
    
29.     /*驱动入口函数*/
    
30.     NTSTATUS DriverEntry(__in struct _DRIVER_OBJECT* DriverObject,
    
31.         __in PUNICODE_STRING  RegistryPath);
    
32. 
    
33. 
    
34.     VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
    
35. 
    
36.     NTSTATUS DispatchCreate(
    
37.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
38.         _Inout_ struct _IRP* Irp
    
39.     );
    
40. 
    
41.     NTSTATUS DispatchClose(
    
42.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
43.         _Inout_ struct _IRP* Irp
    
44.     );
    
45. 
    
46.     NTSTATUS DispatchRead(
    
47.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
48.         _Inout_ struct _IRP* Irp
    
49.     );
    
50. 
    
51.     NTSTATUS DispatchWrite(
    
52.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
53.         _Inout_ struct _IRP* Irp
    
54.     );
    
55. 
    
56.     NTSTATUS DispatchControl(
    
57.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
58.         _Inout_ struct _IRP* Irp
    
59.     );
    
60. 
    
61. }
    
62. 
    
63. 
    
64. --------------Hello.cpp-----------------
    
65. #include "Hello.h"
    
66. 
    
67. 
    
68. MyDeviceExt g_Registers;
    
69. 
    
70. 
    
71. /*驱动卸载函数 clean_up*/
    
72. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject)
    
73. {
    
74.     DbgPrint("[51asm] Unload! DriverObject:%p\n", DriverObject);
    
75. 
    
76.     //删除符号链接
    
77.     UNICODE_STRING ustrSymbolName;
    
78.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
    
79.     IoDeleteSymbolicLink(&ustrSymbolName);
    
80. 
    
81.     //删除设备
    
82.     if (DriverObject->DeviceObject != NULL)
    
83.         IoDeleteDevice(DriverObject->DeviceObject);
    
84. }
    
85. 
    
86. /*1.驱动入口函数*/
    
87. NTSTATUS DriverEntry(
    
88.     __in struct _DRIVER_OBJECT* DriverObject,
    
89.     __in PUNICODE_STRING  RegistryPath)
    
90. {
    
91.     DbgPrint("[51asm] Hello WDK! DriverObject:%p RegistryPath:%wZ\n",
    
92.         DriverObject, RegistryPath);
    
93. 
    
94.     //2.创建设备
    
95.     UNICODE_STRING ustrDevName;
    
96.     RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);  //等于上面的3行代码
    
97. 
    
98. 
    
99. 
    
100.     PDEVICE_OBJECT pDevObj = NULL;
     
101.     NTSTATUS Status = IoCreateDevice(DriverObject,
     
102.         0,
     
103.         &ustrDevName,
     
104.         FILE_DEVICE_UNKNOWN,  //不知道的设备类型
     
105.         FILE_DEVICE_SECURE_OPEN,
     
106.         FALSE, //独占
     
107.         &pDevObj);
     
108.     if (!NT_SUCCESS(Status)) {
     
109.         DbgPrint("[51asm] IoCreateDevice Status:%p\n", Status);
     
110.         return Status;
     
111.     }
     
112. 
     
113. 
     
114.     //MS-DOS Device Names  创建符号链接
     
115.     UNICODE_STRING ustrSymbolName;
     
116.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
     
117.     Status = IoCreateSymbolicLink(&ustrSymbolName, &ustrDevName);
     
118.     if (!NT_SUCCESS(Status)) {
     
119.         DbgPrint("[51asm] IoCreateSymbolicLink Status:%p\n", Status);
     
120. 
     
121.         if (pDevObj != NULL)
     
122.             IoDeleteDevice(pDevObj);
     
123. 
     
124.         return Status;
     
125.     }
     
126.     DbgPrint("[51asm] IoCreateSymbolicLink %wZ OK\n", &ustrSymbolName);
     
127. 
     
128.     //3.注册派遣函数
     
129.     DriverObject->MajorFunction[IRP_MJ_CREATE] = &DispatchCreate;
     
130.     DriverObject->MajorFunction[IRP_MJ_CLOSE] = &DispatchClose;
     
131.     DriverObject->MajorFunction[IRP_MJ_READ] = &DispatchRead;
     
132.     DriverObject->MajorFunction[IRP_MJ_WRITE] = &DispatchWrite;
     
133.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &DispatchControl;
     
134. 
     
135. 
     
136.     //4.注册卸载函数
     
137.     DriverObject->DriverUnload = Unload;
     
138. 
     
139.     return STATUS_SUCCESS;
     
140. }
     
141. 
     
142. 
     
143. NTSTATUS DispatchCreate(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
144. {
     
145.     UNREFERENCED_PARAMETER(DeviceObject);
     
146.     UNREFERENCED_PARAMETER(Irp);
     
147.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
148. 
     
149.     //完成请求  如果没完成 3环的程序就会挂起
     
150.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
151.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
152. 
     
153.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
154.     IoCompleteRequest(Irp, IO_NO_INCREMENT);  
     
155. 
     
156.     return STATUS_SUCCESS;
     
157. }
     
158. 
     
159. NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
160. {
     
161.     UNREFERENCED_PARAMETER(DeviceObject);
     
162.     UNREFERENCED_PARAMETER(Irp);
     
163.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
164. 
     
165. 
     
166.     //完成请求  如果没完成 3环的程序就会挂起
     
167.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
168.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
169. 
     
170.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
171.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
172. 
     
173.     return STATUS_SUCCESS;
     
174. }
     
175. 
     
176. NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
177. {
     
178.     UNREFERENCED_PARAMETER(DeviceObject);
     
179.     UNREFERENCED_PARAMETER(Irp);
     
180.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
181. 
     
182.     //获取用户的缓冲区
     
183.     PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
184. 
     
185.      //获取当前IRP堆栈
     
186.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
187.     ULONG nLength = pIrpStack->Parameters.Read.Length;    //就是用户参数的 缓冲大小  read表示读操作
     
188.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
189. 
     
190. 
     
191.     if (nLength > sizeof(g_Registers.nVirtualReg)) {  //判断用户缓冲区大小是否足够
     
192.         nLength = sizeof(g_Registers.nVirtualReg);
     
193.     }
     
194.         
     
195.     //拷贝信息  就等于  memcoy
     
196.     RtlCopyMemory(pBuffer,&g_Registers.nVirtualReg, nLength);  //把寄存器数据数据传入用缓冲区
     
197. 
     
198.     //完成请求  如果没完成 3环的程序就会挂起
     
199.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
200.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
201. 
     
202.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
203.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
204. 
     
205.     return STATUS_SUCCESS;
     
206. }
     
207. 
     
208. 
     
209. NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
210. {
     
211.     UNREFERENCED_PARAMETER(DeviceObject);
     
212.     UNREFERENCED_PARAMETER(Irp);
     
213.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
214. 
     
215.     //获取用户的缓冲区
     
216.     PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
217. 
     
218.     //获取当前IRP堆栈
     
219.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
220.     ULONG nLength = pIrpStack->Parameters.Write.Length;    //就是用户参数的 缓冲大小  Write表示写操作
     
221.    
     
222.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
223. 
     
224.     if (nLength > sizeof(g_Registers.nVirtualReg)) {
     
225.         nLength = sizeof(g_Registers.nVirtualReg);
     
226.     }
     
227.       
     
228.     RtlCopyMemory(&g_Registers.nVirtualReg, pBuffer, nLength);  //将用户数据拷贝进内核的缓冲区
     
229. 
     
230. 
     
231.     //完成请求  如果没完成 3环的程序就会挂起
     
232.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
233.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
234. 
     
235.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
236.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
237. 
     
238.     return STATUS_SUCCESS;
     
239. }
     
240. 
     
241. NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
242. {
     
243.     UNREFERENCED_PARAMETER(DeviceObject);
     
244.     UNREFERENCED_PARAMETER(Irp);
     
245.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
246. 
     
247. 
     
248.     //获取当前IRP堆栈
     
249.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
250. 
     
251.     //获取用户的缓冲区
     
252.     PVOID pOutBuffer = Irp->UserBuffer;  //获取用户输出缓冲区
     
253.     ULONG nOutLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;   //获取用户输出缓冲区大小
     
254. 
     
255.     PVOID pInputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;  //获取用户输入缓冲区
     
256.     ULONG nInputLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;  //获取用户输入缓冲区大小
     
257. 
     
258.     ULONG nIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;    //获取操作码
     
259. 
     
260.     //DbgPrint("[51asm] %s nIoControlCode:%p pInputBuffer:%p nInputLength:%d pOutBuffer:%p nOutLength:%d\n", __FUNCTION__,  nIoControlCode, pBuffer, nLength);
     
261. 
     
262.     DbgPrint("[51asm] %s nIoControlCode:%p pInputBuffer:%p nInputLength:%d pOutBuffer:%p nOutLength:%d\n"
     
263.         , __FUNCTION__, nIoControlCode, pOutBuffer, nOutLength, pInputBuffer, nInputLength);
     
264. 
     
265. 
     
266.     ULONG nSize = 0;
     
267.     if (nOutLength!=4)
     
268.     {
     
269.         nOutLength = 4;
     
270.     }
     
271.     if (nInputLength != 4)
     
272.     {
     
273.         nInputLength = 4;
     
274.     }
     
275. 
     
276.     KeEnterCriticalRegion();
     
277.     switch (nIoControlCode) {
     
278.     case IOCTL_GET_REG1:
     
279.         RtlCopyMemory(pOutBuffer, &g_Registers.nVirtualReg, nOutLength);
     
280.         nSize = nOutLength;
     
281. 
     
282.         DbgPrint("[51asm] %s IOCTL_GET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
     
283.         break;
     
284.     case IOCTL_GET_REG2:
     
285.         RtlCopyMemory(pOutBuffer, &g_Registers.nVirtualReg2, nOutLength);
     
286.         nSize = nOutLength;
     
287. 
     
288.         DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
     
289.         break;
     
290.     case IOCTL_GET_REG3:
     
291.         RtlCopyMemory(pOutBuffer, &g_Registers.nVirtualReg3, nOutLength);
     
292.         nSize = nOutLength;
     
293. 
     
294.         DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
     
295.         break;
     
296.     case IOCTL_SET_REG1:
     
297.         RtlCopyMemory(&g_Registers.nVirtualReg, pInputBuffer, nInputLength);
     
298.         nSize = nInputLength;
     
299. 
     
300.         DbgPrint("[51asm] %s IOCTL_SET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
     
301.         break;
     
302.     case IOCTL_SET_REG2:
     
303.         RtlCopyMemory(&g_Registers.nVirtualReg2, pInputBuffer, nInputLength);
     
304.         nSize = nInputLength;
     
305. 
     
306.         DbgPrint("[51asm] %s IOCTL_SET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
     
307.         break;
     
308.     case IOCTL_SET_REG3:
     
309.         RtlCopyMemory(&g_Registers.nVirtualReg3, pInputBuffer, nInputLength);
     
310.         nSize = nInputLength;
     
311. 
     
312.         DbgPrint("[51asm] %s IOCTL_SET_REG3 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
     
313.         break;
     
314.     }
     
315.     KeLeaveCriticalRegion();
     
316. 
     
317.     Irp->IoStatus.Status = STATUS_SUCCESS;
     
318.     Irp->IoStatus.Information = nSize;
     
319.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
320. 
     
321.     return STATUS_SUCCESS;
     
322. }

复制代码

测试代码

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. #include <stdlib.h>
   
4. #include <winioctl.h>
   
5. 
   
6. struct MyDeviceExt {
   
7.     int nVirtualReg;
   
8.     int nVirtualReg2;
   
9.     int nVirtualReg3;
   
10. };
    
11. 
    
12. //定义控制码
    
13. #define MY_CODE_BASE 0x800
    
14. #define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
15. #define IOCTL_GET_REG1 MY_CTL_CODE(0)
    
16. #define IOCTL_GET_REG2 MY_CTL_CODE(1)
    
17. #define IOCTL_GET_REG3 MY_CTL_CODE(2)
    
18. #define IOCTL_SET_REG1 MY_CTL_CODE(3)
    
19. #define IOCTL_SET_REG2 MY_CTL_CODE(4)
    
20. #define IOCTL_SET_REG3 MY_CTL_CODE(5)
    
21. 
    
22. 
    
23. void DisplayErrorText()
    
24. {
    
25.     LPVOID lpMsgBuf;
    
26.     FormatMessage(
    
27.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
    
28.         FORMAT_MESSAGE_FROM_SYSTEM |
    
29.         FORMAT_MESSAGE_IGNORE_INSERTS,
    
30.         NULL,
    
31.         GetLastError(),
    
32.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    
33.         (LPTSTR)&lpMsgBuf,
    
34.         0,
    
35.         NULL
    
36.     );
    
37. 
    
38.     printf((LPCTSTR)lpMsgBuf);
    
39. 
    
40.     // Free the buffer.
    
41.     LocalFree(lpMsgBuf);
    
42. }
    
43. 
    
44. int main()
    
45. {
    
46.     HANDLE hFile = CreateFile("\\\\?\\CR42VirtualRegister",
    
47.         GENERIC_ALL,
    
48.         0,
    
49.         NULL,
    
50.         OPEN_EXISTING,
    
51.         FILE_ATTRIBUTE_NORMAL,
    
52.         NULL);
    
53.     if (hFile == INVALID_HANDLE_VALUE)
    
54.     {
    
55.         DisplayErrorText();
    
56.     }
    
57.     else {
    
58.         printf("hFile = %p\n", hFile);
    
59.     }
    
60. 
    
61. 
    
62. 
    
63. 
    
64.     MyDeviceExt DevExt = { 0 };
    
65.     DWORD dwBytes = 0;
    
66.     DevExt.nVirtualReg = 100;
    
67.     if (!WriteFile(hFile, &DevExt, 10000, &dwBytes, NULL))
    
68.     {
    
69.         DisplayErrorText();
    
70.     }
    
71.     else
    
72.     {
    
73.         printf("WriteFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
74.     }
    
75. 
    
76. 
    
77.     DevExt.nVirtualReg = 2;
    
78.     if (!ReadFile(hFile, &DevExt, sizeof(DevExt), &dwBytes, NULL))
    
79.     {
    
80.         DisplayErrorText();
    
81.     }
    
82.     else
    
83.     {
    
84.         printf("ReadFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
85.     }
    
86. 
    
87. 
    
88.     //向内核传递数据,不需要接收数据,所以给空
    
89.     int nReg = 123;
    
90.     DeviceIoControl(hFile, IOCTL_SET_REG1, &nReg, sizeof(nReg), NULL, 0, &dwBytes, NULL);
    
91.     printf("DeviceIoControl dwBytes = %d  nReg:%d\n", dwBytes, nReg);
    
92. 
    
93.     //从内核获取数据,不需要传递数据,所以给空
    
94.     DeviceIoControl(hFile, IOCTL_GET_REG1, NULL, 0, &nReg, sizeof(nReg), &dwBytes, NULL);
    
95.     printf("DeviceIoControl dwBytes = %d  nReg:%d\n", dwBytes, nReg);
    
96. 
    
97.     CloseHandle(hFile);
    
98. 
    
99.     system("pause");
    
100.     return 0;
     
101. }

复制代码

测试

一般在做内核驱动的时候给个控制和打开,关闭就可以,读和写可以实现也可以不实现

解决同步问题

可以通过临界区解决

KeEnterCriticalRegion();   //进去临界区  //需要同步的代码 KeLeaveCriticalRegion();  //退出临界区

  KeEnterCriticalRegion();  

1. KeEnterCriticalRegion();
   
2.   switch(nIoControlCode) {
   
3.   case IOCTL_GET_REG1:
   
4.     RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg, nLength);
   
5.     nSize = nLength;
   
6.     DbgPrint("[51asm] %s IOCTL_GET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
   
7.     break;
   
8.   case IOCTL_GET_REG2:
   
9.     RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg2, nLength);
   
10.     nSize = nLength;
    
11.     DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
    
12.     break;
    
13.   case IOCTL_GET_REG3:
    
14.     RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg3, nLength);
    
15.     nSize = nLength;
    
16.     DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
    
17.     break;
    
18.   case IOCTL_SET_REG1:
    
19.     RtlCopyMemory(&g_Registers.nVirtualReg, pBuffer, nLength);
    
20.     DbgPrint("[51asm] %s IOCTL_SET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
    
21.     nSize = nLength;
    
22.     break;
    
23.   case IOCTL_SET_REG2:
    
24.     RtlCopyMemory(&g_Registers.nVirtualReg2, pBuffer, nLength);
    
25.     DbgPrint("[51asm] %s IOCTL_SET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
    
26.     nSize = nLength;
    
27.     break;
    
28.   case IOCTL_SET_REG3:
    
29.     RtlCopyMemory(&g_Registers.nVirtualReg3, pBuffer, nLength);
    
30.     DbgPrint("[51asm] %s IOCTL_SET_REG3 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
    
31.     nSize = nLength;
    
32.     break;
    
33.   }
    
34.   KeLeaveCriticalRegion();

复制代码

注意: 上面的代码存在问题 ,set功能会导致蓝屏

安全问题

我们的回调函数可能在任何一个进程,线程中运行

0~2G 不共享

2G~4G 共享

内核中不推荐直接访问用户空间地址(线程上下文相关)

3环的地址和大小是不可信任的

问题

• 线程上下文问题: 简单来说就是 回调函数可能被操作系统的线程执行了,这个时候访问用户空间地址是,进程和线程已经切了,切了之后这个3环的地址可能在对方进程是一个无效的地址,于是就会蓝屏
• 安全问题 :内核驱动去3环缓冲区读数据 , 如果有以下代码
  

void *p = malloc();

free(p);

ReadFile(p);

驱动访问 *p 地址就会蓝屏,因此很容易被人攻击

通讯方式

• 其它方式（直接访问用户地址) : 不推荐,很容易蓝屏
• 缓冲区方式 (常用)
  

在创建设备时设置

//设置设备的缓冲区通讯方式 控制是在操作码里面设置的

pDevObj->Flags |= DO_BUFFERED_IO; //缓冲区通讯方式

• 直接方式
  

//设置设备的缓冲区通讯方式 控制是在操作码里面设置的

pDevObj->Flags |= DO_DIRECT_IO; //直接方式

直接或者缓冲只能设置一个,不能同时设两个

控制输入和输出共用一个缓冲区,是因为 系统先把输入缓冲区的数据读进来,此时输入缓冲区就没用了,刚好可以用来作输出缓冲区.

1. --------------------Hello.h------------------
   
2. 
   
3. #pragma once
   
4. extern "C" {
   
5. #include <Ntddk.h>
   
6. 
   
7.     struct MyDeviceExt {
   
8.         int nVirtualReg;
   
9.         int nVirtualReg2;
   
10.         int nVirtualReg3;
    
11.     };
    
12. 
    
13.     #define DEVICE_NAME  L"\\Device\\CR42"
    
14.     #define SYMBOL_NAME L"\\DosDevices\\CR42VirtualRegister"
    
15. 
    
16.     //定义控制码
    
17.     #define MY_CODE_BASE 0x800
    
18.     #define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
19.     #define IOCTL_GET_REG1 MY_CTL_CODE(0)
    
20.     #define IOCTL_GET_REG2 MY_CTL_CODE(1)
    
21.     #define IOCTL_GET_REG3 MY_CTL_CODE(2)
    
22.     #define IOCTL_SET_REG1 MY_CTL_CODE(3)
    
23.     #define IOCTL_SET_REG2 MY_CTL_CODE(4)
    
24.     #define IOCTL_SET_REG3 MY_CTL_CODE(5)
    
25. 
    
26. 
    
27.     /*驱动入口函数*/
    
28.     NTSTATUS DriverEntry(__in struct _DRIVER_OBJECT* DriverObject,
    
29.         __in PUNICODE_STRING  RegistryPath);
    
30. 
    
31. 
    
32.     VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
    
33. 
    
34.     NTSTATUS DispatchCreate(
    
35.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
36.         _Inout_ struct _IRP* Irp
    
37.     );
    
38. 
    
39.     NTSTATUS DispatchClose(
    
40.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
41.         _Inout_ struct _IRP* Irp
    
42.     );
    
43. 
    
44.     NTSTATUS DispatchRead(
    
45.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
46.         _Inout_ struct _IRP* Irp
    
47.     );
    
48. 
    
49.     NTSTATUS DispatchWrite(
    
50.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
51.         _Inout_ struct _IRP* Irp
    
52.     );
    
53. 
    
54.     NTSTATUS DispatchControl(
    
55.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
56.         _Inout_ struct _IRP* Irp
    
57.     );
    
58. 
    
59. }
    
60. 
    
61. --------------------Hello.cpp------------------
    
62. 
    
63. #include "Hello.h"
    
64. 
    
65. MyDeviceExt g_Registers;
    
66. 
    
67. /*驱动卸载函数 clean_up*/
    
68. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject)
    
69. {
    
70.     DbgPrint("[51asm] Unload! DriverObject:%p\n", DriverObject);
    
71. 
    
72.     //删除符号链接
    
73.     UNICODE_STRING ustrSymbolName;
    
74.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
    
75.     IoDeleteSymbolicLink(&ustrSymbolName);
    
76. 
    
77.     //删除设备
    
78.     if (DriverObject->DeviceObject != NULL)
    
79.         IoDeleteDevice(DriverObject->DeviceObject);
    
80. }
    
81. 
    
82. /*1.驱动入口函数*/
    
83. NTSTATUS DriverEntry(
    
84.     __in struct _DRIVER_OBJECT* DriverObject,
    
85.     __in PUNICODE_STRING  RegistryPath)
    
86. {
    
87.     DbgPrint("[51asm] Hello WDK! DriverObject:%p RegistryPath:%wZ\n",
    
88.         DriverObject, RegistryPath);
    
89. 
    
90.     //2.创建设备
    
91.     UNICODE_STRING ustrDevName;
    
92.     RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);  //等于上面的3行代码
    
93. 
    
94.     PDEVICE_OBJECT pDevObj = NULL;
    
95.     NTSTATUS Status = IoCreateDevice(DriverObject,
    
96.         0,
    
97.         &ustrDevName,
    
98.         FILE_DEVICE_UNKNOWN,  //不知道的设备类型
    
99.         FILE_DEVICE_SECURE_OPEN,
    
100.         FALSE, //独占
     
101.         &pDevObj);
     
102.     if (!NT_SUCCESS(Status)) {
     
103.         DbgPrint("[51asm] IoCreateDevice Status:%p\n", Status);
     
104.         return Status;
     
105.     }
     
106.     //设置设备的缓冲区通讯方式
     
107.     pDevObj->Flags |= DO_BUFFERED_IO; //缓冲区通讯方式 (这里只能设置读和写的)
     
108.     //pDevObj->Flags |= DO_DIRECT_IO;   //直接方式
     
109. 
     
110. 
     
111.     //MS-DOS Device Names  创建符号链接
     
112.     UNICODE_STRING ustrSymbolName;
     
113.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
     
114.     Status = IoCreateSymbolicLink(&ustrSymbolName, &ustrDevName);
     
115.     if (!NT_SUCCESS(Status)) {
     
116.         DbgPrint("[51asm] IoCreateSymbolicLink Status:%p\n", Status);
     
117. 
     
118.         if (pDevObj != NULL)
     
119.             IoDeleteDevice(pDevObj);
     
120. 
     
121.         return Status;
     
122.     }
     
123.     DbgPrint("[51asm] IoCreateSymbolicLink %wZ OK\n", &ustrSymbolName);
     
124. 
     
125.     //3.注册派遣函数
     
126.     DriverObject->MajorFunction[IRP_MJ_CREATE] = &DispatchCreate;
     
127.     DriverObject->MajorFunction[IRP_MJ_CLOSE] = &DispatchClose;
     
128.     DriverObject->MajorFunction[IRP_MJ_READ] = &DispatchRead;
     
129.     DriverObject->MajorFunction[IRP_MJ_WRITE] = &DispatchWrite;
     
130.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &DispatchControl;
     
131. 
     
132. 
     
133.     //4.注册卸载函数
     
134.     DriverObject->DriverUnload = Unload;
     
135. 
     
136.     return STATUS_SUCCESS;
     
137. }
     
138. 
     
139. 
     
140. NTSTATUS DispatchCreate(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
141. {
     
142.     UNREFERENCED_PARAMETER(DeviceObject);
     
143.     UNREFERENCED_PARAMETER(Irp);
     
144.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
145. 
     
146.     //完成请求  如果没完成 3环的程序就会挂起
     
147.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
148.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
149. 
     
150.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
151.     IoCompleteRequest(Irp, IO_NO_INCREMENT);  
     
152. 
     
153.     return STATUS_SUCCESS;
     
154. }
     
155. 
     
156. NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
157. {
     
158.     UNREFERENCED_PARAMETER(DeviceObject);
     
159.     UNREFERENCED_PARAMETER(Irp);
     
160.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
161. 
     
162.     //完成请求  如果没完成 3环的程序就会挂起
     
163.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
164.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
165. 
     
166.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
167.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
168. 
     
169.     return STATUS_SUCCESS;
     
170. }
     
171. 
     
172. NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
173. {
     
174.     UNREFERENCED_PARAMETER(DeviceObject);
     
175.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
176. 
     
177.     //获取用户的缓冲区
     
178.     //PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
179.     PVOID pBuffer = Irp->AssociatedIrp.SystemBuffer;  //因为设置了缓冲区通讯方式,用户缓冲区数据从系统申请的缓冲区读
     
180. 
     
181.      //获取当前IRP堆栈
     
182.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
183.     ULONG nLength = pIrpStack->Parameters.Read.Length;    //就是用户参数的 缓冲大小  read表示读操作
     
184.    
     
185.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
186.     DbgPrint("[51asm] %s UserBuffer:%p pBuffer:%p nLength:%d\n", __FUNCTION__, Irp->UserBuffer, pBuffer, nLength);
     
187. 
     
188.     if (nLength > sizeof(g_Registers.nVirtualReg)) {  //判断用户缓冲区大小是否足够
     
189.         nLength = sizeof(g_Registers.nVirtualReg);
     
190.     }
     
191.         
     
192.     //拷贝信息  就等于  memcoy
     
193.     RtlCopyMemory(pBuffer,&g_Registers.nVirtualReg, nLength);  //把寄存器数据数据传入用缓冲区
     
194. 
     
195.     //完成请求  如果没完成 3环的程序就会挂起
     
196.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
197.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
198. 
     
199.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
200.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
201. 
     
202.     return STATUS_SUCCESS;
     
203. }
     
204. 
     
205. 
     
206. NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
207. {
     
208.     UNREFERENCED_PARAMETER(DeviceObject);
     
209.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
210. 
     
211.     //获取用户的缓冲区
     
212.     //PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
213.     PVOID pBuffer = Irp->AssociatedIrp.SystemBuffer;  //因为设置了缓冲区通讯方式,用户缓冲区数据从系统申请的缓冲区读
     
214. 
     
215.     //获取当前IRP堆栈
     
216.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
217.     ULONG nLength = pIrpStack->Parameters.Write.Length;    //就是用户参数的 缓冲大小  Write表示写操作
     
218.    
     
219.    
     
220.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
221.     DbgPrint("[51asm] %s UserBuffer:%p pBuffer:%p nLength:%d\n",__FUNCTION__, Irp->UserBuffer, pBuffer, nLength);
     
222. 
     
223.     if (nLength > sizeof(g_Registers.nVirtualReg)) {
     
224.         nLength = sizeof(g_Registers.nVirtualReg);
     
225.     }
     
226.       
     
227.     RtlCopyMemory(&g_Registers.nVirtualReg, pBuffer, nLength);  //将用户数据拷贝进内核的缓冲区
     
228. 
     
229. 
     
230.     //完成请求  如果没完成 3环的程序就会挂起
     
231.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
232.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
233. 
     
234.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
235.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
236. 
     
237.     return STATUS_SUCCESS;
     
238. }
     
239. 
     
240. NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
241. {
     
242.     UNREFERENCED_PARAMETER(DeviceObject);
     
243.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
244. 
     
245.     //获取当前IRP堆栈
     
246.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
247. 
     
248. #if 0
     
249.     //获取用户的缓冲区
     
250.     PVOID pOutBuffer = Irp->UserBuffer;  //获取用户输出缓冲区
     
251.     ULONG nOutLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;   //获取用户输出缓冲区大小
     
252. 
     
253.     PVOID pInputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;  //获取用户输入缓冲区
     
254.     ULONG nInputLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;  //获取用户输入缓冲区大小
     
255. #endif // 0
     
256. 
     
257. 
     
258.     //获取用户的缓冲区
     
259.     PVOID pBuffer = Irp->AssociatedIrp.SystemBuffer;  //因为设置了缓冲区通讯方式,用户缓冲区数据从系统申请的缓冲区读
     
260.     ULONG nLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
     
261.     ULONG nIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;    //获取操作码
     
262. 
     
263.     DbgPrint("[51asm] %s nIoControlCode:%p pBuffer:%p nLength:%d\n", __FUNCTION__,
     
264.         nIoControlCode, pBuffer, nLength);
     
265. 
     
266.     ULONG nSize = 0;
     
267.     if (nLength != 4)
     
268.     {
     
269.         nLength = 4;
     
270.     }
     
271.    
     
272.     KeEnterCriticalRegion();
     
273.     switch (nIoControlCode) {
     
274.     case IOCTL_GET_REG1:
     
275.         RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg, nLength);
     
276.         nSize = nLength;
     
277. 
     
278.         DbgPrint("[51asm] %s IOCTL_GET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
     
279.         break;
     
280.     case IOCTL_GET_REG2:
     
281.         RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg2, nLength);
     
282.         nSize = nLength;
     
283. 
     
284.         DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
     
285.         break;
     
286.     case IOCTL_GET_REG3:
     
287.         RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg3, nLength);
     
288.         nSize = nLength;
     
289. 
     
290.         DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
     
291.         break;
     
292.     case IOCTL_SET_REG1:
     
293.         RtlCopyMemory(&g_Registers.nVirtualReg, pBuffer, nLength);
     
294.         nSize = nLength;
     
295. 
     
296.         DbgPrint("[51asm] %s IOCTL_SET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
     
297.         break;
     
298.     case IOCTL_SET_REG2:
     
299.         RtlCopyMemory(&g_Registers.nVirtualReg2, pBuffer, nLength);
     
300.         nSize = nLength;
     
301. 
     
302.         DbgPrint("[51asm] %s IOCTL_SET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
     
303.         break;
     
304.     case IOCTL_SET_REG3:
     
305.         RtlCopyMemory(&g_Registers.nVirtualReg3, pBuffer, nLength);
     
306.         nSize = nLength;
     
307. 
     
308.         DbgPrint("[51asm] %s IOCTL_SET_REG3 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
     
309.         break;
     
310.     }
     
311.     KeLeaveCriticalRegion();
     
312. 
     
313.     Irp->IoStatus.Status = STATUS_SUCCESS;
     
314.     Irp->IoStatus.Information = nSize;
     
315.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
316. 
     
317.     return STATUS_SUCCESS;
     
318. }

复制代码

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. #include <stdlib.h>
   
4. #include <winioctl.h>
   
5. 
   
6. struct MyDeviceExt {
   
7.     int nVirtualReg;
   
8.     int nVirtualReg2;
   
9.     int nVirtualReg3;
   
10. };
    
11. 
    
12. //定义控制码
    
13. #define MY_CODE_BASE 0x800
    
14. #define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
15. #define IOCTL_GET_REG1 MY_CTL_CODE(0)
    
16. #define IOCTL_GET_REG2 MY_CTL_CODE(1)
    
17. #define IOCTL_GET_REG3 MY_CTL_CODE(2)
    
18. #define IOCTL_SET_REG1 MY_CTL_CODE(3)
    
19. #define IOCTL_SET_REG2 MY_CTL_CODE(4)
    
20. #define IOCTL_SET_REG3 MY_CTL_CODE(5)
    
21. 
    
22. 
    
23. void DisplayErrorText()
    
24. {
    
25.     LPVOID lpMsgBuf;
    
26.     FormatMessage(
    
27.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
    
28.         FORMAT_MESSAGE_FROM_SYSTEM |
    
29.         FORMAT_MESSAGE_IGNORE_INSERTS,
    
30.         NULL,
    
31.         GetLastError(),
    
32.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    
33.         (LPTSTR)&lpMsgBuf,
    
34.         0,
    
35.         NULL
    
36.     );
    
37. 
    
38.     printf((LPCTSTR)lpMsgBuf);
    
39. 
    
40.     // Free the buffer.
    
41.     LocalFree(lpMsgBuf);
    
42. }
    
43. 
    
44. int main()
    
45. {
    
46.     HANDLE hFile = CreateFile("\\\\?\\CR42VirtualRegister",
    
47.         GENERIC_ALL,
    
48.         0,
    
49.         NULL,
    
50.         OPEN_EXISTING,
    
51.         FILE_ATTRIBUTE_NORMAL,
    
52.         NULL);
    
53.     if (hFile == INVALID_HANDLE_VALUE)
    
54.     {
    
55.         DisplayErrorText();
    
56.     }
    
57.     else {
    
58.         printf("hFile = %p\n", hFile);
    
59.     }
    
60. 
    
61.     MyDeviceExt DevExt = { 0 };
    
62.     DWORD dwBytes = 0;
    
63.     DevExt.nVirtualReg = 100;
    
64.     if (!WriteFile(hFile, &DevExt, 10000, &dwBytes, NULL))
    
65.     {
    
66.         DisplayErrorText();
    
67.     }
    
68.     else
    
69.     {
    
70.         printf("WriteFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
71.     }
    
72. 
    
73.     DevExt.nVirtualReg = 2;
    
74.     if (!ReadFile(hFile, &DevExt, sizeof(DevExt), &dwBytes, NULL))
    
75.     {
    
76.         DisplayErrorText();
    
77.     }
    
78.     else
    
79.     {
    
80.         printf("ReadFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
81.     }
    
82.     int nReg = 123;
    
83.     DeviceIoControl(hFile, IOCTL_SET_REG1, &nReg, sizeof(nReg), NULL, 0, &dwBytes, NULL);
    
84.     printf("DeviceIoControl dwBytes = %d  nReg:%d\n", dwBytes, nReg);
    
85. 
    
86.     nReg = 0;
    
87.     DeviceIoControl(hFile, IOCTL_GET_REG1, NULL, 0, &nReg, sizeof(nReg), &dwBytes, NULL);
    
88.     printf("DeviceIoControl dwBytes = %d  nReg:%d\n", dwBytes, nReg);
    
89. 
    
90.     CloseHandle(hFile);
    
91. 
    
92.     system("pause");
    
93.     return 0;
    
94. }

复制代码

但这种方式他有缺点,就是效率比较低,特别对于一个硬件设备来说,他在大量传输数据的时候他会有卡顿,因为数据量很大,每次返回数据有2次拷贝

内存共享可以极大的提交效率,但同时也会带来安全问题(0环和3环同时操作一个缓冲区)

因此可以通过直接方式通讯,应发跟通讯方式没啥区别,只不过获取缓冲区的方式不同,但注意要进行地址判断,防止地址为空,一般直接方式只会在硬件上看到,应为硬件比较简单

控制码里第3个参数它还有别的取值,对于直接方式,它有两个取值,两个挑一个用

METHOD_IN_DIRECT 1 ;直接方式 输入缓冲区

METHOD_OUT_DIRECT 2 ;直接方式 输出缓冲区

如果选择输出缓冲区直接,那么输出缓冲区就用Mdl,输入缓冲区就用SystemBuffer了;

输入缓冲区直接的话,输入缓冲区就用Mdl,输出就用SystemBuffer;反正只能选择一个

输入从Mdl拿

PVOID pInputBuffer =

​ MmGetSystemAddressForMdlSafe(Irp->MdlAddress,NormalPagePriority);

输出从SystemBuffer拿

​ PVOID pOutBuffer = Irp->AssociatedIrp.SystemBuffer;

内核的堆空间

内核的堆空间和3环的堆空间是分开的,不允许用户堆空间去操作内核的堆空间

内核申请堆空间

ExAllocatePool (不让用了)

参数:

• 内存分页池类型
• 大小
  

或者

ExAllocatePoolWithTag

参数:

• 内存分页池类型
• 大小
• 标记 (四个字符)
  

跟上一个相比多一个参数: 标记

防止内存泄露,因为我们驱动卸载以后可以通过这个标记去找内存,如果找到了就存在内存泄漏,如果没找到就不存在

标记大小是四个字符, 例如: '1234' (注意单引号),意思是这里的最低一个字节用 sacii 码4取代.,倒数第二个用ascii码 3 取代......... 即在内存中 是 0x34 0x33 0x32 0x31 因为内存中的值小尾方式保存,因此通常会倒过来写 '4321',这样在内存中就是顺序排列

内存分页池

• NonPagedPool 非分页内存池
• PagedPool 分页内存池
  

我们申请内存时必须告诉系统从那哪个内存池里面申请内存,不管哪个池分配都是一个分页

NonPagedPool 相当于买房子 PagedPool 相当于租房子

当申请分页内存时,如果操作系统没有内存,就会把内存里面的数丢到磁盘中,把控件腾出来给系统用,当系统用完之后,再从磁盘把你数据还回来,这个过程需要时间.在window里面一般叫做虚拟内存(把硬盘当内存用),默认是开的

非分页内存是系统没内存用就没内存用,除非内存自己没用了,否则系统没法使用

因为我们申请内存时一般都是申请分页内存,如果代码很重要(实时性要求很高),需要一直再用,就可以考虑用非分页内存池.如果我们把非分页内存申请完,系统将会死机

系统的代码都是在非分页内存池中,一般正常的驱动代码都是在分页内存池

3环只能申请分页内存，不能申请非分页内存

自己写的函数(就那些Read,Write....)代码,默认都是非分页内存池中

申请分页内存

通过3环的一个宏来解决

#param alloc_text("PAGENAME",FUN1)

其中PAGENAME是节的名称,PAGE就是把代码放到分页内存池,FUN1是函数名称

#pragma alloc_text("PAGE", DispatchRead);这意思就是把DispatchRead函数放到分页内存里

它可以用逗号分隔,写多个函数,但是不推荐,一般还是一个函数写一行这样的,方便修改

#pragma alloc_text( "PAGE", DispatchCreate)

#pragma alloc_text( "PAGE", DispatchClose)

#pragma alloc_text( "PAGE", DispatchWrite)

#pragma alloc_text( "PAGE", DispatchRead)

#pragma alloc_text( "PAGE", DispatchControl)

#pragma alloc_text( "PAGE", Unload)

#pragma alloc_text( "INIT", DriverEntry)

• 操作系统会定义节来把函数放到对应的节里
• 
• 
  
  • 放到.text就非分页内存
  • 放到PAGE就是分页内存
  • .INIT节是放一些只执行一次的代码 ,用完之后内存就会被释放
    
  
  

因为内核的内存是很宝贵的,而DriverEntry这个函数执行完之后就没用了,它就入口执行一次,所以就把他放到.INIT节里,就是一次性的简单来说就是驱动加载完后这个节的内存全部会被释放掉,也就是DriverEntry执行完后INIT整个节内存就被释放了.Unload是不能放到这个节里的,因为可能执行卸载函数的时候这个内存已经被释放了,所以就释放的时候就崩了

• 到此这个框架就完成了,要实现功能的话就写控制代码就好了
  

完整源码内核驱动

1. #pragma once
   
2. 
   
3. extern "C" {
   
4. 
   
5. #include <Ntddk.h>
   
6. 
   
7.     struct MyDeviceExt {
   
8.         int nVirtualReg;
   
9.         int nVirtualReg2;
   
10.         int nVirtualReg3;
    
11.     };
    
12. 
    
13.     #define DEVICE_NAME  L"\\Device\\CR42"
    
14.     #define SYMBOL_NAME L"\\DosDevices\\CR42VirtualRegister"
    
15. 
    
16.         //定义控制码
    
17.     #define MY_CODE_BASE 0x800
    
18.     #define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
19.     #define IOCTL_GET_REG1 MY_CTL_CODE(0)
    
20.     #define IOCTL_GET_REG2 MY_CTL_CODE(1)
    
21.     #define IOCTL_GET_REG3 MY_CTL_CODE(2)
    
22.     #define IOCTL_SET_REG1 MY_CTL_CODE(3)
    
23.     #define IOCTL_SET_REG2 MY_CTL_CODE(4)
    
24.     #define IOCTL_SET_REG3 MY_CTL_CODE(5)
    
25. 
    
26. 
    
27.     /*驱动入口函数*/
    
28.     NTSTATUS DriverEntry(__in struct _DRIVER_OBJECT* DriverObject,
    
29.         __in PUNICODE_STRING  RegistryPath);
    
30. 
    
31. 
    
32.     VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
    
33. 
    
34.     NTSTATUS DispatchCreate(
    
35.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
36.         _Inout_ struct _IRP* Irp
    
37.     );
    
38. 
    
39.     NTSTATUS DispatchClose(
    
40.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
41.         _Inout_ struct _IRP* Irp
    
42.     );
    
43. 
    
44.     NTSTATUS DispatchRead(
    
45.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
46.         _Inout_ struct _IRP* Irp
    
47.     );
    
48. 
    
49.     NTSTATUS DispatchWrite(
    
50.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
51.         _Inout_ struct _IRP* Irp
    
52.     );
    
53. 
    
54.     NTSTATUS DispatchControl(
    
55.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
56.         _Inout_ struct _IRP* Irp
    
57.     );
    
58. 
    
59. #pragma alloc_text( "PAGE", DispatchCreate)
    
60. #pragma alloc_text( "PAGE", DispatchClose)
    
61. #pragma alloc_text( "PAGE", DispatchWrite)
    
62. #pragma alloc_text( "PAGE", DispatchRead)
    
63. #pragma alloc_text( "PAGE", DispatchControl)
    
64. #pragma alloc_text( "PAGE", Unload)
    
65. #pragma alloc_text( "INIT", DriverEntry)
    
66. 
    
67. }

复制代码

1. #include "Hello.h"
   
2. 
   
3. 
   
4. MyDeviceExt g_Registers;
   
5. 
   
6. 
   
7. /*驱动卸载函数 clean_up*/
   
8. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject)
   
9. {
   
10.     DbgPrint("[51asm] Unload! DriverObject:%p\n", DriverObject);
    
11. 
    
12.     //删除符号链接
    
13.     UNICODE_STRING ustrSymbolName;
    
14.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
    
15.     IoDeleteSymbolicLink(&ustrSymbolName);
    
16. 
    
17.     //删除设备
    
18.     if (DriverObject->DeviceObject != NULL)
    
19.         IoDeleteDevice(DriverObject->DeviceObject);
    
20. }
    
21. 
    
22. /*1.驱动入口函数*/
    
23. NTSTATUS DriverEntry(
    
24.     __in struct _DRIVER_OBJECT* DriverObject,
    
25.     __in PUNICODE_STRING  RegistryPath)
    
26. {
    
27.     DbgPrint("[51asm] Hello WDK! DriverObject:%p RegistryPath:%wZ\n",
    
28.         DriverObject, RegistryPath);
    
29. 
    
30.     //2.创建设备
    
31.     UNICODE_STRING ustrDevName;
    
32.     RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);  //等于上面的3行代码
    
33. 
    
34.     PDEVICE_OBJECT pDevObj = NULL;
    
35.     NTSTATUS Status = IoCreateDevice(DriverObject,
    
36.         0,
    
37.         &ustrDevName,
    
38.         FILE_DEVICE_UNKNOWN,  //不知道的设备类型
    
39.         FILE_DEVICE_SECURE_OPEN,
    
40.         FALSE, //独占
    
41.         &pDevObj);
    
42.     if (!NT_SUCCESS(Status)) {
    
43.         DbgPrint("[51asm] IoCreateDevice Status:%p\n", Status);
    
44.         return Status;
    
45.     }
    
46.     //设置设备的缓冲区通讯方式
    
47.     pDevObj->Flags |= DO_BUFFERED_IO; //缓冲区通讯方式
    
48.     //pDevObj->Flags |= DO_DIRECT_IO;   //直接方式
    
49. 
    
50. 
    
51.     //MS-DOS Device Names  创建符号链接
    
52.     UNICODE_STRING ustrSymbolName;
    
53.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
    
54.     Status = IoCreateSymbolicLink(&ustrSymbolName, &ustrDevName);
    
55.     if (!NT_SUCCESS(Status)) {
    
56.         DbgPrint("[51asm] IoCreateSymbolicLink Status:%p\n", Status);
    
57. 
    
58.         if (pDevObj != NULL)
    
59.             IoDeleteDevice(pDevObj);
    
60. 
    
61.         return Status;
    
62.     }
    
63.     DbgPrint("[51asm] IoCreateSymbolicLink %wZ OK\n", &ustrSymbolName);
    
64. 
    
65. 
    
66. 
    
67.     //3.注册派遣函数
    
68.     DriverObject->MajorFunction[IRP_MJ_CREATE] = &DispatchCreate;
    
69.     DriverObject->MajorFunction[IRP_MJ_CLOSE] = &DispatchClose;
    
70.     DriverObject->MajorFunction[IRP_MJ_READ] = &DispatchRead;
    
71.     DriverObject->MajorFunction[IRP_MJ_WRITE] = &DispatchWrite;
    
72.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &DispatchControl;
    
73. 
    
74. 
    
75.     //4.注册卸载函数
    
76.     DriverObject->DriverUnload = Unload;
    
77. 
    
78.     return STATUS_SUCCESS;
    
79. }
    
80. 
    
81. 
    
82. NTSTATUS DispatchCreate(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
83. {
    
84.     UNREFERENCED_PARAMETER(DeviceObject);
    
85.     UNREFERENCED_PARAMETER(Irp);
    
86.     DbgPrint("[51asm] %s\n", __FUNCTION__);
    
87. 
    
88.     //完成请求  如果没完成 3环的程序就会挂起
    
89.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
    
90.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
    
91. 
    
92.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
    
93.     IoCompleteRequest(Irp, IO_NO_INCREMENT);  
    
94. 
    
95.     return STATUS_SUCCESS;
    
96. }
    
97. 
    
98. NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
99. {
    
100.     UNREFERENCED_PARAMETER(DeviceObject);
     
101.     UNREFERENCED_PARAMETER(Irp);
     
102.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
103. 
     
104. 
     
105.     //完成请求  如果没完成 3环的程序就会挂起
     
106.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
107.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
108. 
     
109.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
110.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
111. 
     
112.     return STATUS_SUCCESS;
     
113. }
     
114. 
     
115. NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
116. {
     
117.     UNREFERENCED_PARAMETER(DeviceObject);
     
118.     UNREFERENCED_PARAMETER(Irp);
     
119.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
120. 
     
121.     //获取用户的缓冲区
     
122.     //PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
123.     PVOID pBuffer = Irp->AssociatedIrp.SystemBuffer;  //因为设置了缓冲区通讯方式,用户缓冲区数据从系统申请的缓冲区读
     
124.     //PVOID pBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);  //设置了直接通讯方式获取用户缓冲区
     
125. 
     
126.      //获取当前IRP堆栈
     
127.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
128.     ULONG nLength = pIrpStack->Parameters.Read.Length;    //就是用户参数的 缓冲大小  read表示读操作
     
129.    
     
130.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
131.     DbgPrint("[51asm] %s UserBuffer:%p pBuffer:%p nLength:%d\n", __FUNCTION__, Irp->UserBuffer, pBuffer, nLength);
     
132. 
     
133.     if (nLength > sizeof(g_Registers.nVirtualReg)) {  //判断用户缓冲区大小是否足够
     
134.         nLength = sizeof(g_Registers.nVirtualReg);
     
135.     }
     
136.         
     
137.     //拷贝信息  就等于  memcoy
     
138.     RtlCopyMemory(pBuffer,&g_Registers.nVirtualReg, nLength);  //把寄存器数据数据传入用缓冲区
     
139. 
     
140.     //完成请求  如果没完成 3环的程序就会挂起
     
141.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
142.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
143. 
     
144.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
145.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
146. 
     
147.     return STATUS_SUCCESS;
     
148. }
     
149. 
     
150. 
     
151. NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
152. {
     
153.     UNREFERENCED_PARAMETER(DeviceObject);
     
154.     UNREFERENCED_PARAMETER(Irp);
     
155.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
156. 
     
157.     //获取用户的缓冲区
     
158.     //PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
159.     PVOID pBuffer = Irp->AssociatedIrp.SystemBuffer;  //因为设置了缓冲区通讯方式,用户缓冲区数据从系统申请的缓冲区读
     
160.     //PVOID pBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);  //设置了直接通讯方式获取用户缓冲区
     
161.    
     
162.      //获取当前IRP堆栈
     
163.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
164.     ULONG nLength = pIrpStack->Parameters.Write.Length;    //就是用户参数的 缓冲大小  Write表示写操作
     
165.    
     
166.    
     
167.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
168.     DbgPrint("[51asm] %s UserBuffer:%p pBuffer:%p nLength:%d\n",__FUNCTION__, Irp->UserBuffer, pBuffer, nLength);
     
169. 
     
170.     if (nLength > sizeof(g_Registers.nVirtualReg)) {
     
171.         nLength = sizeof(g_Registers.nVirtualReg);
     
172.     }
     
173.       
     
174.     RtlCopyMemory(&g_Registers.nVirtualReg, pBuffer, nLength);  //将用户数据拷贝进内核的缓冲区
     
175. 
     
176. 
     
177.     //完成请求  如果没完成 3环的程序就会挂起
     
178.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
179.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
180. 
     
181.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
182.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
183. 
     
184.     return STATUS_SUCCESS;
     
185. }
     
186. 
     
187. NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
188. {
     
189.     UNREFERENCED_PARAMETER(DeviceObject);
     
190.     UNREFERENCED_PARAMETER(Irp);
     
191.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
192. 
     
193. 
     
194.     //获取当前IRP堆栈
     
195.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
196. 
     
197. #if 0
     
198.     //获取用户的缓冲区
     
199.     PVOID pOutBuffer = Irp->UserBuffer;  //获取用户输出缓冲区
     
200.     ULONG nOutLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;   //获取用户输出缓冲区大小
     
201. 
     
202.     PVOID pInputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;  //获取用户输入缓冲区
     
203.     ULONG nInputLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;  //获取用户输入缓冲区大小
     
204. #endif // 0
     
205. 
     
206. 
     
207.     //获取用户的缓冲区
     
208.     PVOID pBuffer = Irp->AssociatedIrp.SystemBuffer;  //因为设置了缓冲区通讯方式,用户缓冲区数据从系统申请的缓冲区读
     
209.     ULONG nLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
     
210.     ULONG nIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;    //获取操作码
     
211. 
     
212. 
     
213.     DbgPrint("[51asm] %s nIoControlCode:%p pBuffer:%p nLength:%d\n", __FUNCTION__,
     
214.         nIoControlCode, pBuffer, nLength);
     
215. 
     
216. 
     
217.     ULONG nSize = 0;
     
218.     if (nLength != 4)
     
219.     {
     
220.         nLength = 4;
     
221.     }
     
222.    
     
223.     KeEnterCriticalRegion();
     
224.     switch (nIoControlCode) {
     
225.     case IOCTL_GET_REG1:
     
226.         RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg, nLength);
     
227.         nSize = nLength;
     
228. 
     
229.         DbgPrint("[51asm] %s IOCTL_GET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
     
230.         break;
     
231.     case IOCTL_GET_REG2:
     
232.         RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg2, nLength);
     
233.         nSize = nLength;
     
234. 
     
235.         DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
     
236.         break;
     
237.     case IOCTL_GET_REG3:
     
238.         RtlCopyMemory(pBuffer, &g_Registers.nVirtualReg3, nLength);
     
239.         nSize = nLength;
     
240. 
     
241.         DbgPrint("[51asm] %s IOCTL_GET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
     
242.         break;
     
243.     case IOCTL_SET_REG1:
     
244.         RtlCopyMemory(&g_Registers.nVirtualReg, pBuffer, nLength);
     
245.         nSize = nLength;
     
246. 
     
247.         DbgPrint("[51asm] %s IOCTL_SET_REG1 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg);
     
248.         break;
     
249.     case IOCTL_SET_REG2:
     
250.         RtlCopyMemory(&g_Registers.nVirtualReg2, pBuffer, nLength);
     
251.         nSize = nLength;
     
252. 
     
253.         DbgPrint("[51asm] %s IOCTL_SET_REG2 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg2);
     
254.         break;
     
255.     case IOCTL_SET_REG3:
     
256.         RtlCopyMemory(&g_Registers.nVirtualReg3, pBuffer, nLength);
     
257.         nSize = nLength;
     
258. 
     
259.         DbgPrint("[51asm] %s IOCTL_SET_REG3 value:%d\n", __FUNCTION__, g_Registers.nVirtualReg3);
     
260.         break;
     
261.     }
     
262.     KeLeaveCriticalRegion();
     
263. 
     
264.     Irp->IoStatus.Status = STATUS_SUCCESS;
     
265.     Irp->IoStatus.Information = nSize;
     
266.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
267. 
     
268.     return STATUS_SUCCESS;
     
269. }
     

复制代码

3环程序

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. #include <stdlib.h>
   
4. #include <winioctl.h>
   
5. 
   
6. struct MyDeviceExt {
   
7.     int nVirtualReg;
   
8.     int nVirtualReg2;
   
9.     int nVirtualReg3;
   
10. };
    
11. 
    
12. //定义控制码
    
13. #define MY_CODE_BASE 0x800
    
14. #define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN, MY_CODE_BASE + code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
15. #define IOCTL_GET_REG1 MY_CTL_CODE(0)
    
16. #define IOCTL_GET_REG2 MY_CTL_CODE(1)
    
17. #define IOCTL_GET_REG3 MY_CTL_CODE(2)
    
18. #define IOCTL_SET_REG1 MY_CTL_CODE(3)
    
19. #define IOCTL_SET_REG2 MY_CTL_CODE(4)
    
20. #define IOCTL_SET_REG3 MY_CTL_CODE(5)
    
21. 
    
22. 
    
23. void DisplayErrorText()
    
24. {
    
25.     LPVOID lpMsgBuf;
    
26.     FormatMessage(
    
27.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
    
28.         FORMAT_MESSAGE_FROM_SYSTEM |
    
29.         FORMAT_MESSAGE_IGNORE_INSERTS,
    
30.         NULL,
    
31.         GetLastError(),
    
32.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    
33.         (LPTSTR)&lpMsgBuf,
    
34.         0,
    
35.         NULL
    
36.     );
    
37. 
    
38.     printf((LPCTSTR)lpMsgBuf);
    
39. 
    
40.     // Free the buffer.
    
41.     LocalFree(lpMsgBuf);
    
42. }
    
43. 
    
44. int main()
    
45. {
    
46.     HANDLE hFile = CreateFile("\\\\?\\CR42VirtualRegister",
    
47.         GENERIC_ALL,
    
48.         0,
    
49.         NULL,
    
50.         OPEN_EXISTING,
    
51.         FILE_ATTRIBUTE_NORMAL,
    
52.         NULL);
    
53.     if (hFile == INVALID_HANDLE_VALUE)
    
54.     {
    
55.         DisplayErrorText();
    
56.     }
    
57.     else {
    
58.         printf("hFile = %p\n", hFile);
    
59.     }
    
60. 
    
61.     MyDeviceExt DevExt = { 0 };
    
62.     DWORD dwBytes = 0;
    
63.     DevExt.nVirtualReg = 100;
    
64.     if (!WriteFile(hFile, &DevExt, 10000, &dwBytes, NULL))
    
65.     {
    
66.         DisplayErrorText();
    
67.     }
    
68.     else
    
69.     {
    
70.         printf("WriteFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
71.     }
    
72. 
    
73.     DevExt.nVirtualReg = 2;
    
74.     if (!ReadFile(hFile, &DevExt, sizeof(DevExt), &dwBytes, NULL))
    
75.     {
    
76.         DisplayErrorText();
    
77.     }
    
78.     else
    
79.     {
    
80.         printf("ReadFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
81.     }
    
82.     int nReg = 123;
    
83.     DeviceIoControl(hFile, IOCTL_SET_REG1, &nReg, sizeof(nReg), NULL, 0, &dwBytes, NULL);
    
84.     printf("DeviceIoControl dwBytes = %d  nReg:%d\n", dwBytes, nReg);
    
85. 
    
86.     nReg = 0;
    
87.     DeviceIoControl(hFile, IOCTL_GET_REG1, NULL, 0, &nReg, sizeof(nReg), &dwBytes, NULL);
    
88.     printf("DeviceIoControl dwBytes = %d  nReg:%d\n", dwBytes, nReg);
    
89. 
    
90.     CloseHandle(hFile);
    
91. 
    
92.     system("pause");
    
93.     return 0;
    
94. }

复制代码