Windows驱动的IOCTL

最新推荐文章于 2024-06-20 09:42:15 发布
最新推荐文章于 2024-06-20 09:42:15 发布
阅读量3.9k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenhuan20123/article/details/78939877
版权

虽然目前，没有具体的项目，但是Direct3D学习还是会继续。其实很多东西，虽然看起来现在没多大用处，说不定将来有很大的用处。这个无法衡量，多学点，总是有好处的。后面，断断续续，会把另外的几个方向，WDDM 驱动，数据结构算法，也开始捡起来继续。现在需要的是，将知识变成体系。所以，需要大量的总结。

我们今天看一下Windows驱动中的IOCTL，IOCTL顾名思义，就是IO控制码。也就是输入输出控制码。Window驱动中大量充斥着这样的控制码。前面的文章，我们知道，所有在驱动中的流都是以IRP的形式进行的。而用来标识IRP的就是这些IOCTL码。回忆一下MSDN中的IRP的结构。

typedef struct _IRP {
    .
    .
    PMDL  MdlAddress;
    ULONG  Flags;
    union {
      struct _IRP  *MasterIrp;
       .
       .
       PVOID  SystemBuffer;
     } 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;

我们知道IRP的一些信息都是存储在IO的堆栈中的：

typedef struct _IO_STACK_LOCATION {
       UCHAR  MajorFunction;
       UCHAR  MinorFunction;
       UCHAR  Flags;
       UCHAR  Control;
        union {
              //
              // Parameters for IRP_MJ_CREATE 
              //
              struct {
                   PIO_SECURITY_CONTEXT SecurityContext;
                   ULONG Options;
                   USHORT POINTER_ALIGNMENT FileAttributes;
                   USHORT ShareAccess;
                   ULONG POINTER_ALIGNMENT EaLength;
               } Create;
              //
              // Parameters for IRP_MJ_READ 
              //
              struct {
                   ULONG Length;
                   ULONG POINTER_ALIGNMENT Key;
                   LARGE_INTEGER ByteOffset;
               } Read;
              //
              // Parameters for IRP_MJ_WRITE 
              //
              struct {
                   ULONG Length;
                   ULONG POINTER_ALIGNMENT Key;
                   LARGE_INTEGER ByteOffset;
               } Write;
              //
              // Parameters for IRP_MJ_QUERY_INFORMATION 
              //
              struct {
                   ULONG Length;
                   FILE_INFORMATION_CLASS POINTER_ALIGNMENT   
      FileInformationClass;
               } QueryFile;
              //
              // Parameters for IRP_MJ_SET_INFORMATION 
              //
              struct {
                   ULONG Length;
                   FILE_INFORMATION_CLASS POINTER_ALIGNMENT   
      FileInformationClass;
                   PFILE_OBJECT FileObject;
                   union {
                        struct {
                            BOOLEAN ReplaceIfExists;
                            BOOLEAN AdvanceOnly;
                        };
                        ULONG ClusterCount;
                        HANDLE DeleteHandle;
                         };
               } SetFile;
              //
              // Parameters for IRP_MJ_QUERY_VOLUME_INFORMATION 
              //
              struct {
                   ULONG Length;
                   FS_INFORMATION_CLASS POINTER_ALIGNMENT    
     FsInformationClass;
               } QueryVolume;
              //
              // Parameters for IRP_MJ_DEVICE_CONTROL and    
     IRP_MJ_INTERNAL_DEVICE_CONTROL 
              //
              struct {
                   ULONG OutputBufferLength;
                   ULONG POINTER_ALIGNMENT InputBufferLength;
                   ULONG POINTER_ALIGNMENT IoControlCode;
                   PVOID Type3InputBuffer;
               } DeviceIoControl;
              //
              // Nonsystem service parameters.
              //
              // Parameters for IRP_MN_MOUNT_VOLUME 
              //
              struct {
                   PVOID DoNotUse1;
                   PDEVICE_OBJECT DeviceObject;
               } MountVolume;
              //
              // Parameters for IRP_MN_VERIFY_VOLUME 
              //
              struct {
                   PVOID DoNotUse1;
                   PDEVICE_OBJECT DeviceObject;
               } VerifyVolume;
              //
              // Parameters for Scsi using IRP_MJ_INTERNAL_DEVICE_CONTROL 
              //
              struct {
                   struct _SCSI_REQUEST_BLOCK *Srb;
               } Scsi;
              //
              // Parameters for IRP_MN_QUERY_DEVICE_RELATIONS 
              //
              struct {
                   DEVICE_RELATION_TYPE Type;
               } QueryDeviceRelations;
              //
              // Parameters for IRP_MN_QUERY_INTERFACE 
              //
              struct {
                   CONST GUID *InterfaceType;
                  USHORT Size;
                   USHORT Version;
                   PINTERFACE Interface;
                   PVOID InterfaceSpecificData;
               } QueryInterface;
              //
              // Parameters for IRP_MN_QUERY_CAPABILITIES 
              //
              struct {
                   PDEVICE_CAPABILITIES Capabilities;
               } DeviceCapabilities;
              //
              // Parameters for IRP_MN_FILTER_RESOURCE_REQUIREMENTS 
              //
              struct {
                   PIO_RESOURCE_REQUIREMENTS_LIST     
    IoResourceRequirementList;
               } FilterResourceRequirements;
              //
              // Parameters for IRP_MN_READ_CONFIG and IRP_MN_WRITE_CONFIG 
              //
              struct {
                   ULONG WhichSpace;
                   PVOID Buffer;
                   ULONG Offset;
                   ULONG POINTER_ALIGNMENT Length;
               } ReadWriteConfig;
              //
              // Parameters for IRP_MN_SET_LOCK 
              //
              struct {
                   BOOLEAN Lock;
               } SetLock;
              //
              // Parameters for IRP_MN_QUERY_ID 
              //
              struct {
                   BUS_QUERY_ID_TYPE IdType;
               } QueryId;
              //
              // Parameters for IRP_MN_QUERY_DEVICE_TEXT 
              //
              struct {
                   DEVICE_TEXT_TYPE DeviceTextType;
                   LCID POINTER_ALIGNMENT LocaleId;
                } QueryDeviceText;
              //
              // Parameters for IRP_MN_DEVICE_USAGE_NOTIFICATION 
              //
              struct {
                   BOOLEAN InPath;
                    BOOLEAN Reserved[3];
                    DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT  
         Type;
               } UsageNotification;
              //
              // Parameters for IRP_MN_WAIT_WAKE 
              //
              struct {
                   SYSTEM_POWER_STATE PowerState;
              } WaitWake;
              //
              // Parameter for IRP_MN_POWER_SEQUENCE 
              //
              struct {
                   PPOWER_SEQUENCE PowerSequence;
               } PowerSequence;
              //
              // Parameters for IRP_MN_SET_POWER and IRP_MN_QUERY_POWER 
              //
              struct {
                   ULONG SystemContext;
                   POWER_STATE_TYPE POINTER_ALIGNMENT Type;
                   POWER_STATE POINTER_ALIGNMENT State;
                   POWER_ACTION POINTER_ALIGNMENT ShutdownType;
               } Power;
              //
              // Parameters for IRP_MN_START_DEVICE 
              //
              struct {
                   PCM_RESOURCE_LIST AllocatedResources;
                   PCM_RESOURCE_LIST AllocatedResourcesTranslated;
                } StartDevice;
              //
              // Parameters for WMI Minor IRPs 
              //
              struct {
                   ULONG_PTR ProviderId;
                   PVOID DataPath;
                   ULONG BufferSize;
                   PVOID Buffer;
              } WMI;
              //
              // Others - driver-specific
              //
              struct {
                   PVOID Argument1;
                   PVOID Argument2;
                   PVOID Argument3;
                   PVOID Argument4;
               } Others;
         } Parameters;
     PDEVICE_OBJECT  DeviceObject;
     PFILE_OBJECT  FileObject;
     .
     .
  } IO_STACK_LOCATION, *PIO_STACK_LOCATION;

在IO堆栈中，我们看到了大量的IOCTL。这个是在WDM中的，在WDF对其进行了封装。我们在WDF中，一般使用如下的3个函数向其他模块发送这些IRP.我认为REQUEST是WDM中的IRP和IO_STATION_LOCATION的封装。

看一下异步函数：

WdfIoTargetFormatRequestForInternalIoctl,WdfIoTargetFormatRequestForInternalIoctlOthers,WdfIoTargetFormatRequestForIoctl,WdfIoTargetFormatRequestForRead,WdfIoTargetFormatRequestForWrite，这是是异步的，后面需要设置完成例程，和真正发送请求。

再看一下同步的：
WdfIoTargetSendInternalIoctlOthersSynchronously，WdfIoTargetSendInternalIoctlSynchronously，WdfIoTargetSendIoctlSynchronously，WdfIoTargetSendReadSynchronously，WdfIoTargetSendWriteSynchronously，同步需要等待，所以可以直接发。

先看一下异步的例子：

NTSTATUS
NICSendOidRequestToTargetAsync(
    IN WDFIOTARGET  IoTarget,
    IN WDFREQUEST  Request,
    IN PFILE_OBJECT  FileObject,
    IN ULONG  IoctlControlCode,
    IN OUT PVOID  InputBuffer,
    IN ULONG  InputBufferLength,
    IN OUT PVOID  OutputBuffer,
    IN ULONG  OutputBufferLength,
    OUT PULONG  BytesReadOrWritten
    )
{
    NTSTATUS  status;
    PREQUEST_CONTEXT  reqContext;
    WDF_REQUEST_REUSE_PARAMS  params;
    WDFMEMORY  inputMem, outputMem;
    
    WDF_REQUEST_REUSE_PARAMS_INIT(
                                  &params, 
                                  WDF_REQUEST_REUSE_NO_FLAGS, 
                                  STATUS_SUCCESS
                                  );
    status = WdfRequestReuse(Request, &params);
    if (!NT_SUCCESS(status)){
        return status;
    }
    reqContext = GetRequestContext(Request);
    inputMem = outputMem = NULL;
    
    if (InputBuffer != NULL) {
        status = WdfMemoryAssignBuffer(
                                       reqContext->InputMemory,
                                       InputBuffer, 
                                       InputBufferLength
                                       );
        if (!NT_SUCCESS(status)) {
             return status;
        }
        inputMem = reqContext->InputMemory;
    }
    if (OutputBuffer != NULL) {
        status = WdfMemoryAssignBuffer(
                                       reqContext->OutputMemory,
                                       OutputBuffer, 
                                       OutputBufferLength
                                       );
        if (!NT_SUCCESS(status)) {
            return status;
        }
        outputMem = reqContext->OutputMemory;
    }
    status = WdfIoTargetFormatRequestForIoctl(
                                              IoTarget,
                                              Request,
                                              IoctlControlCode,
                                              inputMem,
                                              NULL,
                                              outputMem,
                                              NULL
                                              );
    if (!NT_SUCCESS(status)) {
        return status;
    }
    WdfRequestSetCompletionRoutine(
                                   Request,
                                   NICSendOidRequestToTargetAsyncCompletionRoutine,
                                   BytesReadOrWritten
                                   );
    if (WdfRequestSend(
                       Request,
                       IoTarget,
                       WDF_NO_SEND_OPTIONS
                       ) == FALSE) {
        status = WdfRequestGetStatus(Request);
    }
    return status;
}

再看一下同步的：

WDF_MEMORY_DESCRIPTOR  outputDescriptor;
NTSTATUS  status;
HID_COLLECTION_INFORMATION  collectionInformation;
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
                                  &outputDescriptor,
                                  (PVOID) &collectionInformation,
                                  sizeof(HID_COLLECTION_INFORMATION)
                                  );
