WindowsX86内核02.驱动程序

admin

把昨天的程序改用 c++ 编译，改成 .cpp ，发现编译报错

原因是名称粉碎，因此可以直接 extern “C”声明一下这个函数 或者用 头文件（推荐）

因为 在头文件中 可以把 头文件一起包含进去

1. #pragma once
   
2. extern "C" {
   
3. #include <Ntddk.h>
   
4. 
   
5. /*驱动入口函数*/
   
6. NTSTATUS DriverEntry(__in struct _DRIVER_OBJECT* DriverObject,
   
7.         __in PUNICODE_STRING  RegistryPath);
   
8. 
   
9. /*驱动卸载函数*/
   
10. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
    
11. 
    
12. }

复制代码

api

在驱动编程里面也可以面向对象编程，可以用class ，但是有很多功能是禁止的 ，例如 try catch 这是3环的机制，内核处理的方法不一样， malloc ， printf ，scanf，new 等 基本的库函数 和 3环 的 api都不行 因为 内核有一套独立的内核空间，必须用微软提供的独立的内核api去申请 .操作系统会提供一套独立的 内核专用的 内核 api

Reference 里面就是所有的api

WDM（NT）驱动框架

我们前面写的算一个一个驱动程序 （有打印功能），但不具备交互性，即不能跟驱动沟通

那么怎么让驱动具备交互性呢（跟3环程序作交互）

内核驱动一般不做界面功能，有3环程序来做，因为内核不能中出bug

因此 内核驱动开发有一个原则，驱动里面3环能解决的问题就在3环解决，驱动里面只做内核才能做的事

• 想要跟3环做交互，那就要按操作系统的设计来做这个框架
• 如果不需要跟3环程序交互，可能不需要 按 操作系统的设计来
• 卸载函数必须有，不然装上了就无法卸载 （因为有些驱动可能是系统一定要用的，防止被误卸载了）如果是开机启动，重启也无法卸载，除非进安全模式
  

步骤

• 实现驱动入口函数 DriverEntry
• 创建设备
• 注册派函数
• 注册卸载函数 Unload
  

系统 =》 驱动接口 =》 硬件

因为将来的硬件我们也知道有什么，所以驱动接口必须支持现在的硬件，还要支持将来的硬件，因此驱动接口的设计就十分重要，必须抽象

驱动接口 => 抽象 =》 硬件共同的特点 => 文件

应用程序 =》 文件API => 系统 => 驱动操作接口(open read write close) Dispatch Routines =》 硬件

写驱动就是想操作系统提供 open read write close 的接口，就是文件指针，这些函数就是派遣函数

设备对象 DEVICE_OBJECT 存放 open read write close 的接口

绑定

驱动对象 DRIVER_OBJECT 虚拟出来的，当操作系统加载驱动的时候，就会创建一个驱动对象来描述加载的驱动的所有信息 DriverObject

3环程序只需要 操作设备对象 ，设备对象自然会跟驱动对象绑定

实现实现驱动入口函数 DriverEntry

1. /*驱动入口函数*/
   
2. NTSTATUS DriverEntry(
   
3.     __in struct _DRIVER_OBJECT* DriverObject,
   
4.     __in PUNICODE_STRING  RegistryPath)
   
5. {
   
6. 
   
7.     return STATUS_SUCCESS;
   
8. }

复制代码

添加设备

操作系统会提供内核API 实现王操作系统添加一个设备

ms-help://MS.WDK.v10.7600.091201/Kernel_r/hh/Kernel_r/k104_1e38a631-7e65-4b4b-8d51-3150a8073511.xml.htm

最常用的就是 IoCreateDevice

参数：

• 驱动对象 (一个驱动可以创建多个设备对象，他就会挂链表)
• 设备口拓展大小 （驱动对象结构体有一个空指针成员，可以用来存放用户申请的地址，对结构体进行拓展，用来取代全局变量），一般定义一个结构体，也可以不用
• 设备名字 （在内核中基本不用 3环的字符串格式char* 即不是'\0'结尾的字符串，而是用 UNICODE_STRING 结构体），名字有要求 前面必须要有 \Device\ 。而且必须唯一，不可以与其他设备相同
• 设备种类，不能为NULL
• 是否独占 一般是false true表示独占：该软件使用时，其他软件无法使用
• 返回的设备对象
  

不用char* 是因容易字符串一处造成漏洞

内核中有些库函数还是可以用的 如： strlen strcpy但不推荐，因为不是 "\0" 结尾

windows整个操作系统是由C语言 + 汇编写的，但他整个设计用的是面向对象的思想的

内核里面基本返回值统一，这样调 api 可以统一检查 ，通过宏 NT_SUCCESS 检查

驱动卸载下次在安装将创建不了，因为名称被占用了，因此需要在upload 中 删除对象设备

