实现驱动加载器并且和驱动通讯（提示：内容稍长）
M.M.
|
|
|
windows内核
|
0
|
599

3689 字
|
1.5 小时
本文最后更新于 504 天前，其中的信息可能已经有所发展或是发生改变。
内容目录

file

 
 
目标：

  1. 用户一键使用： 驱动加载（将驱动的安装、启动、停止、卸载的服务放到R3程序中来实现，作为可发布程序使用）
  2. 通过驱动的control回调函数和控制码来实现通讯

 
 
 

0x01 项目管理

环境整理：

创建一个空白项目,主要是为了用空白项目的解决方案

把Ring3和驱动加入到解决方案，环境里删掉刚创建的空白项目即可，就不用频繁的切换环境

把Ring3和驱动的输出都放到bin目录下(两个都需要设置)，便于实验

file

 
整理后的效果

file

 

0x02 实验验证： 创建服务

2.1 验证过程

Ring3.cpp

#include <stdio.h>
#include <windows.h>
 
/*
如果没有R3得程序怎么加载呢？
微软有个inf文件，这个东西可以安装，在微软的官方文档中有说明inf内容怎么写；
 
OS会解析inf这个配置文件，帮助动态加载驱动
例： 如果硬件需要开机启动加载，微软再开机时会自动加载inf文件
 
驱动加载的方式：
1. inf文件来加载
2. 动态加载（服务）
 
创建服务就是安装驱动（很多软件都可以使用打印机，那么就可调用打印机的驱动，驱动的角色是服务），也就是需要4个api就可以完成这些工作；
创建服务
启动服务
停止服务
卸载服务
*/
 
void showErr(const char *name)
{
    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("[%s] Error %s", name, (LPCTSTR)lpMsgBuf);
    LocalFree(lpMsgBuf);
}
 
int LoadDriver(const char *pszPath, const char *pszServiceName)
{   
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__,hSCM);
 
    hService = CreateService(hSCM, pszServiceName, pszServiceName, SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER,
        SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL, pszPath, NULL, NULL, NULL, NULL, NULL);
    if (hService == NULL)
    {
        showErr("CreateService");
        goto SAFE_EXIT;  /* 使用了goto之后，使用局部变量，必须先定义后使用 */
    }
 
    printf("[%s] CreateService Ok hService:%p \n", __FUNCTION__, hService);
    /*  CreateService 使用分析
    SC_HANDLE CreateService(  
      SC_HANDLE hSCManager,       // handle to SCM database  服务是由服务管理器来管理，这里拿到服务管理器；SCM（service control manager） ，因为是本地，前两个为NULL，最后一个是权限，如果选择所有权限，就是既能创建又能删除
      LPCTSTR lpServiceName,      // name of service to start
      LPCTSTR lpDisplayName,      // display name
      DWORD dwDesiredAccess,      // type of access to service
      DWORD dwServiceType,        // type of service
      DWORD dwStartType,          // when to start service    五种启动方式，选第3个，重启系统后就不再加载
      DWORD dwErrorControl,       // severity of service failure
      LPCTSTR lpBinaryPathName,   // name of binary file
      LPCTSTR lpLoadOrderGroup,   // name of load ordering group
      LPDWORD lpdwTagId,          // tag identifier
      LPCTSTR lpDependencies,     // array of dependency names
      LPCTSTR lpServiceStartName, // account name
      LPCTSTR lpPassword          // account password);
    */
 
    iRet = 0;
 
SAFE_EXIT:
    if (CloseServiceHandle(hSCM) == 0)
    {
        showErr("CloseServiceHandle");
    }
    return iRet;
}
 
int UnLoadDriver(const char *name)
{
    return 0;
}
 
int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    if (LoadDriver("sample2.sys", "51asmMark") < 0)
        return 0;
 
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    if (UnLoadDriver("51asmMark") < 0)
        return 0;
 
#if 0
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    printf("hFile:%p err:%p\n", hFile, GetLastError());
 
    // 读写设备
    char acBuf[60] = { 0 };
    printf("acBuf:%p\n", acBuf);  /* 驱动要输出R3的缓存地址，这里作为对照 */
    DWORD dwBytes = 0;
    BOOL bRet = ReadFile(hFile, acBuf, sizeof(acBuf), &dwBytes, NULL);
    printf("bRet:%d  dwBytes:%d  acBuf:%s\n", bRet, dwBytes, acBuf);
 
    // 控制设备
    // 关闭设备
 
#endif
 
    system("pause");
    return 0;
}

 

2.2 问题分析

期间遇到一个问题，折腾老半天，无效，如下图：

file

解决： 拒绝访问，是权限不足，关闭vs2019，用管理员的权限运行（感谢前辈的博客）；

 

2.3 结果分析

服务创建成功了

file

 

2.4 原理分析

那么问题来了， creatServer 这个api做了什么？

其实在OS中记录下驱动的信息，regedit 注册表中看一下，注册表的每一个表象，都是创建的服务creatServer的参数，因此开机时，OS遍历注册表 就可以遍历驱动

也就是可以通过这个目录遍历所有系统安装的驱动

file

 

0x03 启动服务

3.1 出现问题1

问题1： 第二次创建时，提示服务已经存在了???

因为此时在创建服务失败后并没有判断服务是否已经存在了，那么就需要根据错误码判断服务是否存在，如果服务存在，那就直接打开服务就行； 下图中左侧打印出错误码，dwErr;

file

Ring.cpp 中的一个函数，解决这个问题

int LoadDriver(const char *pszPath, const char *pszServiceName)
{   
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__,hSCM);
 
    hService = CreateService(hSCM, pszServiceName, pszServiceName, SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER,
        SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL, pszPath, NULL, NULL, NULL, NULL, NULL);
    if (hService == NULL)
    {
        //if (GetLastError() == 1073)  // 当前服务已经存在，那就直接打开用
        if (GetLastError() == ERROR_SERVICE_EXISTS)
        {
            hService = OpenService(hSCM, pszServiceName, SERVICE_ALL_ACCESS);
            if (hService == NULL)
            {
                showErr("OpenService");
                goto SAFE_EXIT;
            }
            printf("[%s] OpenService Ok hService:%p \n", __FUNCTION__, hService);
        }
        else
        {
            showErr("CreateService");
            goto SAFE_EXIT;
        }
    }
 
    printf("[%s] CreateService Ok hService:%p \n", __FUNCTION__, hService);
    /*  CreateService 使用分析
    SC_HANDLE CreateService(  
      SC_HANDLE hSCManager,       // handle to SCM database  服务是由服务管理器来管理，这里拿到服务管理器；SCM（service control manager） ，因为是本地，前两个为NULL，最后一个是权限，如果选择所有权限，就是既能创建又能删除
      LPCTSTR lpServiceName,      // name of service to start
      LPCTSTR lpDisplayName,      // display name
      DWORD dwDesiredAccess,      // type of access to service
      DWORD dwServiceType,        // type of service
      DWORD dwStartType,          // when to start service    五种启动方式，选第3个，重启系统后就不再加载
      DWORD dwErrorControl,       // severity of service failure
      LPCTSTR lpBinaryPathName,   // name of binary file
      LPCTSTR lpLoadOrderGroup,   // name of load ordering group
      LPDWORD lpdwTagId,          // tag identifier 
      LPCTSTR lpDependencies,     // array of dependency names
      LPCTSTR lpServiceStartName, // account name
      LPCTSTR lpPassword          // account password);
    */
 
    if (!StartService(hService, NULL, NULL)) /* 后两个参数，因为是驱动的服务，所以三环这里给NULL */
    {
        showErr("StartService");
        goto SAFE_EXIT;
    }
 
    iRet = 0;
 