status = WdfIoTargetSendIoctlSynchronously(
                                           hidTarget,
                                           NULL,
                                           IOCTL_HID_GET_COLLECTION_INFORMATION,
                                           NULL,
                                           &outputDescriptor,
                                           NULL,
                                           NULL
                                           )

上面是发送，我们在驱动中如何进行处理这些IOCTL了，有些IOCTL，已经被WDF封装了，直接成为了驱动对象的一些域了，比如
IRP_MN_START_DEVICE,IRP_MN_FILTER_RESOURCE_REQUIREMENTS 等。有些我们自己定义的流给应用程序的接口，我们需要在请求对象中获取。调用函数

WdfRequestGetParameters(
       IN WDFREQUEST  Request,
      OUT PWDF_REQUEST_PARAMETERS  Parameters
     );

请求对象会在队列处理函数中，以参数的形式传给你，所以，你可以得到请求的参数，以确定IOCTL，而做不同的操作。
回忆一下请求参数：

typedef struct _WDF_REQUEST_PARAMETERS {
    USHORT Size;
    UCHAR MinorFunction;
    WDF_REQUEST_TYPE Type;
    union {
        //
        // Parameters for IRP_MJ_CREATE
        //
        struct {
            PIO_SECURITY_CONTEXT SecurityContext;
            ULONG Options;
            USHORT POINTER_ALIGNMENT FileAttributes;
            USHORT ShareAccess;
            ULONG POINTER_ALIGNMENT EaLength;
        } Create;
        //
        // Parameters for IRP_MJ_READ
        //
        struct {
            size_t Length;
            ULONG POINTER_ALIGNMENT Key;
            LONGLONG DeviceOffset;
        } Read;
        //
        // Parameters for IRP_MJ_WRITE 
        //
        struct {
            size_t Length;
            ULONG POINTER_ALIGNMENT Key;
            LONGLONG DeviceOffset;
        } Write;
        //
        // Parameters for IRP_MJ_DEVICE_CONTROL and IRP_MJ_INTERNAL_DEVICE_CONTROL 
        //
        struct {
            size_t OutputBufferLength;
            size_t POINTER_ALIGNMENT InputBufferLength;
            ULONG POINTER_ALIGNMENT IoControlCode;
            PVOID Type3InputBuffer;
        } DeviceIoControl;
        struct {
            PVOID Arg1;
            PVOID  Arg2;
            ULONG POINTER_ALIGNMENT IoControlCode;
            PVOID Arg4;
        } Others;
    } Parameters;
} WDF_REQUEST_PARAMETERS, *PWDF_REQUEST_PARAMETERS;