1. #define DEVICE_NAME  L"\\Device\\CR42"
   
2. 
   
3. UNICODE_STRING ustrDevName;
   
4.   //ustrDevName.Length = 8;
   
5.   //ustrDevName.MaximumLength = 10;
   
6.   //ustrDevName.Buffer = L"CR42";
   
7.   RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);  //该函数就是实现上面3 行代码
   
8. 
   
9.   PDEVICE_OBJECT pDevObj = NULL;
   
10.   NTSTATUS Status = IoCreateDevice(DriverObject,
    
11.                                    sizeof(MyDeviceExt),
    
12.                                   &ustrDevName,
    
13.                                   FILE_DEVICE_UNKNOWN,  //不知道的设备类型
    
14.                                   FILE_DEVICE_SECURE_OPEN,
    
15.                                   FALSE, //独占
    
16.                                   &pDevObj);
    
17.   if (!NT_SUCCESS(Status)) {    //检查错误
    
18.     DbgPrint("[51asm] IoCreateDevice Status:%p\n", Status);
    
19.     return Status;     //失败返回 状态码
    
20.   }
    

复制代码

注册派遣函数

驱动对象最后一项是一个函数指针数组，我们驱动有什么功能就填什么功能，而且通过宏说明了每个下标分别放什么功能

一般对一内核驱动来说 必须提供 打开 关闭 控制 3个功能

这些函数就是派遣函数，也可以称回调函数

1. NTSTATUS DispatchCreate(
   
2.   _In_ struct _DEVICE_OBJECT* DeviceObject,
   
3.   _Inout_ struct _IRP* Irp
   
4. );
   
5. 
   
6. NTSTATUS DispatchClose(
   
7.   _In_ struct _DEVICE_OBJECT* DeviceObject,
   
8.   _Inout_ struct _IRP* Irp
   
9. );
   
10. 
    
11. NTSTATUS DispatchRead(
    
12.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
13.   _Inout_ struct _IRP* Irp
    
14. );
    
15. 
    
16. NTSTATUS DispatchWrite(
    
17.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
18.   _Inout_ struct _IRP* Irp
    
19. );
    
20. 
    
21. NTSTATUS DispatchControl(
    
22.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
23.   _Inout_ struct _IRP* Irp
    
24. );
    
25. 
    
26. 
    
27. 
    
28. /*
    
29. IRP  I/O Request Packet
    
30. */
    
