内核知识第五讲.驱动框架编写,以及3环和0环通信.

　　　　　　　　　内核知识第五讲.驱动框架编写,以及3环和0环通信.

一丶了解内核驱动加载方式

内核加载方式有两种方式.

1.动态加载方式.

2.静态加载方式

动态加载方式:

　　动态态加载方式则是调用3环API 进行代码加载.

详情请点击 : 内核驱动加载工具的编写.

静态加载方式

　　静态的加载方式则是利用 后缀为.inf  的文件进行加载.

有关.inf的语法,可以百度或者通过学习WDK中提供的源码例子进行学习.

动态加载一般很常用.

二丶驱动框架的介绍.

在讲解内核驱动框架的是否,我们要先了解设备是什么.  设备和驱动之间的数据关系是什么.

1.什么是驱动.什么是设备

驱动:   驱动则是用来操作设备的. 

设备:   设备则是我们常说的外设. 比如键盘.  显示器.  鼠标等等..

其中.任何一个驱动操作设备.  都应该提供公共的方法.

打开.  关闭.  读. 写. 控制....

如图: 

　　用户操作设备的是否. 这个时候会通过内核驱动.提供的 回调方法.(也就是公共的接口)进而来操作设备.

　2.驱动和设备之间的关系.

驱动和设备之间的关系是一对多的关系.

驱动可以操作很多设备.

比如我们的键盘驱动有一个. 但是可以操作的键盘则有很多个. 你键盘坏了.换了很多.但是驱动则没换过.

所以如果是数据关系的时候.   驱动作为外键放到设备表中.

例如以下:

　　

设备	驱动
A键盘	标准驱动
B键盘	标准驱动

有了数据关系.那么就可以讲解驱动框架了.

3.驱动框架的介绍.

驱动对象.设备对象.

在驱动中有这两个概念. 

驱动对象:  简单来说就是一个结构体,存储了驱动的各种信息.

设备对象: 简单来说也是一个结构体,存储的是设备的各种信息.

但依据上面的数据关系来说. 设备对象中肯定会存储驱动对象结构体的指针.  驱动对象做外键存储到设备对象中.

设备对象结构体:

typedef struct _DRIVER_OBJECT {
    CSHORT Type;　　　　　　　　　　//类型
    CSHORT Size;　　　　　　　　　　//当前结构体大小.内核中任何一个结构体都是这两个成员开头.

    //
    // The following links all of the devices created by a single driver
    // together on a list, and the Flags word provides an extensible flag
    // location for driver objects.
    //

    PDEVICE_OBJECT DeviceObject;//设备对象指针,存疑?  不是说数据关系是  设备表中有驱动对象吗. 怎么驱动对象表中有设备对象指针.???????
    ULONG Flags;　　　　　　　　　　//通讯协议以及方式.

    //
    // The following section describes where the driver is loaded.  The count
    // field is used to count the number of times the driver has had its
    // registered reinitialization routine invoked.
    //

    PVOID DriverStart;
    ULONG DriverSize;
    PVOID DriverSection;
    PDRIVER_EXTENSION DriverExtension;

    //
    // The driver name field is used by the error log thread
    // determine the name of the driver that an I/O request is/was bound.
    //

    UNICODE_STRING DriverName;

    //
    // The following section is for registry support.  Thise is a pointer
    // to the path to the hardware information in the registry
    //

    PUNICODE_STRING HardwareDatabase;

    //
    // The following section contains the optional pointer to an array of
    // alternate entry points to a driver for "fast I/O" support.  Fast I/O
    // is performed by invoking the driver routine directly with separate
    // parameters, rather than using the standard IRP call mechanism.  Note
    // that these functions may only be used for synchronous I/O, and when
    // the file is cached.
    //

    PFAST_IO_DISPATCH FastIoDispatch;

    //
    // The following section describes the entry points to this particular
    // driver.  Note that the major function dispatch table must be the last
    // field in the object so that it remains extensible.
    //

    PDRIVER_INITIALIZE DriverInit;
    PDRIVER_STARTIO DriverStartIo;
    PDRIVER_UNLOAD DriverUnload;
    PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];　　//提供的公共方法的接口. 创建.打开,关闭.读写控制... 里面存放的是函数指针.单用户操作设备的是否.则会调用这些回调函数指针.

} DRIVER_OBJECT;
typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT; 

存疑部分:

　　上面标红的部分. 不是说表关系应该是上面那种吗.?如下图所示

设备	驱动
A键盘	标准驱动
B键盘	标准驱动