这里，我们就可以很方便的得到控制码进行操作了。

http://blog.csdn.net/z18_28_19/article/details/8892552
转载自其博客，因为排版较乱，所以重新编辑后发到自己博客记录。

chenhuan20123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux驱动之ioctl
Stream1777的博客
03-18 737
摘要：(1)应用层函数原型和头文件(2)驱动层函数和头文件(3)驱动层和应用层对应关系(4)ioctl驱动层实现(5)参考代码内容：(1)应用层函数原型和头文件  头文件：#include <sys/ioctl.h>  函数原型： int ioctl(int d, int request, ...);  参数描述：(1) d : 文件描述符(使用open打开获得一个非负整数)。    ...
Linux设备驱动之Ioctl控制
woshigaoyuan的专栏
11-01 602
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 大部分驱动除了需要具备读写设备的能力之外，还需要具备对硬件控制的能力。 　一、在用户空间，使用ioctl系统调用来控制设备，原型如下
windows内核_Windows内核漏洞利用
weixin_39900468的博客
12-30 181
堆栈缓冲区溢出在第一部分中，我们会从HackSysExtremeVulnerableDriver中的普通堆栈缓冲区溢出开始。当堆栈上存在的缓冲区获取的数据超出其存储容量时(例如，在一个16字节缓冲区中复制20个字节，就可以是字符数组或类似对象)，其余数据将写入附近位置，从而有效覆盖或破坏堆栈。其核心思想是控制此溢出，这样我们可以覆盖堆栈上保存的返回地址，并且在执行当前(易受攻击的)函数...
win32 IOCTL学习总结
bcbobo21cn的专栏
04-15 3147
Kernel-win32的系统调用机制 毛德操 正如许多网友所言，要在Linux内核中实现Windows系统调用(或别的系统调用)，最简单的办法莫过于把 这些系统调用“搭载”在Linux系统调用上。具体又有几种不同的方法： 1． 为Linux系统调用ioctl()增加一些“命令码”，每个新的命令码都代表着一个Windows系统调用。 2． 为Linux增加一个新的系统调用、例如w
【深度探索】IOCTLDump：透视Windows驱动交互的神器
最新发布
gitblog_00017的博客
06-20 359
【深度探索】IOCTLDump：透视Windows驱动交互的神器 项目地址:https://gitcode.com/Signal-Labs/IOCTLDump 项目介绍 在错综复杂的系统底层世界里，每一处IOCTL（Input/Output Control）调用都承载着设备驱动与操作系统之间的秘密对话。而IOCTLDump，正如其名，是一个用于挂钩和转储其他设备驱动程序IOCTL操作的强大内核级工...
ioctl函数
codeingdog的专栏
10-14 664
ioctl用于向设备发控制和配置命令，这些命令数据不能用read/write读写的，称为Out-of-band数据。也就是说，read/write读写的数据是in-band数据，是I/O操作的主体，而ioctl命令传送的是控制信息，其中的数据是辅助的数据。例如，在串口线上收发数据通过read/write操作，而串口的波特率、校验位、停止位通过ioctl设置；A/D转换的结果通过read读取，而A/
内核层和用户层通讯的三种方式
weixin_30954607的博客
08-30 472
内核层#include <ntddk.h>​#define CTRL_CODE1 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_IN_DIRECT, FILE_ANY_ACCESS)#define CTRL_CODE2 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE...
IO_STACK_LOCATION
二月麦苗的专栏
07-16 835
IO_STACK_LOCATION The IO_STACK_LOCATION structure defines an I/O stack location, which is an entry in the I/O stack that is associated with each IRP. Each I/O stack location in an IRP has some co
Windows WDM驱动开发
10-27
- **安装Visual C++**：Visual C++是编写Windows驱动程序的常用开发工具。 - **配置环境变量**：需要在系统环境中设置必要的路径，以便于访问DDK（Driver Development Kit）的头文件和库文件。 - **编译过程**：配置...
IOCTL 助手（Windows驱动开发工具）
08-12
标题中的"IOCTL 助手"是指一个专用于Windows驱动开发的工具，它主要帮助开发者处理与I/O控制代码（Input/Output Control Codes，简称IOCTLs）相关的操作。IOCTLs是Windows操作系统中用于设备驱动程序通信的一种机制...
Windows驱动编程基础教程
03-22
在IT领域，Windows驱动编程是计算机科学的一个重要分支，它涉及到操作系统内核与硬件设备之间的交互。本教程“Windows驱动编程基础教程”是楚狂人专门为新手设计的入门指南，旨在帮助初学者理解和掌握这一复杂但至关...
Tsi721 Windows 设备驱动和API用户参考指南（中文版）
03-30
### Tsi721 Windows 设备驱动和API用户参考指南（中文版）知识点解析 #### 一、概览 本文档旨在为熟悉RapidIO规范的软件开发人员提供关于Tsi721 Windows设备驱动程序及其API的详细介绍。文档不仅涵盖了驱动程序的...
I/O Request Packet
zhuo_zhibin的专栏
09-14 5877
第5章 I/O Request Packet 5.1 数据结构 在处理 I/O 请求上，有两个重要的数据结构：IRP（I/O request packet）和 IO_STACK_LOCATION 5.1.1 IRP 的结构 下面是在 windbg 里得到的 IRP 结构： nt!_IRP +0x000 Type : Int2B +0x002 Size
windows ioctl
anna的专栏
12-11 8182
Windows IOCTL Reference | Extracted from DDK 7.1.0 | Entries: 760 | Quick Filter  Ioctl Hex Value Header Brief IOCTL_1394_CLASS 0x22021d inc\ddk\1394.h An
WDM ioctl 缓冲区读写
12-22 697
1 METHOD_BUFFERED Buffered IO中IO管理器会分配一块堆内存然后把用户态缓冲区数据copy进来再传给驱动程序,而输出时IO管理器会把堆内存中的数据copy回用户态缓冲区。 ULONG inputSize = I.IoctlInputBufferSize(); PVOID inputBuffer = I.IoctlBuffer(); ULON
HID ioctl 命令详解 .
09-08 1836
ioctl(): This is the control interface. There are a number of controls: HIDIOCGVERSION int (read) Gets the version code out of the hiddev driver. HIDIOCAPPLICATION (none) This ioctl ca
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值