31. NTSTATUS DispatchCreate(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
32. {
    
33.   //表示参数暂时不用，不说明一下的话参数没用没报错  
    
34.   UNREFERENCED_PARAMETER(DeviceObject);
    
35.   UNREFERENCED_PARAMETER(Irp);
    
36. 
    
37.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
38. 
    
39.   return STATUS_SUCCESS;
    
40. }
    
41. 
    
42. NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
43. {
    
44.   //表示参数暂时不用，不说明一下的话参数没用没报错  
    
45.   UNREFERENCED_PARAMETER(DeviceObject);
    
46.   UNREFERENCED_PARAMETER(Irp);
    
47.    
    
48.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
49. 
    
50.   return STATUS_SUCCESS;
    
51. }
    
52. 
    
53. NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
54. {
    
55.   //表示参数暂时不用，不说明一下的话参数没用没报错   
    
56.   UNREFERENCED_PARAMETER(DeviceObject);
    
57.   UNREFERENCED_PARAMETER(Irp);
    
58.    
    
59.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
60. 
    
61.   return STATUS_SUCCESS;
    
62. }
    
63. 
    
64. 
    
65. NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
66. {
    
67.   //表示参数暂时不用，不说明一下的话参数没用没报错   
    
68.   UNREFERENCED_PARAMETER(DeviceObject);
    
69.   UNREFERENCED_PARAMETER(Irp);
    
70.    
    
71.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
72. 
    
73.   return STATUS_SUCCESS;
    
74. }
    
75. 
    
76. NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
77. {
    
78.   //表示参数暂时不用，不说明一下的话参数没用没报错   
    
79.   UNREFERENCED_PARAMETER(DeviceObject);
    
80.   UNREFERENCED_PARAMETER(Irp);
    
81.    
    
82.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
83. 
    
84.   return STATUS_SUCCESS;
    
85. }
    
86. 
    
87. 
    
88. //3.注册派遣函数
    
89. DriverObject->MajorFunction[IRP_MJ_CREATE] = &DispatchCreate;     //打开
    
90. DriverObject->MajorFunction[IRP_MJ_CLOSE] = &DispatchClose;       //关闭
    
91. DriverObject->MajorFunction[IRP_MJ_READ] = &DispatchRead;         //读
    
92. DriverObject->MajorFunction[IRP_MJ_WRITE] = &DispatchWrite;       //写
    
93. DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &DispatchControl;  //控制

复制代码

注册卸载函数VOID Unload(__in struct _DRIVER_OBJECT* DriverObject){  DbgPrint("[51asm] Unload! DriverObject:%p\n", DriverObject);  //删除设备  if (DriverObject->DeviceObject != NULL)    IoDeleteDevice(DriverObject->DeviceObject);}

简单框架完成

Hello.h

1. #pragma once
   
2. 
   
3. extern "C" {
   
4. 
   
5. #include <Ntddk.h>
   
6. 
   
7. struct MyDeviceExt {
   
8.   int nVirtualReg;
   
9. };
   
10. 
    
11. #define DEVICE_NAME  L"\\Device\\CR42"
    
12. #define SYMBOL_NAME L"\\DosDevices\\CR42Virtual"
    
13. 
    
14.   /*驱动入口函数*/
    
15. NTSTATUS DriverEntry(__in struct _DRIVER_OBJECT* DriverObject,
    
16.   __in PUNICODE_STRING  RegistryPath);
    
17. 
    
18. 
    
19. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
    
20. 
    
21. NTSTATUS DispatchCreate(
    
22.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
23.   _Inout_ struct _IRP* Irp
    
24. );
    
25. 
    
26. NTSTATUS DispatchClose(
    
27.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
28.   _Inout_ struct _IRP* Irp
    
29. );
    
30. 
    
31. NTSTATUS DispatchRead(
    
32.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
33.   _Inout_ struct _IRP* Irp
    
34. );
    
35. 
    
36. NTSTATUS DispatchWrite(
    
37.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
38.   _Inout_ struct _IRP* Irp
    
39. );
    
40. 
    
41. NTSTATUS DispatchControl(
    
42.   _In_ struct _DEVICE_OBJECT* DeviceObject,
    
43.   _Inout_ struct _IRP* Irp
    
44. );
    
45. 
    
46. }

复制代码

Hello.cpp

1. #include "Hello.h"
   
2. 
   
3. 
   
4. 
   
5. /*驱动卸载函数 clean_up*/
   
6. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject)
   
7. {
   
8.   DbgPrint("[51asm] Unload! DriverObject:%p\n", DriverObject);
   
9. 
   
10.   //删除设备
    
11.   if (DriverObject->DeviceObject != NULL)
    
12.     IoDeleteDevice(DriverObject->DeviceObject);
    
13. }
    
14. 
    
15. /*1.驱动入口函数*/
    
16. NTSTATUS DriverEntry(
    
17.   __in struct _DRIVER_OBJECT* DriverObject,
    
18.   __in PUNICODE_STRING  RegistryPath)
    
19. {
    
20.   DbgPrint("[51asm] Hello WDK! DriverObject:%p RegistryPath:%wZ\n",
    
21.             DriverObject, RegistryPath);
    
22. 
    
23.   //2.创建设备
    
24.   UNICODE_STRING ustrDevName;
    
25.   //ustrDevName.Length = 8;
    
26.   //ustrDevName.MaximumLength = 10;
    
27.   //ustrDevName.Buffer = L"CR42";
    
28.   RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);
    
29. 
    
30.   PDEVICE_OBJECT pDevObj = NULL;
    
31.   NTSTATUS Status = IoCreateDevice(DriverObject,
    
32.                                    sizeof(MyDeviceExt),
    
33.                                   &ustrDevName,
    
34.                                   FILE_DEVICE_UNKNOWN,  //不知道的设备类型
    
35.                                   FILE_DEVICE_SECURE_OPEN,
    
36.                                   FALSE, //独占
    
37.                                   &pDevObj);
    
38.   if (!NT_SUCCESS(Status)) {
    
39.     DbgPrint("[51asm] IoCreateDevice Status:%p\n", Status);
    
40.     return Status;
    
41.   }
    
42. 
    
43.   //3.注册派遣函数
    
44.   DriverObject->MajorFunction[IRP_MJ_CREATE] = &DispatchCreate;
    
45.   DriverObject->MajorFunction[IRP_MJ_CLOSE] = &DispatchClose;
    
46.   DriverObject->MajorFunction[IRP_MJ_READ] = &DispatchRead;
    
47.   DriverObject->MajorFunction[IRP_MJ_WRITE] = &DispatchWrite;
    
48.   DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &DispatchControl;
    
49. 
    
50. 
    
51.   //4.注册卸载函数
    
52.   DriverObject->DriverUnload = Unload;
    
53. 
    
54.   return STATUS_SUCCESS;
    
55. }
    
56. 
    
57. /*
    
58. IRP  I/O Request Packet
    
59. */
    
