《C++黑客编程解密》04 - 内核驱动开发

在windows下，驱动不仅用于控制硬件设备，也可以创建虚拟设备，也可以和具体设备无关。可以通过windows提供的接口很方便地对内核扩展。驱动模块加载到内核后就可以工作在和操作系统平级地平台上运行。

在安装vs之后还要再安装wdk https://docs.microsoft.com/zh-cn/windows-hardware/drivers/download-the-wdk
注意：win11使用vs2022与相应wdk，win10使用vs2019和相应wdk。

win10 下运行程序可能会报错，提示要修复漏洞，到vs installer 中再下载几个组件：

编译程序前需要做：

移除项目自动生成的.inf文件
配置属性 - C/C++ -常规
警告等级设置为等级3
将警告视为错误设置为否
配置属性 - 链接器 -常规
将链接器警告视为错误设置为否
配置属性 - Driver Signing - General
Sign Mode 设置为 Off。

驱动版 Hello World

开发驱动时不再使用 main WinMain，而是使用 DriveEntry 作为入口函数

// DriverEntry[WDK kernel] 定义，除此以外还有很多 DriverEntry 函数的定义
NTSTATUS
DriverEntry(
    __in struct _DRIVER_OBJECT *DriverObject,  // 一个指向驱动对象结构体地指针
    __in PUNICODE_STRING RegistryPath          // 一个UNICODE字符串，指向此驱动负责的注册表
)
{ ... }

helloworld的例子：

#include <ntddk.h>

VOID DriverUnload(PDRIVER_OBJECT pDriverOjbect)
{
    KdPrint(("DriverUnload Routine!\r\n"));
}

NTSTATUS DriverEntry(
            PDRIVER_OBJECT pDriverObject,
            PUNICODE_STRING pRegistryPath)
{
    KdPrint(("%S\r\n", pDriverObject->DriverName.Buffer));
    pDriverObject->DriverUnload = DriverUnload;
    
    return STATUS_SUCCESS;
}

DriverObject 结构体：

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.  This is a pointer
    // to the path to the hardware information in the registry
    //

    PUNICODE_STRING HardwareDatabase; // 指向 注册表中硬件配置信息的 \Registry\Machine\Hardware 路径的指针

    //
    // 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; // 指向定义驱动程序快速 I/O 入口点的结构的指针。 此成员仅由 FSD 和网络传输驱动程序使用。

    //
    // 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;  // DriverEntry 例程的入口点，由 I/O 管理器设置
    PDRIVER_STARTIO DriverStartIo;  // 驱动程序的 StartIo 例程的入口点（如果有）（由驱动程序初始化时 DriverEntry 例程设置）。 如果驱动程序没有 StartIo 例程 ，则此成员为 NULL。
    PDRIVER_UNLOAD DriverUnload;    // 卸载驱动时的回调函数 typedef VOID DRIVER_UNLOAD ( _In_ struct _DRIVER_OBJECT *DriverObject );
    PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1]; // 一个调度表，由驱动程序的 DispatchXxx 例程的入口点数组组成。 数组的索引值是表示IRP_MJ_ IRP 主要函数代码的索引值。 每个驱动程序必须在此数组中为驱动程序处理的 IRP_MJ_XXX 请求设置入口点
} DRIVER_OBJECT;

驱动程序装载

将驱动程序加载为一个服务，卸载时直接删除服务。常见的Windows驱动程序分为两类，一类时不支持即插即用的NT式驱动，另一类是支持即插即用的WDM式驱动。NT式驱动程序安装是基于服务的，WDM式驱动安装是基于INF文件的。

void Load(char* szDriverPath)
{
    char szFileName[256];
    _splitpath(szDriverPath, NULL, NULL, szFileName, NULL);

    // 打开服务控制管理器
    SC_HANDLE hScm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

    // 创建驱动对应的服务
    SC_HANDLE hService = CreateService(hScm, szFileName, szFileName,
        SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START,
        SERVICE_ERROR_IGNORE, szDriverPath, NULL, NULL, NULL, NULL, NULL);

    // 启动服务
    StartService(hService, NULL, NULL);

    CloseServiceHandle(hService);
    CloseServiceHandle(hScm);
}