可为何设计为这样.

原因:

　　我们的内核驱动可以操作设备. 但是我们要知道有多少设备怎么办. 所以这里给了一个设备对象的指针. 而不是我们说的数据关系.

而在设备对象中.存储的则是我们的驱动对象指针.

而这里的指针.则是一个链表形式的. 为了方便遍历.

例如:

　　

typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _DEVICE_OBJECT {
    CSHORT Type;
    USHORT Size;
    LONG ReferenceCount;
    struct _DRIVER_OBJECT *DriverObject;　　//驱动对象做外键存储
    struct _DEVICE_OBJECT *NextDevice;      //链表.
    struct _DEVICE_OBJECT *AttachedDevice;
    struct _IRP *CurrentIrp;
    PIO_TIMER Timer;
    ULONG Flags;                                // See above:  DO_...
    ULONG Characteristics;                      // See ntioapi:  FILE_...
    __volatile PVPB Vpb;
    PVOID DeviceExtension;
    DEVICE_TYPE DeviceType;
    CCHAR StackSize;
    union {
        LIST_ENTRY ListEntry;
        WAIT_CONTEXT_BLOCK Wcb;
    } Queue;
    ULONG AlignmentRequirement;
    KDEVICE_QUEUE DeviceQueue;
    KDPC Dpc;

    //
    //  The following field is for exclusive use by the filesystem to keep
    //  track of the number of Fsp threads currently using the device
    //

    ULONG ActiveThreadCount;
    PSECURITY_DESCRIPTOR SecurityDescriptor;
    KEVENT DeviceLock;

    USHORT SectorSize;
    USHORT Spare1;

    struct _DEVOBJ_EXTENSION  *DeviceObjectExtension;
    PVOID  Reserved;

} DEVICE_OBJECT;

typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT; 

三丶编写驱动框架.

上面我们已经简单的了解了驱动对象.设备对象是什么了.那么现在开始编写驱动框架

步骤

1.首先注册设备回调函数.当用户对设备进行操作的是否.驱动会调用这个回调函数进行操作.

2.创建设备.创建虚拟的设备给用户使用.

3.指定通讯方式. 什么意思?比如ring3中操作设备进行读写的时候 如果用ReadFile读取.那么你们的通讯方式是否是字符串

4.创建符号连接.

　　符号连接: 我们知道.在操作系统下有C盘.D盘一说.但是在驱动下面.则没有怎么一说.只有卷一说.所以我们要绑定一下.

PS: 鉴于篇幅原因.只写重点.如果想要完整的驱动框架. 请下载资料进行查看.

1.注册回调函数.

  pDriverObject->MajorFunction[IRP_MJ_CREATE] = 创建的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_CLOSE] =  关闭的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_READ] =   读取的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_WRITE] =  写入的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = 控制的回调函数指针;

回调函数的写法.

NTSTATUS 自定义的函数名(__in struct _DEVICE_OBJECT *DeviceObject,
                      __inout struct _IRP *Irp)
{
 
  .........
  return STATUS_SUCCESS;
}

2.创建虚拟设备.

创建设备等等.都属于IO操作.

IO操作创建设备的API

NTSTATUS 
  IoCreateDevice(
    IN PDRIVER_OBJECT  DriverObject,　　　　　　//调用者驱动对象的指针.一般是驱动入口的参数
    IN ULONG  DeviceExtensionSize,         　　//设备扩展大小
    IN PUNICODE_STRING  DeviceName  OPTIONAL, //设备对象名称,注意不是我们ring3下的路径.
    IN DEVICE_TYPE  DeviceType,　　　　　　　　　//我们的设备类型
    IN ULONG  DeviceCharacteristics,　　　　　　//驱动的附加信息.
    IN BOOLEAN  Exclusive,　　　　　　　　　　　　//创建的设备是否其余的可以使用,是否独占
    OUT PDEVICE_OBJECT  *DeviceObject　　      //传出参数,设备的信息.
    );

注意红点标注:

　　在内核中并没有路径一说.所以这个路径是特殊的.

UNICODE_STRING 内核中新的字符串格式.其实是一个结构体.系统提供了操作这种结构体的API

我们拼接一个路径

UNICODE_STRING  uStrDeviceName;

RtlInitUnicodeString(&uStrDeviceName,L"\Device\xxx名字即可");

注意,创建设备的时候.我们前边需要加上 Device.  这里因为是转义字符.所以加了好多\

拼接好则可以给了.