60. NTSTATUS DispatchCreate(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
61. {
    
62.   UNREFERENCED_PARAMETER(DeviceObject);
    
63.   UNREFERENCED_PARAMETER(Irp);
    
64. 
    
65.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
66. 
    
67. 
    
68.   return STATUS_SUCCESS;
    
69. }
    
70. 
    
71. NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
72. {
    
73.   UNREFERENCED_PARAMETER(DeviceObject);
    
74.   UNREFERENCED_PARAMETER(Irp);
    
75.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
76. 
    
77.   return STATUS_SUCCESS;
    
78. }
    
79. 
    
80. NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
81. {
    
82.   UNREFERENCED_PARAMETER(DeviceObject);
    
83.   UNREFERENCED_PARAMETER(Irp);
    
84.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
85. 
    
86.   return STATUS_SUCCESS;
    
87. }
    
88. 
    
89. 
    
90. NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
91. {
    
92.   UNREFERENCED_PARAMETER(DeviceObject);
    
93.   UNREFERENCED_PARAMETER(Irp);
    
94.   DbgPrint("[51asm] %s\n", __FUNCTION__);
    
95. 
    
96. 
    
97.   return STATUS_SUCCESS;
    
98. }
    
99. 
    
100. NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
101. {
     
102.   UNREFERENCED_PARAMETER(DeviceObject);
     
103.   UNREFERENCED_PARAMETER(Irp);
     
104.   DbgPrint("[51asm] %s\n", __FUNCTION__);
     
105. 
     
106. 
     
107.   return STATUS_SUCCESS;
     
108. }
     

复制代码

当设备被打开时，就会找到 DispatchCreate 函数并进行调用 里面一般都是通过 内联汇编代码 跟硬件进行交互

3环程序跟驱动进行通讯

CreateFile() ReadFile() WriteFile() CloseHandle() DeviceIoControl()

分别会对应调到上面的四个函数

DispatchCreate() DispatchRead() DispatchWrite() DispatchClose() DispatchControl()

实现虚拟硬件

因为要在要xp上运行，所以编译成静态库 ，

然后再 PE中 把 MajorSubsystemVersion 项 改成 4 就可以了

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. #include <stdlib.h>
   
4. 
   
5. struct MyDeviceExt {
   
6.     int nVirtualReg;
   
7. };
   
8. 
   
9. //显示错误信息  FormatMessage
   
10. void DisplayErrorText()
    
11. {
    
12.     LPVOID lpMsgBuf;
    
13.     FormatMessage(
    
14.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
    
15.         FORMAT_MESSAGE_FROM_SYSTEM |
    
16.         FORMAT_MESSAGE_IGNORE_INSERTS,
    
17.         NULL,
    
18.         GetLastError(),
    
19.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    
20.         (LPTSTR)&lpMsgBuf,
    
21.         0,
    
22.         NULL
    
23.     );
    
24.     printf((LPCTSTR)lpMsgBuf);
    
25.     // Free the buffer.
    
26.     LocalFree(lpMsgBuf);
    
27. }
    
28. 
    
29. int main()
    
30. {
    
31.     HANDLE hFile = CreateFile("\\Device\\CR42",     
    
32.         GENERIC_ALL,
    
33.         0,
    
34.         NULL,
    
35.         OPEN_EXISTING,  //驱动只能打开已存在
    
36.         FILE_ATTRIBUTE_NORMAL,
    
37.         NULL);
    
38.     if (hFile == INVALID_HANDLE_VALUE)
    
39.     {
    
40.         DisplayErrorText();
    
41.     }
    
42.     else {
    
43.         printf("hFile = %p\n", hFile);
    
44.     }
    
45. 
    
46.     CloseHandle(hFile);
    
47.     system("pause");
    
48.     return 0;
    
49. }

复制代码

运行可以看到找不到路径 ，这是权限问题

每个设备有2个 名字，其中一个名字叫 NT Device Names 还有一个叫 MS-DOS Device Names

NT Device Names 只能在内核中打开 ，3环中无法打开

MS-DOS Device Names(符号链接) ， 如果要想设被3环访问，必须创建一个 符号链接，就相当于路径的一个别名。如果不想被3环访问，可以没有，而且 符号名和设备名也是唯一的，卸载的时候也要删除

#define SYMBOL_NAME L"\\DosDevices\\CR42Virtual"//MS-DOS Device Names  创建符号链接UNICODE_STRING ustrSymbolName;RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);Status = IoCreateSymbolicLink(&ustrSymbolName, &ustrDevName);if (!NT_SUCCESS(Status)) {   DbgPrint("[51asm] IoCreateSymbolicLink Status:%p\n", Status);if (pDevObj != NULL)  IoDeleteDevice(pDevObj);  return Status;}DbgPrint("[51asm] IoCreateSymbolicLink %wZ OK\n", &ustrSymbolName);//删除符号链接UNICODE_STRING ustrSymbolName;RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);IoDeleteSymbolicLink(&ustrSymbolName);

#include <stdio.h>#include <Windows.h>#include <stdlib.h>struct MyDeviceExt {    int nVirtualReg;};//显示错误信息  FormatMessagevoid DisplayErrorText(){    LPVOID lpMsgBuf;    FormatMessage(        FORMAT_MESSAGE_ALLOCATE_BUFFER |        FORMAT_MESSAGE_FROM_SYSTEM |        FORMAT_MESSAGE_IGNORE_INSERTS,        NULL,        GetLastError(),        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language        (LPTSTR)&lpMsgBuf,        0,        NULL    );    printf((LPCTSTR)lpMsgBuf);    // Free the buffer.    LocalFree(lpMsgBuf);}int main(){    HANDLE hFile = CreateFile("\\\\?\\CR42VirtualRegister",   // ？= DosDevices        GENERIC_ALL,        0,        NULL,        OPEN_EXISTING,  //驱动只能打开已存在        FILE_ATTRIBUTE_NORMAL,        NULL);    if (hFile == INVALID_HANDLE_VALUE)    {        DisplayErrorText();    }    else {        printf("hFile = %p\n", hFile);    }    CloseHandle(hFile);    system("pause");    return 0;}

测试

这样3环程序可以指挥驱动程序干活了

完善

调用四个函数

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. #include <stdlib.h>
   
4. 
   
5. struct MyDeviceExt {
   
6.     int nVirtualReg;
   
7. };
   
8. 
   
9. void DisplayErrorText()
   
10. {
    
11.     LPVOID lpMsgBuf;
    
12.     FormatMessage(
    
13.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
    
14.         FORMAT_MESSAGE_FROM_SYSTEM |
    
15.         FORMAT_MESSAGE_IGNORE_INSERTS,
    
16.         NULL,
    
17.         GetLastError(),
    
18.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    
19.         (LPTSTR)&lpMsgBuf,
    
20.         0,
    
21.         NULL
    
22.     );
    
23. 
    
24.     printf((LPCTSTR)lpMsgBuf);
    
25.     LocalFree(lpMsgBuf);
    
26. }
    
27. 
    
28. int main()
    
29. {
    
30.     HANDLE hFile = CreateFile("\\\\?\\CR42Virtual",
    
31.         GENERIC_ALL,
    
32.         0,
    
33.         NULL,
    
34.         OPEN_EXISTING,
    
35.         FILE_ATTRIBUTE_NORMAL,
    
36.         NULL);
    
37.     if (hFile == INVALID_HANDLE_VALUE)
    
38.     {
    
39.         DisplayErrorText();
    
40.     }
    
41.     else {
    
42.         printf("hFile = %p\n", hFile);
    
43.     }
    
44. 
    
45. 
    
46.     char szBuf[100] = {0};
    
47.     DWORD dwBytes = 0;
    
48.     ReadFile(hFile, szBuf, sizeof(szBuf), &dwBytes, NULL);
    
49.     printf("ReadFile dwBytes = %d  szBuf:%s\n", dwBytes, szBuf);
    
50. 
    
51. 
    
52.     WriteFile(hFile, szBuf, sizeof(szBuf), &dwBytes, NULL);
    
53.     printf("WriteFile dwBytes = %d szBuf:%s\n", dwBytes, szBuf);
    
54. 
    
55.      //控制
    
56.     //DeviceIoControl(hFile, 100, szBuf, sizeof(szBuf), szBuf, sizeof(szBuf), &dwBytes, NULL);
    
57.    
    
58.     CloseHandle(hFile);
    
59. 
    
60.     system("pause");
    
61.     return 0;
    
62. }

复制代码

实现驱动模拟寄存器驱动程序

用一个变量来当作寄存器保存值 ，如果要读寄存器的值，把返变量的值 ，如果要写寄存器的值，就修改变量的值

实现的难点就是参数的传递 ， 内核如何收到3环的数据

3环如果调用WriteFile函数 和 ReadFile 函数时 ，就会把对应的信息打包成一个 Irp 结构体传递给 内核

IRP I/O Request Packet 读写请求包

我们必须完成这个请求，如果不完成请求，函数可能会卡死在那

例如网卡驱动。假如有人发起读请求，读取从别的电脑发送过来的网络数据，这时候给不了，因为没数据发过来，那这个时候要把请求挂起来，也要把线程挂起来，直到收到数据包为止

1. #pragma once
   
2. 
   
3. extern "C" {
   
4. 
   
5. #include <Ntddk.h>
   
6. 
   
7.     struct MyDeviceExt {
   
8.         int nVirtualReg;   //用来当作寄存器的值
   
9.     };
   
10. 
    
11. #define DEVICE_NAME  L"\\Device\\CR42"
    
12. #define SYMBOL_NAME L"\\DosDevices\\CR42VirtualRegister"
    
13. 
    
14.     /*驱动入口函数*/
    
15.     NTSTATUS DriverEntry(__in struct _DRIVER_OBJECT* DriverObject,
    
16.         __in PUNICODE_STRING  RegistryPath);
    
17. 
    
18. 
    
19.     VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
    
20. 
    
21.     NTSTATUS DispatchCreate(
    
22.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
23.         _Inout_ struct _IRP* Irp
    
24.     );
    
25. 
    
26.     NTSTATUS DispatchClose(
    
27.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
28.         _Inout_ struct _IRP* Irp
    
29.     );
    
30. 
    
31.     NTSTATUS DispatchRead(
    
32.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
33.         _Inout_ struct _IRP* Irp
    
34.     );
    
35. 
    
36.     NTSTATUS DispatchWrite(
    
37.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
38.         _Inout_ struct _IRP* Irp
    
39.     );
    
40. 
    
41.     NTSTATUS DispatchControl(
    
42.         _In_ struct _DEVICE_OBJECT* DeviceObject,
    
43.         _Inout_ struct _IRP* Irp
    
44.     );
    
45. 
    
46. }

复制代码

1. #include "Hello.h"
   
2. 
   
3. 
   
4. /*驱动卸载函数 clean_up*/
   
5. VOID Unload(__in struct _DRIVER_OBJECT* DriverObject)
   
6. {
   
7.     DbgPrint("[51asm] Unload! DriverObject:%p\n", DriverObject);
   
8. 
   
9.     //删除符号链接
   
10.     UNICODE_STRING ustrSymbolName;
    
11.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
    
12.     IoDeleteSymbolicLink(&ustrSymbolName);
    
13. 
    
14.     //删除设备
    
15.     if (DriverObject->DeviceObject != NULL)
    
16.         IoDeleteDevice(DriverObject->DeviceObject);
    
17. }
    
18. 
    
19. /*1.驱动入口函数*/
    
20. NTSTATUS DriverEntry(
    
21.     __in struct _DRIVER_OBJECT* DriverObject,
    
22.     __in PUNICODE_STRING  RegistryPath)
    
23. {
    
24.     DbgPrint("[51asm] Hello WDK! DriverObject:%p RegistryPath:%wZ\n",
    
25.         DriverObject, RegistryPath);
    
26. 
    
27.     //2.创建设备
    
28.     UNICODE_STRING ustrDevName;
    
29.     //ustrDevName.Length = 8;
    
30.     //ustrDevName.MaximumLength = 10;
    
31.     //ustrDevName.Buffer = L"CR42";
    
32.     RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);  //等于上面的3行代码
    
33. 
    
34. 
    
35. 
    
36.     PDEVICE_OBJECT pDevObj = NULL;
    
37.     NTSTATUS Status = IoCreateDevice(DriverObject,
    
38.         sizeof(MyDeviceExt),
    
39.         &ustrDevName,
    
40.         FILE_DEVICE_UNKNOWN,  //不知道的设备类型
    
41.         FILE_DEVICE_SECURE_OPEN,
    
42.         FALSE, //独占
    
43.         &pDevObj);
    
44.     if (!NT_SUCCESS(Status)) {
    
45.         DbgPrint("[51asm] IoCreateDevice Status:%p\n", Status);
    
46.         return Status;
    
47.     }
    
48. 
    
49.     //初始化寄存器变量
    
50.     RtlZeroMemory(pDevObj->DeviceExtension, sizeof(MyDeviceExt));
    
51.     MyDeviceExt* pDevExt = (MyDeviceExt*)pDevObj->DeviceExtension;
    
52.     pDevExt->nVirtualReg = 0;
    
53. 
    
54.     //MS-DOS Device Names  创建符号链接
    
55.     UNICODE_STRING ustrSymbolName;
    
56.     RtlInitUnicodeString(&ustrSymbolName, SYMBOL_NAME);
    
57.     Status = IoCreateSymbolicLink(&ustrSymbolName, &ustrDevName);
    
58.     if (!NT_SUCCESS(Status)) {
    
59.         DbgPrint("[51asm] IoCreateSymbolicLink Status:%p\n", Status);
    
60. 
    
61.         if (pDevObj != NULL)
    
62.             IoDeleteDevice(pDevObj);
    
63. 
    
64.         return Status;
    
65.     }
    
66.     DbgPrint("[51asm] IoCreateSymbolicLink %wZ OK\n", &ustrSymbolName);
    
67. 
    
68. 
    
69. 
    
70.     //3.注册派遣函数
    
71.     DriverObject->MajorFunction[IRP_MJ_CREATE] = &DispatchCreate;
    
72.     DriverObject->MajorFunction[IRP_MJ_CLOSE] = &DispatchClose;
    
73.     DriverObject->MajorFunction[IRP_MJ_READ] = &DispatchRead;
    
74.     DriverObject->MajorFunction[IRP_MJ_WRITE] = &DispatchWrite;
    
75.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &DispatchControl;
    
76. 
    
77. 
    
78.     //4.注册卸载函数
    
79.     DriverObject->DriverUnload = Unload;
    
80. 
    
81.     return STATUS_SUCCESS;
    
82. }
    