void Unload(char* szDriverPath)
{
    char szFileName[256];
    _splitpath(szDriverPath, NULL, NULL, szFileName, NULL);

    // 打开服务控制管理器
    SC_HANDLE hScm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

    // 获得服务句柄
    SC_HANDLE hService = OpenService(hScm, szFileName, SERVICE_ALL_ACCESS);

    // 关闭服务
    SERVICE_STATUS status;
    ControlService(hService, SERVICE_CONTROL_STOP, &status);
    // 删除服务
    DeleteService(hService);

    // 关闭句柄
    CloseServiceHandle(hService);
}

内核下文件操作

内核中不能使用用户层的win32api函数，需要使用内存层对应函数。

文件创建或打开：

再应用层文件完整路径为"c:\\a.txt"，内核层描述方式为"\\?\\c:\\a.txt"；
符号链接在用户模式下以"\\\\.\\"开头，内核模式下以"\\??\\"或"\\DosDevices\\"开头。

// 可以创建和打开
NTSYSAPI
NTSTATUS
NTAPI
ZwCreateFile(
    _Out_ PHANDLE FileHandle,                  // 返回文件打开的句柄
    _In_ ACCESS_MASK DesiredAccess,            // 打开文件的操作 GENERIC_READ GENERIC_WRITE
    _In_ POBJECT_ATTRIBUTES ObjectAttributes,  // 指向包含文件名的结构体的指针
    _Out_ PIO_STATUS_BLOCK IoStatusBlock,      // 指向接收操作结果的指针
    _In_opt_ PLARGE_INTEGER AllocationSize,    // 指定文件初始化大小的64位整数
    _In_ ULONG FileAttributes,                 // 通常 FILE_ATTRIBUTE_NORMAL
    _In_ ULONG ShareAccess,                    // 文件共享方式 FILE_SHARE_READ FILE_SHARE_WRITE FILE_SHARE_DELETE
    _In_ ULONG CreateDisposition,              // FILE_CREATE FILE_OPEN FILE_OPEN_IF
    _In_ ULONG CreateOptions,                  // 通常使用 FILE_SYNCHRONOUS_IO_NONALERT 表示文件是同步操作
    _In_reads_bytes_opt_(EaLength) PVOID EaBuffer,  // 一般为NULL
    _In_ ULONG EaLength                        // NULL
    );



// 第三个参数指向的结构体
typedef struct _OBJECT_ATTRIBUTES {
    ULONG Length;
    HANDLE RootDirectory;
    PUNICODE_STRING ObjectName;
    ULONG Attributes;
    PVOID SecurityDescriptor;        // Points to type SECURITY_DESCRIPTOR
    PVOID SecurityQualityOfService;  // Points to type SECURITY_QUALITY_OF_SERVICE
} OBJECT_ATTRIBUTES;

// 一般使用  InitializeObjectAttributes 宏进行初始化
//++
//
// VOID
// InitializeObjectAttributes(
//     _Out_ POBJECT_ATTRIBUTES p, 指向结构体的指针
//     _In_ PUNICODE_STRING n,     对象名称，用UNICODE_STRING 描述，对于 ZwCreateFile 该处指定文件名
//     _In_ ULONG a,               一般设置为 OBJ_CASE_INSENSITIVE 意味名字字符串不区分大小写
//     _In_ HANDLE r,              一般NULL
//     _In_ PSECURITY_DESCRIPTOR s 一般NULL
//     )
//
//--

#define InitializeObjectAttributes( p, n, a, r, s ) { \
    (p)->Length = sizeof( OBJECT_ATTRIBUTES );          \
    (p)->RootDirectory = r;                             \
    (p)->Attributes = a;                                \
    (p)->ObjectName = n;                                \
    (p)->SecurityDescriptor = s;                        \
    (p)->SecurityQualityOfService = NULL;               \
    }

// 内核对宽字符串的封装，使用KdPrint 输出： KdPrint(("%wZ", &uniString));
// 初始化方法：RtlInitUnicodeString(&FooU, L"Foo");
typedef struct _UNICODE_STRING {
    USHORT Length;         // 字符串长度
    USHORT MaximumLength;  // 缓存区长度
    PWSTR Buffer;          // 缓冲区指针
#endif // MIDL_PASS
} UNICODE_STRING;

用于打开的简化函数