status = IoCreateDevice(pDriverObject, 
                          0, 
                          &ustrDeviceName,          //设备路径
                          FILE_DEVICE_UNKNOWN,//设备类型设置为不知道
                          FILE_DEVICE_SECURE_OPEN, 
                          FALSE,                           //是否独占
                          &pDevObj);
  if (status != STATUS_SUCCESS)
  {
    return status;
  }        

3.设置通讯方式.

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

4.创建符号连接

我们创建的符号连接.可以通过 Win0bj工具进行查看. 这个工具可以查看所有设备.但是只有0环才可以操作.

 status = IoCreateSymbolicLink(&g_ustrSymbolName, &ustrDeviceName);
  if (status != STATUS_SUCCESS)
  {
    //删除设备
    IoDeleteDevice(pDevObj);
    return status;
  }

注意符号连接名字.我们也是初始化得出的.

RtlInitUnicodeString(&g_ustrSymbolName, L"\DosDevices\xxxx名字");

完整的框架已经写完.剩下的就是 三环和0环驱动通讯. 依赖我们写的框架.

四丶三环和0环的通讯.

三环操作设备的API就是 CreateFile ReadFile.....等等.不做介绍了.

利用三环程序.操作我们的设备.从中读取内容.

HANDLE hFile = CreateFile("\\?\符号连接名称", 
             GENERIC_WRITE | GENERIC_READ, 
             0, 
             NULL, 
             OPEN_EXISTING, 
             FILE_ATTRIBUTE_NORMAL, 
             NULL);

打开我们的设备.注意文件名并不是路径.而是我们绑定的符号连接. 这里我们可以写成\?

读取内容.

char szBuf[10];
ReadFile(hFile, szBuff, sizeof(szBuff), &dwBytes, NULL)

请注意,当读取设备的是否.我们一开始注册的回调函数就会来. 这时候我们给它什么都可以了.

但是此时需要讲解一下通讯协议.

当读取的是否,回调函数会来. 然后操作系统会填写 struct _IRP 结构体.用来和我们的零环通信.

typedef struct _IRP {
  .　　　　　　　　　　　　//省略了两个成员,这两个成员一个是类型.一个是大小.
  .
  PMDL  MdlAddress;
  ULONG  Flags;
  union {
    struct _IRP  *MasterIrp;
    .
    .
    PVOID  SystemBuffer;//ring3下的缓冲区.操作系统会填写.我们给里面填写什么内容.那么ring3就读取到什么.
  } AssociatedIrp;
  .
  .
  IO_STATUS_BLOCK  IoStatus;
  KPROCESSOR_MODE  RequestorMode;
  BOOLEAN PendingReturned;
  .
  .
  BOOLEAN  Cancel;
  KIRQL  CancelIrql;
  .
  .
  PDRIVER_CANCEL  CancelRoutine;
  PVOID UserBuffer;
  union {
    struct {
    .
    .
    union {
      KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
      struct {
        PVOID  DriverContext[4];
      };
    };
    .
    .
    PETHREAD  Thread;
    .
    .
    LIST_ENTRY  ListEntry;
    .
    .
    } Overlay;
  .
  .
  } Tail;
} IRP, *PIRP;

我们有了缓冲区,但是不知道缓冲区的大小.这个是否需要通过IO函数.从当前栈中获取参数.

IoGetCurrentIrpStackLocation(pIrp)

返回当前IRP的栈.我们从返回值中获取参数即可.

操作完成之后,我们完成IRP请求即可.这个IRP请求主要是为了多线程使用.有的时候可能在读取的是否.线程就切换了.

ring0下的读取回调完整编写.

 //获取当前irp堆栈
  PIO_STACK_LOCATION pIrpStack = NULL;
  PVOID lpBuff = NULL;
  ULONG Length = 0;

  //PsGetCurrentThreadId();
  KdBreakPoint();

  __try
  {
    pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
    //check

    lpBuff = pIrp->AssociatedIrp.SystemBuffer;
    Length = pIrpStack->Parameters.Read.Length;
    
    KdPrint(("[FirstWDK] DispatchRead
"));
    
    RtlStringCbCopyA(lpBuff, Length, "Hello World!");
    //check


    pIrp->IoStatus.Status = STATUS_SUCCESS;
    pIrp->IoStatus.Information = 6;
    
    //完成Irp请求
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    //check
  }
  __except(1)
  {
  }


  return STATUS_SUCCESS;

课堂3环和0环的完整代码资料:

　　链接：https://pan.baidu.com/s/1edffGy 密码：vpo0

原创不易,转载请注明出处.