83. 
    
84. 
    
85. NTSTATUS DispatchCreate(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
    
86. {
    
87.     UNREFERENCED_PARAMETER(DeviceObject);
    
88.     UNREFERENCED_PARAMETER(Irp);
    
89.     DbgPrint("[51asm] %s\n", __FUNCTION__);
    
90. 
    
91.     //完成请求  如果没完成 3环的程序就会挂起
    
92.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
    
93.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
    
94. 
    
95.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
    
96.     IoCompleteRequest(Irp, IO_NO_INCREMENT);  
    
97. 
    
98.     return STATUS_SUCCESS;
    
99. }
    
100. 
     
101. NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
102. {
     
103.     UNREFERENCED_PARAMETER(DeviceObject);
     
104.     UNREFERENCED_PARAMETER(Irp);
     
105.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
106. 
     
107. 
     
108.     //完成请求  如果没完成 3环的程序就会挂起
     
109.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
110.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
111. 
     
112.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
113.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
114. 
     
115.     return STATUS_SUCCESS;
     
116. }
     
117. 
     
118. NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
119. {
     
120.     UNREFERENCED_PARAMETER(DeviceObject);
     
121.     UNREFERENCED_PARAMETER(Irp);
     
122.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
123. 
     
124.    
     
125. 
     
126.     //获取用户的缓冲区
     
127.     PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
128. 
     
129.      //获取当前IRP堆栈
     
130.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
131.     ULONG nLength = pIrpStack->Parameters.Read.Length;    //就是用户参数的 缓冲大小  read表示读操作
     
132.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
133. 
     
134. 
     
135.     MyDeviceExt* pDevExt = (MyDeviceExt*)DeviceObject->DeviceExtension;
     
136.     if (nLength > sizeof(pDevExt->nVirtualReg)) {  //检查缓冲区大小，防溢出
     
137.         nLength = sizeof(pDevExt->nVirtualReg);
     
138.     }
     
139.         
     
140.     //拷贝信息  就等于  memcoy
     
141.     RtlCopyMemory(pBuffer, &pDevExt->nVirtualReg, nLength);  //把寄存器数据数据传入用缓冲区
     
142. 
     
143. 
     
144.     //完成请求  如果没完成 3环的程序就会挂起
     
145.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
146.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
147. 
     
148.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
149.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
150. 
     
151.     return STATUS_SUCCESS;
     
152. }
     
153. 
     
154. 
     
155. NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
156. {
     
157.     UNREFERENCED_PARAMETER(DeviceObject);
     
158.     UNREFERENCED_PARAMETER(Irp);
     
159.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
160. 
     
161.      //获取用户的缓冲区
     
162.     PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址
     
163. 
     
164.     //获取当前IRP堆栈
     
165.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
     
166.     ULONG nLength = pIrpStack->Parameters.Write.Length;    //就是用户参数的 缓冲大小  Write表示写操作
     
167.    
     
168.     DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);
     
169. 
     
170. 
     
171.     MyDeviceExt* pDevExt = (MyDeviceExt*)DeviceObject->DeviceExtension;
     
172.     if (nLength > sizeof(pDevExt->nVirtualReg)) {     //检查缓冲区大小，防溢出
     
173.         nLength = sizeof(pDevExt->nVirtualReg);  
     
174.     }
     
175.       
     
176.     RtlCopyMemory(&pDevExt->nVirtualReg, pBuffer, nLength);  //将用户数据拷贝进内核的缓冲区
     
177. 
     
178. 
     
179.     //完成请求  如果没完成 3环的程序就会挂起
     
180.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
181.     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
182. 
     
183.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
184.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
185. 
     
186.     return STATUS_SUCCESS;
     
187. }
     