NTSYSAPI
NTSTATUS
NTAPI
ZwOpenFile(
    _Out_ PHANDLE FileHandle,
    _In_ ACCESS_MASK DesiredAccess,
    _In_ POBJECT_ATTRIBUTES ObjectAttributes,
    _Out_ PIO_STATUS_BLOCK IoStatusBlock,
    _In_ ULONG ShareAccess,
    _In_ ULONG OpenOptions
    );

关闭句柄：

NTSYSAPI
NTSTATUS
NTAPI
ZwClose(
    _In_ HANDLE Handle
    );

内存管理函数

NTKERNELAPI
PVOID
ExAllocatePool (
    // 枚举值 NonPagedPool非分页内存：不会被交换到文件中的虚拟内存  PagedPool分页内存：可以被交换到文件中的虚拟内存
    __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType,
    _In_ SIZE_T NumberOfBytes  // 要分配的内存大小
    );

#define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))

NTKERNELAPI
VOID
NTAPI
ExFreePool (
    _Pre_notnull_ __drv_freesMem(Mem) PVOID P
    );

例子：

查看代码

 #include <ntddk.h>
#define FILENAME L"\\??\\c:\\a.txt"
#define BUFFERLEN 10

VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
{
}

VOID CreateFileTest()
{
    NTSTATUS status = STATUS_SUCCESS;
    
    OBJECT_ATTRIBUTES ObjAttribute;
    IO_STATUS_BLOCK ioStatusBlock;
    
    UNICODE_STRING uniFile;
    
    HANDLE hFile = NULL;
    
    RtlInitUnicodeString(&uniFile, FILENAME);
    
    // 初始化一个对象属性
    InitializeObjectAttributes(&ObjAttribute,
                &uniFile,
                OBJ_CASE_INSENSITIVE, 
                NULL,
                NULL);
                
    // 创建文件
    status = ZwCreateFile(&hFile,
                GENERIC_READ | GENERIC_WRITE,
                &ObjAttribute,
                &ioStatusBlock,
                0,
                FILE_ATTRIBUTE_NORMAL,
                FILE_SHARE_READ,
                FILE_OPEN_IF,
                FILE_SYNCHRONOUS_IO_NONALERT,
                NULL,
                0);
    
    if ( NT_SUCCESS(status) )
    {
        KdPrint(("File Create ok ! \r\n"));
    }
    else
    {
        KdPrint(("File Create faild ! \r\n"));
    }
    

    ZwClose(hFile);
}