SAFE_EXIT:
    if (hService != NULL)
    {
        if (CloseServiceHandle(hService) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    if (hSCM != NULL)
    {
        if (CloseServiceHandle(hSCM) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    return iRet;
}

 

3.2 出现问题2

问题2：找不到指定文件

1、 不能再win10上运行

2、 驱动一直没有卸载过，卸载函数没写过

file

 

3.3 卸载实验验证

Ring3.cpp的UnLoadDriver函数

int UnLoadDriver(const char * pszServiceName)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
    SERVICE_STATUS oldState = { 0 };
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__, hSCM);
 
    hService = OpenService(hSCM, pszServiceName, SERVICE_ALL_ACCESS);
    if (hService == NULL)
    {
        showErr("OpenService");
        goto SAFE_EXIT;
    }
    printf("[%s] OpenService Ok hService:%p \n", __FUNCTION__, hService);
 
    /* 
        1. DeleteService之前，如果服务正在运行怎么办？ 那就是先暂停服务  
        2 .OS 的peding状态：向硬件发送的请求还没有完成，此时驱动卸不掉，停不掉(如果驱动中的派遣函数没有IoCompleteRequest完成请求，就会有这种情况)
    */
    if (!ControlService(hService, SERVICE_CONTROL_STOP, &oldState))
    {
        if (GetLastError() == ERROR_SERVICE_NOT_ACTIVE)  // 服务没有启动的时候 判断错误码1062,那就启动服务；
        {
            printf("[%s] ControlService not active  hService:%p \n", __FUNCTION__, hService);
        }
        else if (GetLastError() == ERROR_DEPENDENT_SERVICES_RUNNING)  // peding 状态
        {
            printf("[%s] Please reboot system hService:%p \n", __FUNCTION__, hService);
            goto SAFE_EXIT;
        }
        else
        {
            showErr("ControlService");
            goto SAFE_EXIT;
        }
    }
 
    printf("[%s] ControlService stop service Ok hService:%p \n", __FUNCTION__, hService);
 
    if (!DeleteService(hService))
    {
        showErr("DeleteService");
        goto SAFE_EXIT;
    }
 
    printf("[%s] DeleteService Ok hService:%p \n", __FUNCTION__, hService);
 
    iRet = 0;
 
SAFE_EXIT:
    if (hService != NULL)
    {
        if (CloseServiceHandle(hService) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    if (hSCM != NULL)
    {
        if (CloseServiceHandle(hSCM) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    return iRet;
}

 

3.4 卸载结果分析

卸载成功，但是创建找不到指定文件

file

 

3.5 极端情况(加载器不会考虑这种情况)

3.5.1

极端情况分析： 有可能停掉驱动，但是驱动的回调函数还没有完成 IoCompleteRequest，这时的线程被挂起，服务停不掉，也会报错；

NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
 
    /* 验证这里是R3的缓存地址，输出一下 */
    DbgPrint("51[asm][%s:%d] Irp->UserBuffer:%p", __FUNCTION__, __LINE__, Irp->UserBuffer); 
 
    RtlCopyMemory(Irp->UserBuffer,g_zMsg,sizeof(g_zMsg));
 
    Irp->IoStatus.Status = STATUS_SUCCESS;        /* 告诉R3返回的状态 */
    Irp->IoStatus.Information = sizeof(g_zMsg);   /* 告诉R3读取的字节数 */
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);  /* 如果驱动中的派遣函数没有IoCompleteRequest完成请求，R3就会有这peding状态的情况 */
 
    return STATUS_SUCCESS;                      /* R3的ReadFile的返回值 */
}

 

3.5.2

OS 的peding状态：向硬件发送的请求还没有完成，此时驱动卸不掉，停不掉

file

 

3.6 实验验证：加载卸载

Ring3.cpp

#include <stdio.h>
#include <windows.h>
 
/*
如果没有R3得程序怎么加载呢？
微软有个inf文件，这个东西可以安装，在微软的官方文档中有说明inf内容怎么写；
 
OS会解析inf这个配置文件，帮助动态加载驱动
例： 如果硬件需要开机启动加载，微软再开机时会自动加载inf文件
 
驱动加载的方式：
1. inf文件来加载
2. 动态加载（服务）
 
创建服务就是安装驱动（很多软件都可以使用打阴界，那么就可调用打印机的驱动，驱动的角色是服务），也就是需要4个api就可以完成这些工作；
创建服务
启动服务
停止服务
卸载服务
*/
 
void showErr(const char *name)
{
    LPVOID lpMsgBuf;
    DWORD dwErr = GetLastError();
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dwErr,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
        (LPTSTR)&lpMsgBuf,
        0,
        NULL
    );
    printf("[%s] Error Code:%d  Msg:%s", name, dwErr, (LPCTSTR)lpMsgBuf);
    //MessageBox(NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION);
    // Free the buffer.
    LocalFree(lpMsgBuf);
}
 
int LoadDriver(const char *pszPath, const char *pszServiceName)
{   
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__,hSCM);
 
    hService = CreateService(hSCM, pszServiceName, pszServiceName, SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER,
        SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL, pszPath, NULL, NULL, NULL, NULL, NULL);
    if (hService == NULL)
    {
        //if (GetLastError() == 1073)  // 当前服务已经存在，那就直接打开用
        if (GetLastError() == ERROR_SERVICE_EXISTS)
        {
            hService = OpenService(hSCM, pszServiceName, SERVICE_ALL_ACCESS);
            if (hService == NULL)
            {
                showErr("OpenService");
                goto SAFE_EXIT;
            }
            printf("[%s] OpenService Ok hService:%p \n", __FUNCTION__, hService);
        }
        else
        {
            showErr("CreateService");
            goto SAFE_EXIT;
        }
    }
 
    printf("[%s] CreateService Ok hService:%p \n", __FUNCTION__, hService);
    /*  CreateService 使用分析
    SC_HANDLE CreateService(  
      SC_HANDLE hSCManager,       // handle to SCM database  服务是由服务管理器来管理，这里拿到服务管理器；SCM（service control manager） ，因为是本地，前两个为NULL，最后一个是权限，如果选择所有权限，就是既能创建又能删除
      LPCTSTR lpServiceName,      // name of service to start
      LPCTSTR lpDisplayName,      // display name
      DWORD dwDesiredAccess,      // type of access to service
      DWORD dwServiceType,        // type of service
      DWORD dwStartType,          // when to start service    五种启动方式，选第3个，重启系统后就不再加载
      DWORD dwErrorControl,       // severity of service failure
      LPCTSTR lpBinaryPathName,   // name of binary file
      LPCTSTR lpLoadOrderGroup,   // name of load ordering group
      LPDWORD lpdwTagId,          // tag identifier 
      LPCTSTR lpDependencies,     // array of dependency names
      LPCTSTR lpServiceStartName, // account name
      LPCTSTR lpPassword          // account password);
    */
 
    if (!StartService(hService, NULL, NULL)) /* 后两个参数，因为是驱动的服务，所以三环这里给NULL */
    {
        showErr("StartService");
        goto SAFE_EXIT;
    }
 
    iRet = 0;
 
SAFE_EXIT:
    if (hService != NULL)
    {
        if (CloseServiceHandle(hService) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    if (hSCM != NULL)
    {
        if (CloseServiceHandle(hSCM) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    return iRet;
}
 
int UnLoadDriver(const char * pszServiceName)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
    SERVICE_STATUS oldState = { 0 };
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__, hSCM);
 
    hService = OpenService(hSCM, pszServiceName, SERVICE_ALL_ACCESS);
    if (hService == NULL)
    {
        showErr("OpenService");
        goto SAFE_EXIT;
    }
    printf("[%s] OpenService Ok hService:%p \n", __FUNCTION__, hService);
 
    /* 
        1. DeleteService之前，如果服务正在运行怎么办？ 那就是先暂停服务  
        2 .OS 的peding状态：向硬件发送的请求还没有完成，此时驱动卸不掉，停不掉(如果驱动中的派遣函数没有IoCompleteRequest完成请求，就会有这种情况)
    */
    if (!ControlService(hService, SERVICE_CONTROL_STOP, &oldState))
    {
        if (GetLastError() == ERROR_SERVICE_NOT_ACTIVE)  // 服务没有启动的时候 判断错误码1062
        {
            printf("[%s] ControlService not active  hService:%p \n", __FUNCTION__, hService);
        }
        else if (GetLastError() == ERROR_DEPENDENT_SERVICES_RUNNING)  // peding 状态
        {
            printf("[%s] Please reboot system hService:%p \n", __FUNCTION__, hService);
            goto SAFE_EXIT;
        }
        else
        {
            showErr("ControlService");
            goto SAFE_EXIT;
        }
    }
 
    printf("[%s] ControlService stop service Ok hService:%p \n", __FUNCTION__, hService);
 
    if (!DeleteService(hService))
    {
        showErr("DeleteService");
        goto SAFE_EXIT;
    }
 
    printf("[%s] DeleteService Ok hService:%p \n", __FUNCTION__, hService);
 
    iRet = 0;
 
SAFE_EXIT:
    if (hService != NULL)
    {
        if (CloseServiceHandle(hService) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    if (hSCM != NULL)
    {
        if (CloseServiceHandle(hSCM) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    return iRet;
}
 
int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
 
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
#if 1
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    printf("hFile:%p err:%p\n", hFile, GetLastError());
 
    // 读写设备
    char acBuf[60] = { 0 };
    printf("acBuf:%p\n", acBuf);  /* 驱动要输出R3的缓存地址，这里作为对照 */
    DWORD dwBytes = 0;
    BOOL bRet = ReadFile(hFile, acBuf, sizeof(acBuf), &dwBytes, NULL);
    printf("bRet:%d  dwBytes:%d  acBuf:%s\n", bRet, dwBytes, acBuf);
 
    // 控制设备
    // 关闭设备
 
#endif
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

 

3.7 实验结果分析

启动服务的时候，系统路径找不到，验证有误，驱动路径有问题，修改为绝对路径试试；

file

 

3.8 实验验证：路径修改为绝对路径

修改为绝对路径(虚拟机中驱动的绝对路径)

int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("C:\\Documents and Settings\\cobb\\桌面\\sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        showErr("CreateFile");
    }
    else
    {
        printf("hFile:%p \n", hFile);
 
        // 读写设备
        char acBuf[60] = { 0 };
        printf("acBuf:%p\n", acBuf);  /* 驱动要输出R3的缓存地址，这里作为对照 */
        DWORD dwBytes = 0;
        BOOL bRet = ReadFile(hFile, acBuf, sizeof(acBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("ReadFile");
        }
        else
        {
            printf("bRet:%d  dwBytes:%d  acBuf:%s\n", bRet, dwBytes, acBuf);
        }
 
        // 控制设备
        // 关闭设备
        CloseHandle(hFile);
    }
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

 

3.9 结果分析

成功获取到hello，成功加载和卸载；

加载工具的实现已完成；

file

 

0x04 通过control来通讯

控制码： 驱动的DispatchRead被调用了，用户发来了请求，那么驱动怎么才能知道用户想要干嘛？ 是遍历文件？遍历进程? …. 于是需要用控制码来标注一下，R3想要让驱动具体做什么，就发送对应的控制码；

R3和R0要分开，驱动中不直接访问三环的内存地址，而是在内核中申请一段内存，请求完成时，把内存拷贝给R3

 
问题： 读了数据又想写数据怎么办？

假如说R3写数据的请求是关闭某个进程，那么需要传给驱动一个pid， 同时R3需要一个结果，判断这个进程有没有关闭成功。

readfile+缓冲区，writefile+缓冲区，这就需要两个缓冲区来做交互，并且这两个回调一般是给硬件设备用的;

如果使用控制，那可以一次传两个缓冲区，可以同时读写数据,相对更加方便；

 

4.1 实验验证：能否调用驱动control函数

Ring3.cpp 中的main函数

int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("C:\\Documents and Settings\\cobb\\桌面\\sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        showErr("CreateFile");
    }
    else
    {
        printf("hFile:%p \n", hFile);
#if 0
        // 读写设备
        char acBuf[60] = { 0 };
        printf("acBuf:%p\n", acBuf);  /* 驱动要输出R3的缓存地址，这里作为对照 */
        DWORD dwBytes = 0;
        BOOL bRet = ReadFile(hFile, acBuf, sizeof(acBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("ReadFile");
        }
        else
        {
            printf("bRet:%d  dwBytes:%d  acBuf:%s\n", bRet, dwBytes, acBuf);
        }
#endif
        char szInBuf[MAXBYTE] = { 0 };
        char szOutBuf[MAXBYTE] = { 0 };
        DWORD dwBytes = 0; /* 缓冲区写进去的数据个数 */
        BOOL bRet = DeviceIoControl(hFile, 100, szInBuf, sizeof(szInBuf), szOutBuf, sizeof(szOutBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("DeviceIoControl");
        }
        else
        {
            // 显示结果
            printf("bRet:%d  dwBytes:%d  szOutBuf:%s\n", bRet, dwBytes, szOutBuf);
        }
 
        // 控制设备
        // 关闭设备
        CloseHandle(hFile);
    }
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

 

4.2 结果分析

调用了control，

file

 
4.2.1

NT框架的设计问题：irp里没有R3的控制码

系统采用分层驱动的方式，例如：键盘是两个驱动加载组成的；

file

例： 有线键盘 不同usb接口键盘 逻辑大量重复

那就： 一个负责接口驱动，一个负责键盘逻辑驱动

 

4.3 实验验证：驱动中获取R3地址

Ring3.cpp 的main函数

int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("C:\\Documents and Settings\\cobb\\桌面\\sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        showErr("CreateFile");
    }
    else
    {
        printf("hFile:%p \n", hFile);
 
        char szInBuf[MAXBYTE] = { 0 };
        char szOutBuf[MAXBYTE] = { 0 };
        printf("szInBuf:%p  szOutBuf:%p size:%d\n", szInBuf, szOutBuf, MAXBYTE);  /* 驱动要输出R3的缓存地址，这里作为对照验证 */
        DWORD dwBytes = 0; /* 缓冲区写进去的数据个数 */
        BOOL bRet = DeviceIoControl(hFile, 100, szInBuf, sizeof(szInBuf), szOutBuf, sizeof(szOutBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("DeviceIoControl");
        }
        else
        {
            // 显示结果
            printf("bRet:%d  dwBytes:%d  szOutBuf:%s\n", bRet, dwBytes, szOutBuf);
        }
 
        // 控制设备
        // 关闭设备
        CloseHandle(hFile);
    }
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

sample.cpp 的DispatchControl函数

NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
    /*
        类似函数调用，要给下一层驱动传参数，参数：有的分开，有的共用；
        共用参数放到了IRP里了；
        不共用的参数，都会有自己的内存空间==》"IRP堆栈"   （ 缓冲区大小 控制码......）
        然后要向IO管理器获取到IRP堆栈(要的是这层驱动的irp堆栈地址)，参数给irp，因为IRP堆栈就放在IRP后面；
 
        IoGetCurrentIrpStackLocation(Irp); 传参是irp,因为irp堆栈放到irp后面；
        但是不知道拿到那一层，自己不能去拿到这个地址，这是系统来拿，R3的其他参数都在这里main
        不同的回调函数会有不同的行为，IoGetCurrentIrpStackLocation返回值里是共用体；
    */
    PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
    PVOID pUserBuffer = Irp->UserBuffer;
    PVOID pType3InputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
    ULONG uInputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
    ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
    ULONG uOutputBufferLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    DbgPrint("51[asm][%s:%d] uIoControlCode:%08x  pUserBuffer:%p  pType3InputBuffer:%p", __FUNCTION__, __LINE__, uIoControlCode, pUserBuffer, pType3InputBuffer);
    DbgPrint("51[asm][%s:%d] uInputBufferLength:%d  uOutputBufferLength:%d", __FUNCTION__, __LINE__, uInputBufferLength, uOutputBufferLength);
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    /*
        1. 这个函数表示 请求是否结束
        2. 第一个参数：Irp(I/O Request Packet) 把所有的请求参数封装到这个结构体了
        3. 第二个参数，让挂起的线程快速恢复，把线程的优先级往上提；
        4. 当前IO_NO_INCREMENT: 不要提升优先级，什时候唤醒就什么时候结束
        5. 除了入口函数和卸载函数外，其他全部函数都是一样的，要这样处理；
    */
    IoCompleteRequest(Irp,IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
    //return IoCallDriver(Irp); // 分层驱动，这里进入下一层驱动来获取需要的值
}

 

4.4 现象分析：

这里只拿到一个缓冲区，另外一个缓冲区拿不到了，这就是为什么不要用R3的缓冲区，内核返回R3的缓冲区是有安全风险的

OS处理的原理：

R3输出缓冲区给驱动的过程：OS申请一个R0级别的内存，先把R3输出缓冲区的数据拷贝到OS里，驱动从R0申请的内存中再读数据； 驱动读取完数据之后要返回，路径相反；

而readfile参数是三环的，从内核里读数据，数据会被覆盖，无法读到数据，这是系统缓冲区；这就是为什么不能使用readfile

所以驱动中拿到这几个R3的数据没有意义的，是无效的参数；

file

 

4.5 实验验证： 内核读写数据的正确姿势

sample.cpp 的DispatchControl函数

NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
    /*
        类似函数调用，要给下一层驱动传参数，参数：有的分开，有的共用；
        共用参数放到了IRP里了；
        不共用的参数，都会有自己的内存空间==》"IRP堆栈"   （ 缓冲区大小 控制码......）
        然后要向IO管理器获取到IRP堆栈(要的是我这层驱动的irp堆栈地址)，参数给irp，因为IRP堆栈就放在IRP后面；
 
        IoGetCurrentIrpStackLocation(Irp); 传参是irp,因为irp堆栈放到irp后面；
        但是不知道拿到那一层，自己不能去拿到这个地址，这是系统来拿，R3的其他参数都在这里main
        不同的回调函数会有不同的行为，IoGetCurrentIrpStackLocation返回值里是共用体；
    */
    PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
    //PVOID pUserBuffer = Irp->UserBuffer;
    //PVOID pType3InputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
    //ULONG uInputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
    //ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
    //ULONG uOutputBufferLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    //DbgPrint("51[asm][%s:%d] uIoControlCode:%08x  pUserBuffer:%p  pType3InputBuffer:%p", __FUNCTION__, __LINE__, uIoControlCode, pUserBuffer, pType3InputBuffer);
    //DbgPrint("51[asm][%s:%d] uInputBufferLength:%d  uOutputBufferLength:%d", __FUNCTION__, __LINE__, uInputBufferLength, uOutputBufferLength);
 
    /*
      内核中读写数据：
        获取输出缓冲区的大小(地址在高2G), 
        数据的读写都是在这里进行
        系统会让这里的缓冲区大小和R3输出缓冲区一样大
    */ 
    PVOID pSystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    ULONG uLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    DbgPrint("51[asm][%s:%d] pSystemBuffer:%p uLength:%d", __FUNCTION__, __LINE__, pSystemBuffer, uLength);
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    /*
        1. 这个函数表示 请求是否结束
        2. 第一个参数：Irp(I/O Request Packet) 把所有的请求参数疯转到这个结构体了
        3. 第二个参数，让挂起的线程快速恢复，把线程的优先级往上提；
        4. 当前IO_NO_INCREMENT: 不要提升优先级，什时候唤醒就什么时候结束
        5. 除了入口函数和卸载函数外，其他全部函数都是一样的，要这样处理；
    */
    IoCompleteRequest(Irp,IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
    //return IoCallDriver(Irp); // 分层驱动，这里进入下一层驱动来获取需要的值
}

 

4.6 结果分析

输出了高2G的地址

file

 

4.7 尝试读写内核数据

R3传给驱动"hello",驱动回复"word".

Ring3.cpp 的main函数

int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("C:\\Documents and Settings\\cobb\\桌面\\sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        showErr("CreateFile");
    }
    else
    {
        printf("hFile:%p \n", hFile);
        char szInBuf[MAXBYTE] = { 0 };
        char szOutBuf[MAXBYTE] = { "hello" };
        printf("szInBuf:%p  szOutBuf:%p size:%d\n", szInBuf, szOutBuf, MAXBYTE);  /* 驱动要输出R3的缓存地址，这里作为对照验证 */
        DWORD dwBytes = 0; /* 缓冲区写进去的数据个数 */
        BOOL bRet = DeviceIoControl(hFile, 100, szInBuf, sizeof(szInBuf), szOutBuf, sizeof(szOutBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("DeviceIoControl");
        }
        else
        {
            // 显示结果
            printf("bRet:%d  dwBytes:%d  szInBuf:%s\n", bRet, dwBytes, szInBuf);
        }
 
        // 控制设备
        // 关闭设备
        CloseHandle(hFile);
    }
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

sample.cpp 的DispatchControl函数

NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
    /*
        类似函数调用，要给下一层驱动传参数，参数：有的分开，有的共用；
        共用参数放到了IRP里了；
        不共用的参数，都会有自己的内存空间==》"IRP堆栈"   （ 缓冲区大小 控制码......）
        然后要向IO管理器获取到IRP堆栈(要的是我这层驱动的irp堆栈地址)，参数给irp，因为IRP堆栈就放在IRP后面；
 
        IoGetCurrentIrpStackLocation(Irp); 传参是irp,因为irp堆栈放到irp后面；
        但是不知道拿到那一层，自己不能去拿到这个地址，这是系统来拿，R3的其他参数都在这里main
        不同的回调函数会有不同的行为，IoGetCurrentIrpStackLocation返回值里是共用体；
    */
    PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
    //PVOID pUserBuffer = Irp->UserBuffer;
    //PVOID pType3InputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
    //ULONG uInputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
    //ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
    //ULONG uOutputBufferLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    //DbgPrint("51[asm][%s:%d] uIoControlCode:%08x  pUserBuffer:%p  pType3InputBuffer:%p", __FUNCTION__, __LINE__, uIoControlCode, pUserBuffer, pType3InputBuffer);
    //DbgPrint("51[asm][%s:%d] uInputBufferLength:%d  uOutputBufferLength:%d", __FUNCTION__, __LINE__, uInputBufferLength, uOutputBufferLength);
 
    /*
      内核中读写数据：
        获取输出缓冲区的大小(地址在高2G), 
        数据的读写都是在这里进行
        系统会让这里的缓冲区大小和R3输出缓冲区一样大
        不要在Ring0下访问Ring3地址，会产生安全问题
    */ 
    PVOID pSystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    ULONG uLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
    ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
 
    DbgPrint("51[asm][%s:%d] uIoControlCode:%08x pSystemBuffer:%p uLength:%d", __FUNCTION__, __LINE__, 
        uIoControlCode, pSystemBuffer, uLength);
 
    switch (uIoControlCode)
    {
    case 100:
        DbgPrint("51[asm][%s:%d] Enum Process pid:%s", __FUNCTION__, __LINE__, pSystemBuffer);
        RtlStringCchCopyA((LPSTR)pSystemBuffer, uLength, "word"); //如果要向R3写数据，也是写入这个缓存中
        break;
    case 200:
        break;
    default:
        break;
    }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = uLength;  // 返回值的长度要返回去
 
    /*
        1. 这个函数表示 请求是否结束
        2. 第一个参数：Irp(I/O Request Packet) 把所有的请求参数疯转到这个结构体了
        3. 第二个参数，让挂起的线程快速恢复，把线程的优先级往上提；
        4. 当前IO_NO_INCREMENT: 不要提升优先级，什时候唤醒就什么时候结束
        5. 除了入口函数和卸载函数外，其他全部函数都是一样的，要这样处理；
    */
    IoCompleteRequest(Irp,IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
    //return IoCallDriver(Irp); // 分层驱动，这里进入下一层驱动来获取需要的值
}

 

4.8 结果分析

数据没有读到，也没有返回回去，这是因为控制码的原因，控制码的定义是有规范的

file

微软定义一个宏 CTL_CODE ，来表示控制码，可查看文档；

 

4.9 控制码讲解

编写控制函数的第一步就是要定义控制码(也就是定义一套自己的控制码)

控制码从3环的API可以看出它是一个整型;而且控制码是有规范的,不能胡乱定义.

file

这么定义控制码是很麻烦的,所以微软提供了一个宏来完成控制码的定义

示例:
#define IOCTL_GET_REG1 CTL_CODE(DeviceType, Function, Method, Access) 只需要填写上这四个参数就行了
 
DeviceType:(DeviceType)设备类型;内核驱动就写FILE_DEVICE_UNKNOWN就行了
Function:(FunctionCode)控制码;可以定义自己的控制码,但是要大于0x800;(0x800以下被微软保留使用了)
Method:(TransferType);通信方式
Access:(RequiredAccess)访问权限;就是读写的权限,一般给所有权限FILE_ANY_ACCESS;
 
定义好以后就是这样
#define IOCTL_GET_REG1 CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_NEITHER,FILE_ANY_ACCESS)
#define IOCTL_GET_REG2 CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_NEITHER,FILE_ANY_ACCESS)
 
控制码会越来越多,所以一般我们还会再套一个宏,方便后期的修改.
#define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_NEITHER,FILE_ANY_ACCESS)
#define IOCTL_GET_REG1 MY_CTL_CODE(0x801)
#define IOCTL_GET_REG2 MY_CTL_CODE(0x802)
 
或者再多加一个宏
#define MY_CODE_BASE 0x800
#define MY_CTL_CODE(code) CTL_CODE(FILE_DEVICE_UNKNOWN,MY_CODE_BASE + code,METHOD_NEITHER,FILE_ANY_ACCESS)
#define IOCTL_GET_REG1 MY_CTL_CODE(0)
#define IOCTL_GET_REG2 MY_CTL_CODE(1)

控制码不按格式定义的话,驱动可能收不到,或者收到后直接系统蓝屏

 

4.10 实验验证：通过控制码的数据读写

Ring3.cpp 的main函数和添加的宏

#include <stdio.h>
#include <windows.h>
#include <WinIoCtl.h> /* use CTL_CODE */
 
// 参数2：Values of less than 0x800 are reserved for Microsoft
// 参数3：METHOD_BUFFERED表示操作系统来创建缓冲区
#define IOCTL_ENUM_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED , FILE_ANY_ACCESS)
#define IOCTL_KILL_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED , FILE_ANY_ACCESS)
 
// 中间部分省略 ...
 
int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("C:\\Documents and Settings\\cobb\\桌面\\sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        showErr("CreateFile");
    }
    else
    {
        printf("hFile:%p \n", hFile);
        char szInBuf[MAXBYTE] = { 0 };
        char szOutBuf[MAXBYTE] = { "hello" };
        printf("szInBuf:%p  szOutBuf:%p size:%d\n", szInBuf, szOutBuf, MAXBYTE);  /* 驱动要输出R3的缓存地址，这里作为对照验证 */
        DWORD dwBytes = 0; /* 缓冲区写进去的数据个数 */
        BOOL bRet = DeviceIoControl(hFile, IOCTL_ENUM_PROCESS, szInBuf, sizeof(szInBuf), szOutBuf, sizeof(szOutBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("DeviceIoControl");
        }
        else
        {
            // 显示结果
            printf("bRet:%d  dwBytes:%d  szInBuf:%s szOutBuf:%s\n", bRet, dwBytes, szInBuf, szOutBuf);
        }
 
        // 控制设备
        // 关闭设备
        CloseHandle(hFile);
    }
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

sample.h

#pragma once
 
#include <ntddk.h>
#include <Wdm.h>
#include <Ntstrsafe.h>
 
#define DEVICE_NAME L"\\Device\\51asmMark"
#define SYMBOL_NAME L"\\DosDevices\\51asmMark"
//#define SYMBOL_NAME L"\\??\\51asmMark"
 
// 参数2：Values of less than 0x800 are reserved for Microsoft
// 参数3：METHOD_BUFFERED表示操作系统来创建缓冲区
#define IOCTL_ENUM_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED , FILE_ANY_ACCESS)
#define IOCTL_KILL_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED , FILE_ANY_ACCESS)
 
VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT     DriverObject, PUNICODE_STRING    RegistryPath);
 
NTSTATUS DispatchCreat(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchClose(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchRead(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchWrite(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchControl(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);

sample.cpp 的DispatchControl函数

NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
    /*
        类似函数调用，要给下一层驱动传参数，参数：有的分开，有的共用；
        共用参数放到了IRP里了；
        不共用的参数，都会有自己的内存空间==》"IRP堆栈"   （ 缓冲区大小 控制码......）
        然后要向IO管理器获取到IRP堆栈(要的是我这层驱动的irp堆栈地址)，参数给irp，因为IRP堆栈就放在IRP后面；
 
        IoGetCurrentIrpStackLocation(Irp); 传参是irp,因为irp堆栈放到irp后面；
        但是不知道拿到那一层，自己不能去拿到这个地址，这是系统来拿，R3的其他参数都在这里main
        不同的回调函数会有不同的行为，IoGetCurrentIrpStackLocation返回值里是共用体；
    */
    PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
    //PVOID pUserBuffer = Irp->UserBuffer;
    //PVOID pType3InputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
    //ULONG uInputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
    //ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
    //ULONG uOutputBufferLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    //DbgPrint("51[asm][%s:%d] uIoControlCode:%08x  pUserBuffer:%p  pType3InputBuffer:%p", __FUNCTION__, __LINE__, uIoControlCode, pUserBuffer, pType3InputBuffer);
    //DbgPrint("51[asm][%s:%d] uInputBufferLength:%d  uOutputBufferLength:%d", __FUNCTION__, __LINE__, uInputBufferLength, uOutputBufferLength);
 
    /*
      内核中读写数据：
        获取输出缓冲区的大小(地址在高2G), 
        数据的读写都是在这里进行
        系统会让这里的缓冲区大小和R3输出缓冲区一样大
        不要在Ring0下访问Ring3地址，会产生安全问题
    */ 
    PVOID pSystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    ULONG uLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
    ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
 
    DbgPrint("51[asm][%s:%d] uIoControlCode:%08x pSystemBuffer:%p uLength:%d", __FUNCTION__, __LINE__, 
        uIoControlCode, pSystemBuffer, uLength);
 
    switch (uIoControlCode)
    {
    case IOCTL_ENUM_PROCESS:
        DbgPrint("51[asm][%s:%d] Enum Process pid:%p", __FUNCTION__, __LINE__, pSystemBuffer);
        RtlStringCchCopyA((LPSTR)pSystemBuffer, uLength, "word"); //如果要向R3写数据，也是写入这个缓存中
        break;
    case IOCTL_KILL_PROCESS:
        DbgPrint("51[asm][%s:%d] Kill Process pid:%p", __FUNCTION__, __LINE__, pSystemBuffer);
        break;
    default:
        break;
    }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = uLength;  // 返回值的长度要返回去
 
    /*
        1. 这个函数表示 请求是否结束
        2. 第一个参数：Irp(I/O Request Packet) 把所有的请求参数疯转到这个结构体了
        3. 第二个参数，让挂起的线程快速恢复，把线程的优先级往上提；
        4. 当前IO_NO_INCREMENT: 不要提升优先级，什时候唤醒就什么时候结束
        5. 除了入口函数和卸载函数外，其他全部函数都是一样的，要这样处理；
    */
    IoCompleteRequest(Irp,IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
    //return IoCallDriver(Irp); // 分层驱动，这里进入下一层驱动来获取需要的值
}

 

4.11 结果分析

驱动没有操作R3的地址，缓冲区地址是高2G,并且成功输出"word"

file

Ring3.cpp 的main函数

也可以这么做，这个做法类似 管道 ，匿名管道；可进可出

int main()
{
    // 部分省略 ....
 
        char szBuf[MAXBYTE] = { "hello" };
        printf("szBuf:%p size:%d\n", szBuf, MAXBYTE);  /* 驱动要输出R3的缓存地址，这里作为对照验证 */
        DWORD dwBytes = 0; /* 缓冲区写进去的数据个数 */
        BOOL bRet = DeviceIoControl(hFile, IOCTL_ENUM_PROCESS, szBuf, sizeof(szBuf), szBuf, sizeof(szBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("DeviceIoControl");
        }
        else
        {
            // 显示结果
            printf("bRet:%d  dwBytes:%d  szBuf:%s\n", bRet, dwBytes, szBuf);
        }
 
        // 部分省略 ....
 
    return 0;
}

 

4.12 同步问题

  • 在驱动里操作全局变量也是会有同步问题的
  • 可以直接用临界区来搞定
  • 必须上个同步,要不然有两个线程同时操作就完了
KeEnterCriticalRegion();  //进入临界区
 // ...  这里就是操作全局变量,对象的代码
KeLeaveCriticalRegion();  //退出临界区
 
//可以获取一下进程ID,来测试一下
PsGetCurrentProcessId();

				

					
				

				

					
				

				

					
				

				

					
				

			
    KeEnterCriticalRegion();
 
    switch (uIoControlCode)
    {
    case IOCTL_ENUM_PROCESS:
        DbgPrint("51[asm][%s:%d] Enum Process pid:%p", __FUNCTION__, __LINE__, pSystemBuffer);
        RtlStringCchCopyA((LPSTR)pSystemBuffer, uLength, "word"); //如果要向R3写数据，也是写入这个缓存中
        break;
    case IOCTL_KILL_PROCESS:
        DbgPrint("51[asm][%s:%d] Kill Process pid:%p", __FUNCTION__, __LINE__, pSystemBuffer);
        break;
    default:
        break;
    }
 
  KeLeaveCriticalRegion();

 
 

0x05 完整代码记录

Ring3.cpp

#include <stdio.h>
#include <windows.h>
#include <WinIoCtl.h> /* use CTL_CODE */
 
// 参数2：Values of less than 0x800 are reserved for Microsoft
// 参数3：METHOD_BUFFERED表示操作系统来创建缓冲区
#define IOCTL_ENUM_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED , FILE_ANY_ACCESS)
#define IOCTL_KILL_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED , FILE_ANY_ACCESS)
 
struct ProcessInfo
{
    int pid;
    char name[256];
};
/*
如果没有R3得程序怎么加载呢？
微软有个inf文件，这个东西可以安装，在微软的官方文档中有说明inf内容怎么写；
 
OS会解析inf这个配置文件，帮助动态加载驱动
例： 如果硬件需要开机启动加载，微软再开机时会自动加载inf文件
 
驱动加载的方式：
1. inf文件来加载
2. 动态加载（服务）
 
创建服务就是安装驱动（很多软件都可以使用打阴界，那么就可调用打印机的驱动，驱动的角色是服务），也就是需要4个api就可以完成这些工作；
创建服务
启动服务
停止服务
卸载服务
*/
 
void showErr(const char *name)
{
    LPVOID lpMsgBuf;
    DWORD dwErr = GetLastError();
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dwErr,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
        (LPTSTR)&lpMsgBuf,
        0,
        NULL
    );
    printf("[%s] Error Code:%d  Msg:%s", name, dwErr, (LPCTSTR)lpMsgBuf);
    //MessageBox(NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION);
    // Free the buffer.
    LocalFree(lpMsgBuf);
}
 
int LoadDriver(const char *pszPath, const char *pszServiceName)
{   
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__,hSCM);
 
    hService = CreateService(hSCM, pszServiceName, pszServiceName, SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER,
        SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL, pszPath, NULL, NULL, NULL, NULL, NULL);
    if (hService == NULL)
    {
        //if (GetLastError() == 1073)  // 当前服务已经存在，那就直接打开用
        if (GetLastError() == ERROR_SERVICE_EXISTS)
        {
            hService = OpenService(hSCM, pszServiceName, SERVICE_ALL_ACCESS);
            if (hService == NULL)
            {
                showErr("OpenService");
                goto SAFE_EXIT;
            }
            printf("[%s] OpenService Ok hService:%p \n", __FUNCTION__, hService);
        }
        else
        {
            showErr("CreateService");
            goto SAFE_EXIT;
        }
    }
 
    printf("[%s] CreateService Ok hService:%p \n", __FUNCTION__, hService);
    /*  CreateService 使用分析
    SC_HANDLE CreateService(  
      SC_HANDLE hSCManager,       // handle to SCM database  服务是由服务管理器来管理，这里拿到服务管理器；SCM（service control manager） ，因为是本地，前两个为NULL，最后一个是权限，如果选择所有权限，就是既能创建又能删除
      LPCTSTR lpServiceName,      // name of service to start
      LPCTSTR lpDisplayName,      // display name
      DWORD dwDesiredAccess,      // type of access to service
      DWORD dwServiceType,        // type of service
      DWORD dwStartType,          // when to start service    五种启动方式，选第3个，重启系统后就不再加载
      DWORD dwErrorControl,       // severity of service failure
      LPCTSTR lpBinaryPathName,   // name of binary file
      LPCTSTR lpLoadOrderGroup,   // name of load ordering group
      LPDWORD lpdwTagId,          // tag identifier 
      LPCTSTR lpDependencies,     // array of dependency names
      LPCTSTR lpServiceStartName, // account name
      LPCTSTR lpPassword          // account password);
    */
 
    if (!StartService(hService, NULL, NULL)) /* 后两个参数，因为是驱动的服务，所以三环这里给NULL */
    {
        showErr("StartService");
        goto SAFE_EXIT;
    }
 
    iRet = 0;
 
SAFE_EXIT:
    if (hService != NULL)
    {
        if (CloseServiceHandle(hService) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    if (hSCM != NULL)
    {
        if (CloseServiceHandle(hSCM) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    return iRet;
}
 
int UnLoadDriver(const char * pszServiceName)
{
    SC_HANDLE hSCM = NULL;
    SC_HANDLE hService = NULL;
    int iRet = -1;
    SERVICE_STATUS oldState = { 0 };
 
    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        showErr("OpenSCManager");
        return 0;
    }
 
    printf("[%s] OpenSCManager Ok hSCM:%p \n", __FUNCTION__, hSCM);
 
    hService = OpenService(hSCM, pszServiceName, SERVICE_ALL_ACCESS);
    if (hService == NULL)
    {
        showErr("OpenService");
        goto SAFE_EXIT;
    }
    printf("[%s] OpenService Ok hService:%p \n", __FUNCTION__, hService);
 
    /* 
        1. DeleteService之前，如果服务正在运行怎么办？ 那就是先暂停服务  
        2 .OS 的peding状态：向硬件发送的请求还没有完成，此时驱动卸不掉，停不掉(如果驱动中的派遣函数没有IoCompleteRequest完成请求，就会有这种情况)
    */
    if (!ControlService(hService, SERVICE_CONTROL_STOP, &oldState))
    {
        if (GetLastError() == ERROR_SERVICE_NOT_ACTIVE)  // 服务没有启动的时候 判断错误码1062,那就启动服务；
        {
            printf("[%s] ControlService not active  hService:%p \n", __FUNCTION__, hService);
        }
        else if (GetLastError() == ERROR_DEPENDENT_SERVICES_RUNNING)  // peding 状态
        {
            printf("[%s] Please reboot system hService:%p \n", __FUNCTION__, hService);
            goto SAFE_EXIT;
        }
        else
        {
            showErr("ControlService");
            goto SAFE_EXIT;
        }
    }
 
    printf("[%s] ControlService stop service Ok hService:%p \n", __FUNCTION__, hService);
 
    if (!DeleteService(hService))
    {
        showErr("DeleteService");
        goto SAFE_EXIT;
    }
 
    printf("[%s] DeleteService Ok hService:%p \n", __FUNCTION__, hService);
 
    iRet = 0;
 
SAFE_EXIT:
    if (hService != NULL)
    {
        if (CloseServiceHandle(hService) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    if (hSCM != NULL)
    {
        if (CloseServiceHandle(hSCM) == 0)
        {
            showErr("CloseServiceHandle");
        }
    }
 
    return iRet;
}
 
int main()
{
    printf("[%s] Install Driver ... \n", __FUNCTION__);
 
    LoadDriver("C:\\Documents and Settings\\cobb\\桌面\\sample2.sys", "51asmMark");
    //if (LoadDriver("sample2.sys", "51asmMark") < 0)
    //    return 0;
    printf("[%s] Install Driver Ok \n", __FUNCTION__);
 
    // 打开设备, 这里文件的路径就是在驱动中创建的设备名字
    HANDLE  hFile = CreateFile("\\\\.\\\\51asmMark", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        showErr("CreateFile");
    }
    else
    {
        printf("hFile:%p \n", hFile);
#if 0
        // 读写设备
        char acBuf[60] = { 0 };
        printf("acBuf:%p\n", acBuf);  /* 驱动要输出R3的缓存地址，这里作为对照 */
        DWORD dwBytes = 0;
        BOOL bRet = ReadFile(hFile, acBuf, sizeof(acBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("ReadFile");
        }
        else
        {
            printf("bRet:%d  dwBytes:%d  acBuf:%s\n", bRet, dwBytes, acBuf);
        }
#endif
        char szBuf[MAXBYTE] = { "hello" };
        printf("szBuf:%p size:%d\n", szBuf, MAXBYTE);  /* 驱动要输出R3的缓存地址，这里作为对照验证 */
        DWORD dwBytes = 0; /* 缓冲区写进去的数据个数 */
        BOOL bRet = DeviceIoControl(hFile, IOCTL_ENUM_PROCESS, szBuf, sizeof(szBuf), szBuf, sizeof(szBuf), &dwBytes, NULL);
        if (!bRet)
        {
            showErr("DeviceIoControl");
        }
        else
        {
            // 显示结果
            printf("bRet:%d  dwBytes:%d  szBuf:%s\n", bRet, dwBytes, szBuf);
        }
 
        // 控制设备
        // 关闭设备
        CloseHandle(hFile);
    }
 
    UnLoadDriver("51asmMark");
    printf("[%s] UnLoadDriver Driver Ok \n", __FUNCTION__);
 
    system("pause");
    return 0;
}

sample.h

#pragma once
 
#include <ntddk.h>
#include <Wdm.h>
#include <Ntstrsafe.h>
 
#define DEVICE_NAME L"\\Device\\51asmMark"
#define SYMBOL_NAME L"\\DosDevices\\51asmMark"
//#define SYMBOL_NAME L"\\??\\51asmMark"
 
// 参数2：Values of less than 0x800 are reserved for Microsoft
// 参数3：METHOD_BUFFERED表示操作系统来创建缓冲区
#define IOCTL_ENUM_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED , FILE_ANY_ACCESS)
#define IOCTL_KILL_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED , FILE_ANY_ACCESS)
 
VOID Unload(__in struct _DRIVER_OBJECT* DriverObject);
extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT     DriverObject, PUNICODE_STRING    RegistryPath);
 
NTSTATUS DispatchCreat(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchClose(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchRead(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchWrite(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
NTSTATUS DispatchControl(struct _DEVICE_OBJECT* DeviceObject, struct _IRP* Irp);
 
/*
IRP_MJ_DEVICE_CONTROL： 读写可以控制摄像头的打开关闭，控制则可以控制其他的，如：摄像头的旋转...[除了硬件厂商，其他人可不知道怎么让摄像头旋转]
是用来写不通用的功能； 读写的参数需要传一个缓冲区和一个长度，而control的参数，微软不知道传什么参数
control就是要传一些只有硬件厂家才能解析的数据
 
显卡（NVIDIA）的驱动安装之后,R3上有界面,设置显卡的一些特性，会调用DispatchControl这个函数，这里可以做一些硬件独有的功能；
 
有一种软件可以拿到硬件的各种信息：有没有可能把control的参数逆清楚，模仿参数发送数据，这样就可以拿到硬件的各种信息了
前几天在闲鱼买了太Macmini主机，最担心的就是有人通过这种方式来修改主机里的信息，如：8+256的主机刷成32+2t的，买家需要反复擦亮眼睛奥；
 
*/

sample.cpp

#include "sample.h"
 
char g_zMsg[] = "hello"; // 代表OS的任何数据
 
VOID Unload(__in struct _DRIVER_OBJECT* DriverObject)
{
    UNREFERENCED_PARAMETER(DriverObject);
 
    /*  删除符号链接 */
    UNICODE_STRING strDosDeviceName;
    RtlInitUnicodeString(&strDosDeviceName, SYMBOL_NAME);
    IoDeleteSymbolicLink(&strDosDeviceName);
 
    /* 驱动对象和设备对象绑定之后，设备对象会被记录到这里 DriverObject->DeviceObject; 需要判断对象是否绑定成功*/
    if (DriverObject->DeviceObject != NULL)
    {
        IoDeleteDevice(DriverObject->DeviceObject);
        DbgPrint("51[asm][%s:%d] IoDeleteDevice OK!",__FUNCTION__,__LINE__);
    }
 
    DbgPrint("51[asm][%s:%d] Unload", __FUNCTION__, __LINE__);
}
 
NTSTATUS DriverEntry(
    PDRIVER_OBJECT     DriverObject,   /* PDRIVER_OBJECT 这个结构体保存了驱动的所有信息 */
    PUNICODE_STRING    RegistryPath)
{
    UNREFERENCED_PARAMETER(DriverObject);
    UNREFERENCED_PARAMETER(RegistryPath);
 
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* 注册派遣函数 */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreat;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
    DriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = DispatchWrite;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchControl;
 
    /* rtl: run time library  C库(运行库)  微软重新做的C库，这个库更加安全； 这里做字符串使用的初始化 */
    UNICODE_STRING userDevName;
    RtlInitUnicodeString(&userDevName, DEVICE_NAME);
 
    /* 绑定设备 */
    PDEVICE_OBJECT pDeviceObj = NULL;
    Status = IoCreateDevice(DriverObject, 0, &userDevName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN | FILE_READ_ONLY_DEVICE | FILE_WRITE_ONCE_MEDIA, FALSE, &pDeviceObj);
    if (!NT_SUCCESS(Status))  /* 函数返回值统一是Status，这里安全性检查 */
    {
        DbgPrint("51[asm][%s:%d] IoCreateDevice err status:%p", __FUNCTION__, __LINE__, Status);
        DriverObject->DriverUnload = Unload; /* 卸载函数中一定要删除设备，否则卸载后无法再次启动，提示设备名已存在 */
        return Status;
    }
    /*  IoCreateDevice 参数填写注意事项：
    PDEVICE_OBJECT pDeviceObj = NULL;  //  结构体里的 PVOID DeviceExtension;  可以申请空间大小
    IoCreateDevice(
            IN PDRIVER_OBJECT  DriverObject,      // 驱动对象
            IN ULONG  DeviceExtensionSize,        // 设备扩展： 微软定义了一个结构体 PDEVICE_OBJECT，如果硬件希望在结构体中增加一些成员，这里需要写成员的大小，OS会申请一段内存空间，那就就可以无限的给这个结构体增加成员；这里是额外申请一些空间
        IN PUNICODE_STRING  DeviceName  OPTIONAL, // 给设备名字是必须唯一的,注册的名字和其他的冲突了，会创建失败；可以给个NULL，微软会随机一个名字；  文档中说明设备名必须是有格式的： \Device\DeviceName
                                                  // 注意： PUNICODE_STRING  这里的字符串Unicode字符串，字符串需要经过处理
            IN DEVICE_TYPE  DeviceType,           // 选择为止设备就行，但是一定得给，否则无法通讯  FILE_DEVICE_UNKNOWN
            IN ULONG  DeviceCharacteristics,      // 权限
            IN BOOLEAN  Exclusive,                // 关键参数，是否独占的方式,  独占： 只允许一个人打开这个设备  (杀毒软件会独占)
            OUT PDEVICE_OBJECT * DeviceObject
        );
 
    */
 
    /* 创建符号链接 */
    UNICODE_STRING strDosDeviceName;
    RtlInitUnicodeString(&strDosDeviceName, SYMBOL_NAME);
    Status = IoCreateSymbolicLink(&strDosDeviceName, &userDevName); /* R3使用的名字在文档中选：MS-DOS Device Names     R0使用的名字在文档中选：NT Device Names  */
    if (!NT_SUCCESS(Status))  
    {
        /* 驱动对象和设备对象绑定之后，设备对象会被记录到这里 DriverObject->DeviceObject; 需要判断对象是否绑定成功*/
        if (DriverObject->DeviceObject != NULL)
        {
            /*  删除符号链接 */
            IoDeleteSymbolicLink(&strDosDeviceName);
 
            IoDeleteDevice(DriverObject->DeviceObject);
            DbgPrint("51[asm][%s:%d] IoCreateSymbolicLink err!", __FUNCTION__, __LINE__);
        }
 
        return Status;
    }
 
    DriverObject->DriverUnload = Unload;
    DbgPrint("51[asm][%s:%d] hello word! DriverEntry:%p,Unload:%p,&status:%p,pDeviceObj:%p", __FUNCTION__, __LINE__, DriverEntry, Unload, &Status,&pDeviceObj);
 
    return Status;
}
 
NTSTATUS DispatchCreat(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
 
    // 这样返回的数据才是完整的
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
NTSTATUS DispatchClose(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
 
    // 这样返回的数据才是完整的
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
NTSTATUS DispatchRead(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
 
    /* 验证这里是R3的缓存地址，输出一下 */
    DbgPrint("51[asm][%s:%d] Irp->UserBuffer:%p", __FUNCTION__, __LINE__, Irp->UserBuffer); 
 
    RtlCopyMemory(Irp->UserBuffer,g_zMsg,sizeof(g_zMsg));
 
    Irp->IoStatus.Status = STATUS_SUCCESS;        /* 告诉R3返回的状态 */
    Irp->IoStatus.Information = sizeof(g_zMsg);   /* 告诉R3读取的字节数 */
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;                      /* R3的ReadFile的返回值 */
}
 
NTSTATUS DispatchWrite(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
    // 这样返回的数据才是完整的
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
NTSTATUS DispatchControl(_DEVICE_OBJECT* DeviceObject, _IRP* Irp)
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    DbgPrint("51[asm][%s:%d]", __FUNCTION__, __LINE__);
    /*
        类似函数调用，要给下一层驱动传参数，参数：有的分开，有的共用；
        共用参数放到了IRP里了；
        不共用的参数，都会有自己的内存空间==》"IRP堆栈"   （ 缓冲区大小 控制码......）
        然后要向IO管理器获取到IRP堆栈(要的是我这层驱动的irp堆栈地址)，参数给irp，因为IRP堆栈就放在IRP后面；
 
        IoGetCurrentIrpStackLocation(Irp); 传参是irp,因为irp堆栈放到irp后面；
        但是不知道拿到那一层，自己不能去拿到这个地址，这是系统来拿，R3的其他参数都在这里main
        不同的回调函数会有不同的行为，IoGetCurrentIrpStackLocation返回值里是共用体；
    */
    PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
    //PVOID pUserBuffer = Irp->UserBuffer;
    //PVOID pType3InputBuffer = pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
    //ULONG uInputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
    //ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
    //ULONG uOutputBufferLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    //DbgPrint("51[asm][%s:%d] uIoControlCode:%08x  pUserBuffer:%p  pType3InputBuffer:%p", __FUNCTION__, __LINE__, uIoControlCode, pUserBuffer, pType3InputBuffer);
    //DbgPrint("51[asm][%s:%d] uInputBufferLength:%d  uOutputBufferLength:%d", __FUNCTION__, __LINE__, uInputBufferLength, uOutputBufferLength);
 
    /*
      内核中读写数据：
        获取输出缓冲区的大小(地址在高2G), 
        数据的读写都是在这里进行
        系统会让这里的缓冲区大小和R3输出缓冲区一样大
        不要在Ring0下访问Ring3地址，会产生安全问题
    */ 
    PVOID pSystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    ULONG uLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
    ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
 
    DbgPrint("51[asm][%s:%d] uIoControlCode:%08x pSystemBuffer:%p uLength:%d", __FUNCTION__, __LINE__, 
        uIoControlCode, pSystemBuffer, uLength);
 
    switch (uIoControlCode)
    {
    case IOCTL_ENUM_PROCESS:
        DbgPrint("51[asm][%s:%d] Enum Process pid:%p", __FUNCTION__, __LINE__, pSystemBuffer);
        RtlStringCchCopyA((LPSTR)pSystemBuffer, uLength, "word"); //如果要向R3写数据，也是写入这个缓存中
        break;
    case IOCTL_KILL_PROCESS:
        DbgPrint("51[asm][%s:%d] Kill Process pid:%p", __FUNCTION__, __LINE__, pSystemBuffer);
        break;
    default:
        break;
    }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = uLength;  // 返回值的长度要返回去
 
    /*
        1. 这个函数表示 请求是否结束
        2. 第一个参数：Irp(I/O Request Packet) 把所有的请求参数疯转到这个结构体了
        3. 第二个参数，让挂起的线程快速恢复，把线程的优先级往上提；
        4. 当前IO_NO_INCREMENT: 不要提升优先级，什时候唤醒就什么时候结束
        5. 除了入口函数和卸载函数外，其他全部函数都是一样的，要这样处理；
    */
    IoCompleteRequest(Irp,IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
    //return IoCallDriver(Irp); // 分层驱动，这里进入下一层驱动来获取需要的值
}

兼容xp的插件安装

YY-Thunks – 让兼容 Windows 更轻松

windows内核
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																

							
							
						

																

							
							
						

										
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇 

                    

                    
			        推荐文章
		            

		            

							
R3和R0的交互(NT框架的使用)

							
							

							
win7/win8/win9/win11 配置双机调试环境