188. 
     
189. NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
     
190. {
     
191.     UNREFERENCED_PARAMETER(DeviceObject);
     
192.     UNREFERENCED_PARAMETER(Irp);
     
193.     DbgPrint("[51asm] %s\n", __FUNCTION__);
     
194. 
     
195.     //完成请求  如果没完成 3环的程序就会挂起
     
196.     Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功
     
197.     Irp->IoStatus.Information = 0; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值
     
198. 
     
199.     //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级
     
200.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
201. 
     
202.     return STATUS_SUCCESS;
     
203. }
     

复制代码

测试程序

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. #include <stdlib.h>
   
4. 
   
5. struct MyDeviceExt {
   
6.     int nVirtualReg;
   
7. };
   
8. 
   
9. void DisplayErrorText()
   
10. {
    
11.     LPVOID lpMsgBuf;
    
12.     FormatMessage(
    
13.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
    
14.         FORMAT_MESSAGE_FROM_SYSTEM |
    
15.         FORMAT_MESSAGE_IGNORE_INSERTS,
    
16.         NULL,
    
17.         GetLastError(),
    
18.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    
19.         (LPTSTR)&lpMsgBuf,
    
20.         0,
    
21.         NULL
    
22.     );
    
23. 
    
24.     printf((LPCTSTR)lpMsgBuf);
    
25.     LocalFree(lpMsgBuf);
    
26. }
    