VOID OpenFileTest()
{
    IO_STATUS_BLOCK ioStatusBlock;
    OBJECT_ATTRIBUTES ObjAttribute;
    HANDLE hFile;
    UNICODE_STRING uniFileName;
    NTSTATUS status;
    
    FILE_STANDARD_INFORMATION fsi;
    FILE_POSITION_INFORMATION fpi;
    PVOID Buffer = NULL;
    
    RtlInitUnicodeString(&uniFileName, FILENAME);
    
    // 初始化一个对象属性
    InitializeObjectAttributes(&ObjAttribute, 
                        &uniFileName,
                        OBJ_CASE_INSENSITIVE,
                        NULL,
                        NULL);
    
    // 打开文件
    status = ZwOpenFile(&hFile,
                    GENERIC_READ | GENERIC_WRITE,
                    &ObjAttribute,
                    &ioStatusBlock,
                    FILE_SHARE_READ,
                    FILE_SYNCHRONOUS_IO_NONALERT);
    
    if ( NT_SUCCESS(status) )
    {
        KdPrint(("OpenFile Successfully ! \r\n"));
    }
    else
    {
        KdPrint(("OpenFile UnSuccessfully ! \r\n"));
        return ;
    }
    
    // 获取文件属性
    status = ZwQueryInformationFile(hFile,
                        &ioStatusBlock,
                        &fsi,
                        sizeof(FILE_STANDARD_INFORMATION),
                        FileStandardInformation);
    
    // 输出新创建的文件是否是目录
    KdPrint(("Is Directory %d \r\n", fsi.Directory));
    
    // 分配空间
    Buffer = ExAllocatePool(PagedPool, BUFFERLEN);
    
    if ( Buffer == NULL )
    {
        ZwClose(hFile);
        return ;
    }
    
    // 填充值为
    RtlFillMemory(Buffer, BUFFERLEN, 0x61);
    
    // 写文件
    status = ZwWriteFile(hFile,
                    NULL,
                    NULL,
                    NULL,
                    &ioStatusBlock,
                    Buffer,
                    BUFFERLEN,
                    0,
                    NULL);

    if ( NT_SUCCESS(status) )
    {
        KdPrint(("ZwWriteFile Successfully ! \r\n"));
    }
    
    // 释放申请的空间
    ExFreePool(Buffer);
    
    // 获取文件属性
    status = ZwQueryInformationFile(hFile,
                        &ioStatusBlock,
                        &fsi,
                        sizeof(FILE_STANDARD_INFORMATION),
                        FileStandardInformation);
                        
    // 输出新创建的文件是否是目录
    KdPrint(("FileSize =  %d \r\n", (LONG)fsi.EndOfFile.QuadPart));

    Buffer = ExAllocatePool(PagedPool, (fsi.EndOfFile.QuadPart * 2));
    if ( Buffer == NULL )
    {
        KdPrint(("ExAllocatePool UnSuccessfully ! \r\n"));
        ZwClose(hFile);
        return ;
    }    
    
    
    fpi.CurrentByteOffset.QuadPart = 0;
    // 设置文件指针
    status = ZwSetInformationFile(hFile, 
                            &ioStatusBlock, &fpi,
                            sizeof(FILE_POSITION_INFORMATION),
                            FilePositionInformation);
    
    // 读取文件内容
    status = ZwReadFile(hFile, NULL, NULL, NULL,
                        &ioStatusBlock, Buffer,
                        (LONG)fsi.EndOfFile.QuadPart,
                        NULL, NULL);
                        
    if ( NT_SUCCESS(status) )
    {
        KdPrint(("ZwReadFile Successfully ! \r\n"));
    }
    KdPrint(("%s", Buffer));
    
    ExFreePool(Buffer);
    ZwClose(hFile);
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, 
                     PUNICODE_STRING pRegistryPath)
{
    pDriverObject->DriverUnload = DriverUnload;
    
    CreateFileTest();
    
    OpenFileTest();
    
    return STATUS_SUCCESS;
}

注册表操作

ZwCreateKey
ZwOpenKey
ZwSetValueKey
ZwQueryValueKey

// 用于创建和打开
NTSYSAPI
NTSTATUS
NTAPI
ZwCreateKey(
    _Out_ PHANDLE KeyHandle,
    _In_ ACCESS_MASK DesiredAccess,     // 访问权限 KEY_ALL_ACCESS
    _In_ POBJECT_ATTRIBUTES ObjectAttributes,  // 用于保存要创建的子键
    _Reserved_ ULONG TitleIndex,        // 0
    _In_opt_ PUNICODE_STRING Class,     // NULL
    _In_ ULONG CreateOptions,           // 一般 REG_OPTION_NON_VOLATILE
    _Out_opt_ PULONG Disposition        // 返回创建成功还是打开成功
    );


NTSYSAPI
NTSTATUS
NTAPI
ZwOpenKey(
    _Out_ PHANDLE KeyHandle,
    _In_ ACCESS_MASK DesiredAccess,
    _In_ POBJECT_ATTRIBUTES ObjectAttributes
    );


NTSYSAPI
NTSTATUS
NTAPI
ZwSetValueKey(
    _In_ HANDLE KeyHandle,
    _In_ PUNICODE_STRING ValueName, // 新建或修改的键名
    _In_opt_ ULONG TitleIndex,      // 一般为0
    _In_ ULONG Type,                // 键值类型，REG_SZ REG_DWORD REG_MULTI_SZ
    _In_reads_bytes_opt_(DataSize) PVOID Data,  // 写入键值的值
    _In_ ULONG DataSize             // 记录数据的大小
    );


NTSYSAPI
NTSTATUS
NTAPI
ZwQueryValueKey(
    _In_ HANDLE KeyHandle,
    _In_ PUNICODE_STRING ValueName, // 键名
    _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, // 查询方式
    _Out_writes_bytes_to_opt_(Length, *ResultLength) PVOID KeyValueInformation, // 根据前者选择不同类别
    _In_ ULONG Length,              // 要查数据长度
    _Out_ PULONG ResultLength       // 实际查询数据长度
    );