27. 
    
28. int main()
    
29. {
    
30.     HANDLE hFile = CreateFile("\\\\?\\CR42VirtualRegister",
    
31.         GENERIC_ALL,
    
32.         0,
    
33.         NULL,
    
34.         OPEN_EXISTING,
    
35.         FILE_ATTRIBUTE_NORMAL,
    
36.         NULL);
    
37.     if (hFile == INVALID_HANDLE_VALUE)
    
38.     {
    
39.         DisplayErrorText();
    
40.     }
    
41.     else {
    
42.         printf("hFile = %p\n", hFile);
    
43.     }
    
44. 
    
45. 
    
46.     MyDeviceExt DevExt = { 0 };
    
47.     DWORD dwBytes = 0;
    
48.     DevExt.nVirtualReg = 100;
    
49.     if (!WriteFile(hFile, &DevExt, 100, &dwBytes, NULL))  //往寄存器里面写值
    
50.     {
    
51.         DisplayErrorText();
    
52.     }
    
53.     else
    
54.     {
    
55.         printf("WriteFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
56.     }
    
57. 
    
58.     DevExt.nVirtualReg = -1;
    
59.     if (!ReadFile(hFile, &DevExt, sizeof(DevExt), &dwBytes, NULL))  //从寄存器里面读值
    
60.     {
    
61.         DisplayErrorText();
    
62.     }
    
63.     else
    
64.     {
    
65.         printf("ReadFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);
    
66.     }
    
67. 
    
68.     //控制
    
69.     //DeviceIoControl(hFile, 100, szBuf, sizeof(szBuf), szBuf, sizeof(szBuf), &dwBytes, NULL);
    
70. 
    
71.     CloseHandle(hFile);
    
72. 
    
73.     system("pause");
    
74.     return 0;
    
75. }

复制代码

测试

因为不是独占，所以多个函数可以同时调用，注意，多函数同时访问存在同步问题

漏洞

例如：

    MyDeviceExt DevExt = { 0 };    DWORD dwBytes = 0;    DevExt.nVirtualReg = 100;    if (!WriteFile(hFile, &DevExt, 10000, &dwBytes, NULL))  //往寄存器里面写值    {        DisplayErrorText();    }    else    {        printf("WriteFile dwBytes = %d  VirtualReg:%d\n", dwBytes, DevExt.nVirtualReg);    }

NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp){    UNREFERENCED_PARAMETER(DeviceObject);    UNREFERENCED_PARAMETER(Irp);    DbgPrint("[51asm] %s\n", __FUNCTION__);    //获取用户的缓冲区    PVOID pBuffer = Irp->UserBuffer;   //就是用户参数的 缓冲地址    //获取当前IRP堆栈    PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);    ULONG nLength = pIrpStack->Parameters.Write.Length;    //就是用户参数的 缓冲大小  Write表示写操作        DbgPrint("[51asm] %s pBuffer:%p nLength:%d\n", __FUNCTION__, pBuffer, nLength);    MyDeviceExt* pDevExt = (MyDeviceExt*)DeviceObject->DeviceExtension;           RtlCopyMemory(&pDevExt->nVirtualReg, pBuffer, nLength);  //将用户数据拷贝进内核的缓冲区    //完成请求  如果没完成 3环的程序就会挂起    Irp->IoStatus.Status = STATUS_SUCCESS;   //状态，成功     Irp->IoStatus.Information = nLength; //成功操作的字节数,非读写一般是0 就算是读写文件 dwBytes的返回值    //第二个参数线程的优先级，内核一般时 IO_NO_INCREMENT 不提升优先级    IoCompleteRequest(Irp, IO_NO_INCREMENT);    return STATUS_SUCCESS;}

上面的代码会导致系统蓝屏 因为上面 3成程序 给驱动的缓冲区只有4字节 ，但是大小却指定了 10000，由于没有长度检查 ，这样 驱动去访问那 10000 个字节 就会 c005 ，

RtlCopyMemory(&pDevExt->nVirtualReg, pBuffer, nLength); 中 nLength 大小由3环程序控制

由于是往内核写数据，因为长度出错，导致代码溢出了，因此需要对长度检查

WinObj

可以找遍历电脑上已经安装的所有设备

https://docs.microsoft.com/zh-cn/sysinternals/downloads/winobj