devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

WinIO3.0调用键盘实践-winxp、win7、win10下32位64位都适用

作者：不正经 | 2024-05-12 01:25:44

赞

踩

winio3.0

目录

 

准备

步骤

第一步：Windows系统开启测试模式（针对64位系统，32系统不需要）

第二步：WinIo64.sys安装签名（针对64位系统，32系统不需要）

第三步：Java代码及c++代码实现

 第四步：执行代码

准备

开发环境：winxp、win7、win10 32位及64位

开发语言：Java和c++

必要文件：WinIo32.dll、WinIo64.dll、WinIo32.sys、WinIo64.sys

步骤

（注：有些步骤的详细做法非常简单，如果不明白请问度哥）

第一步：Windows系统开启测试模式（针对64位系统，32系统不需要）

开启测试模式：cmd执行命令：bcdedit /set testsigning on 然后重启，电脑右下角出现测试模式......

关闭测试模式：cmd执行命令：bcdedit /set testsigning off 然后重启，电脑右下角测试模式消失

参考链接如下：

win10：https://jingyan.baidu.com/article/72ee561a724b74e16138df1c.html
win7、winxp:https://jingyan.baidu.com/article/acf728fd21c3e7f8e510a3ef.html

第二步：WinIo64.sys安装签名（针对64位系统，32系统不需要）

1、打开 WinIO64.sys的属性框，翻到“数字签名”选项卡，点击“详细信息”

2、在新出来的对话框中点击“查看证书”

3、在又新出来的对话框中点击“安装证书”

4、点击“下一步”，然后选择“将所有的证书放入下列存储”

5、点击浏览，选择“受信任的根证书发布机构”

6、点击“下一步”，然后点击“完成”

7、在弹出的“安全性警告”对话框中选择“是”，才能导入成功

8、重启电脑

第三步：Java代码及c++代码实现

网上有很多人使用jnative实现的,这里使用jna实现。jnative是在jna的基础上封装的有局限性。以下是maven依赖：

  1. <dependencies>
  2.    <dependency>
  3.       <groupId>net.java.dev.jna</groupId>
  4.       <artifactId>jna</artifactId>
  5.       <version>4.4.0</version>
  6.    </dependency>
  7.    <dependency>
  8.       <groupId>net.java.dev.jna</groupId>
  9.       <artifactId>jna-platform</artifactId>
  10.       <version>4.4.0</version>
  11.    </dependency>
  12.    <dependency>
  13.       <groupId>org.apache.commons</groupId>
  14.       <artifactId>commons-lang3</artifactId>
  15.       <version>3.9</version>
  16.    </dependency>
  17. </dependencies>

winio代码实现

  1. import com.sun.jna.Library;
  2. import com.sun.jna.Native;
  3. import com.sun.jna.Pointer;
  4. import com.sun.jna.WString;
  5. import com.sun.jna.win32.W32APIOptions;
  6.  
  7. /**
  8.  * author songxq
  9.  * date 2020/6/18
  10.  * description
  11.  */
  12. public interface WinIo extends Library {
  13.  
  14.     /**
  15.      * 系统架构32位或者64位
  16.      */
  17.     String ARCH = System.getProperty("os.arch");
  18.     /**
  19.      * 使用的winio版本
  20.      */
  21.     String WIN_IO_LIB_NAME = "x86".equals(ARCH) ? "WinIo32" : "WinIo64";
  22.  
  23.     WinIo INSTANCE = (WinIo) Native.loadLibrary(WIN_IO_LIB_NAME, WinIo.class, W32APIOptions.DEFAULT_OPTIONS);
  24.  
  25.     /**
  26.      * PS/2键盘的命令端口
  27.      */
  28.     int CONTROL_PORT = 0x64;
  29.     /**
  30.      * PS/2键盘的数据端口
  31.      */
  32.     int DATA_PORT = 0x60;
  33.  
  34.     /**
  35.      * 初始化winiolib库
  36.      * @param path	驱动文件绝对路径
  37.      * @return
  38.      */
  39.     boolean InitializeWinIo(WString path);
  40.  
  41.     /**
  42.      * 释放资源及开辟的内存空间
  43.      */
  44.     void ShutdownWinIo();
  45.  
  46.     /**
  47.      * 读数据
  48.      * 98/ME系列使用GetPortVal  NT/2000/XP系列可以使用_inp/_inpw/_inpd
  49.      * @param portAddr	io地址
  50.      * @param pPortVal	指针变量
  51.      * @param size 数据大小
  52.      * @return
  53.      */
  54.     boolean GetPortVal(int portAddr, Pointer pPortVal, int size);
  55.  
  56.     /**
  57.      * 写数据
  58.      * @param portAddr	io地址
  59.      * @param portVal	指针变量
  60.      * @param size	数据大小
  61.      * @return
  62.      */
  63.     boolean SetPortVal(int portAddr, int portVal, int size);
  64. }

键盘调用代码

  1.  
  2. import com.sun.jna.Memory;
  3. import com.sun.jna.Pointer;
  4. import com.sun.jna.WString;
  5.  
  6. import java.io.File;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.nio.file.Files;
  10. import java.nio.file.Paths;
  11. import java.nio.file.StandardCopyOption;
  12.  
  13. /**
  14.  * author songxq
  15.  * date 2020/6/18
  16.  * description
  17.  */
  18. public class VirtualKB {
  19.  
  20.     private static final WinIo WIN_IO = WinIo.INSTANCE;
  21.  
  22.     private static final String WIN_BASE_SYSTEM32 = "C:\\Windows\\System32";
  23.  
  24.     private static final String WINIO_INSTALL_PATH = "C:\\INSTALLWINIO";
  25.  
  26.     private static final String WINIO_INSTALL_EXE = "C:\\INSTALLWINIO\\InstallWinIo.exe";
  27.  
  28.     private static final String WIN_32_SYS = "WinIo32.sys";
  29.  
  30.     private static final String WIN_64_SYS = "WinIo64.sys";
  31.  
  32.     //keyame
  33.     public static final String Tab = "Tab";
  34.     public static final String Esc = "Esc";
  35.     public static final String Backspace = "Backspace";
  36.     public static final String Enter = "Enter";
  37.     public static final String LCtrl = "LCtrl";
  38.     public static final String LShift = "LShift";
  39.     public static final String RShift = "RShift";
  40.     public static final String LAlt = "LAlt";
  41.     public static final String Space = "Space";
  42.     public static final String CapsLock = "CapsLock";
  43.     public static final String F1 = "F1";
  44.     public static final String F2 = "F2";
  45.     public static final String F3 = "F3";
  46.     public static final String F4 = "F4";
  47.     public static final String F5 = "F5";
  48.     public static final String F6 = "F6";
  49.     public static final String F7 = "F7";
  50.     public static final String F8 = "F8";
  51.     public static final String F9 = "F9";
  52.     public static final String F10 = "F10";
  53.     public static final String F11 = "F11";
  54.     public static final String F12 = "F12";
  55.     public static final String NumLock = "NumLock";
  56.     public static final String ScrollLock = "ScrollLock";
  57.  
  58.  
  59.     static{
  60.         String x86 = "x86";
  61.         String driverName;
  62.         if (x86.equals(WinIo.ARCH)) {
  63.             driverName = WIN_BASE_SYSTEM32 + File.separator + WIN_32_SYS;
  64.         } else {
  65.             driverName = WIN_BASE_SYSTEM32 + File.separator + WIN_64_SYS;
  66.         }
  67.         if(!WIN_IO.InitializeWinIo(new WString(driverName))){
  68.             installSys();
  69.         }
  70.     }
  71.  
  72.     /**
  73.      * 等待缓冲区置空
  74.      */
  75.     private static void KBCWait4IBE() {
  76.         int val;
  77.         do {
  78.             Pointer p = new Memory(8);
  79.             if (!WIN_IO.GetPortVal(WinIo.CONTROL_PORT, p, 1)) {
  80.                 throw new RuntimeException("Cannot Get The Port!");
  81.             }
  82.             val = p.getInt(0);
  83.         } while ((0x2 & val) > 0);
  84.     }
  85.  
  86.  
  87.     private static void down(int key) {
  88.         KBCWait4IBE();
  89.         WIN_IO.SetPortVal(WinIo.CONTROL_PORT, 0xd2, 1);
  90.         KBCWait4IBE();
  91.         WIN_IO.SetPortVal(WinIo.DATA_PORT, key, 1);
  92.     }
  93.  
  94.     private static void up(int key) {
  95.         KBCWait4IBE();
  96.         WIN_IO.SetPortVal(WinIo.CONTROL_PORT, 0xd2, 1);
  97.         KBCWait4IBE();
  98.         WIN_IO.SetPortVal(WinIo.DATA_PORT, (key | 0x80), 1);
  99.     }
  100.  
  101.     private static void press(String[] words, long firstSleepTime, long sleepTime) throws Exception{
  102.         if (null == words || words.length == 0) {
  103.             throw new IllegalArgumentException("words Is NULL Or Empty");
  104.         }
  105.         int minSleepTime = 50;
  106.         if (sleepTime < minSleepTime) {
  107.             throw new IllegalArgumentException("SleepTime Less Than 50 ms");
  108.         }
  109.         if (firstSleepTime > 0) {
  110.             Thread.sleep(firstSleepTime);
  111.         }
  112.         for (String word : words) {
  113.             Integer vk = VirtualKBMapping.VK_MAP.get(word);
  114.             if (null == vk) {
  115.                 vk = VirtualKBMapping.NEED_SHIFT_VK.get(word);
  116.             }
  117.             if (null == vk) {
  118.                 throw new RuntimeException(word + " Not Support");
  119.             }
  120.             boolean needShift = word.length() == 1 && null != VirtualKBMapping.NEED_SHIFT_VK.get(word);
  121.             if (needShift) {
  122.                 down(VirtualKBMapping.VK_MAP.get("LShift"));
  123.             }
  124.             down(vk);
  125.             Thread.sleep(sleepTime);
  126.             up(vk);
  127.             if (needShift) {
  128.                 up(VirtualKBMapping.VK_MAP.get("LShift"));
  129.             }
  130.         }
  131.     }
  132.  
  133.     /**
  134.      * 键盘输入文本
  135.      * @param content 文本
  136.      * @param sleepTime 等待时间间隔
  137.      */
  138.     public static void inputStr(String content,long sleepTime) throws Exception {
  139.         if (null == content || content.length() == 0) {
  140.             throw new IllegalArgumentException("content Is NULL Or Empty");
  141.         }
  142.         char[] chars = content.toCharArray();
  143.         for (int i=0;i<chars.length;i++){
  144.             press(new String[]{String.valueOf(chars[i])},sleepTime,50);
  145.         }
  146.     }
  147.  
  148.     /**
  149.      * 键盘按键
  150.      * @param keyname 按键名称
  151.      * @param sleepTime 等待时间间隔
  152.      */
  153.     public static void pressKey(String keyname,long sleepTime) throws Exception {
  154.         if (null == keyname || keyname.length() == 0) {
  155.             throw new IllegalArgumentException("keyname Is NULL Or Empty");
  156.         }
  157.         press(new String[]{keyname},sleepTime,50);
  158.     }
  159.  
  160.     private static void extract(final String fileName, final String name) {
  161.         if (new File(fileName).exists()) {
  162.             return;
  163.         }
  164.         try(InputStream inputStream = VirtualKB.class.getResourceAsStream("/" + name)) {
  165.             Files.copy(inputStream, Paths.get(fileName), StandardCopyOption.REPLACE_EXISTING);
  166.         } catch (IOException e) {
  167.             e.printStackTrace();
  168.         }
  169.     }
  170.  
  171.     /**
  172.      * 执行sys驱动安装
  173.      */
  174.     public static void installSys() {
  175.         if (!new File(WINIO_INSTALL_EXE).exists()) {
  176.             if(!new File(WINIO_INSTALL_PATH).exists()){
  177.                 new File(WINIO_INSTALL_PATH).mkdirs();
  178.             }
  179.             extract(WINIO_INSTALL_EXE,"InstallWinIo.exe");
  180.         }
  181.         Runtime rn = Runtime.getRuntime();
  182.         Process p = null;
  183.         try {
  184.             p = rn.exec(WINIO_INSTALL_EXE);
  185.         } catch (Exception e) {
  186.             e.printStackTrace();
  187.         }
  188.     }
  189. }

虚拟键盘映射代码

  1.  
  2. import org.apache.commons.lang3.StringUtils;
  3.  
  4. import java.util.Arrays;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7.  
  8. /**
  9.  * author songxq
  10.  * date 2020/6/18
  11.  * description
  12.  */
  13. public class VirtualKBMapping {
  14.  
  15.     /**
  16.      * 映射基本键map
  17.      */
  18.     static final Map<String, Integer> VK_MAP = new HashMap<>();
  19.  
  20.     /**
  21.      * 映射shift转换键map
  22.      */
  23.     static final Map<String, Integer> NEED_SHIFT_VK = new HashMap<>();
  24.  
  25.     static {
  26.         VK_MAP.put("Esc", 0x01);
  27.         VK_MAP.put("1", 0x02);
  28.         VK_MAP.put("2", 0x03);
  29.         VK_MAP.put("3", 0x04);
  30.         VK_MAP.put("4", 0x05);
  31.         VK_MAP.put("5", 0x06);
  32.         VK_MAP.put("6", 0x07);
  33.         VK_MAP.put("7", 0x08);
  34.         VK_MAP.put("8", 0x09);
  35.         VK_MAP.put("9", 0x0a);
  36.         VK_MAP.put("0", 0x0b);
  37.         VK_MAP.put("-", 0x0c);
  38.         VK_MAP.put("=", 0x0d);
  39.         VK_MAP.put("Backspace", 0x0e);
  40.         VK_MAP.put("Tab", 0x0f);
  41.         VK_MAP.put("q", 0x10);
  42.         VK_MAP.put("w", 0x11);
  43.         VK_MAP.put("e", 0x12);
  44.         VK_MAP.put("r", 0x13);
  45.         VK_MAP.put("t", 0x14);
  46.         VK_MAP.put("y", 0x15);
  47.         VK_MAP.put("u", 0x16);
  48.         VK_MAP.put("i", 0x17);
  49.         VK_MAP.put("o", 0x18);
  50.         VK_MAP.put("p", 0x19);
  51.         VK_MAP.put("[", 0x1a);
  52.         VK_MAP.put("]", 0x1b);
  53.         VK_MAP.put("Enter", 0x1c);
  54.         VK_MAP.put("LCtrl", 0x1d);
  55.         VK_MAP.put("a", 0x1e);
  56.         VK_MAP.put("s", 0x1f);
  57.         VK_MAP.put("d", 0x20);
  58.         VK_MAP.put("f", 0x21);
  59.         VK_MAP.put("g", 0x22);
  60.         VK_MAP.put("h", 0x23);
  61.         VK_MAP.put("j", 0x24);
  62.         VK_MAP.put("k", 0x25);
  63.         VK_MAP.put("l", 0x26);
  64.         VK_MAP.put(";", 0x27);
  65.         VK_MAP.put("'", 0x28);
  66.         VK_MAP.put("`", 0x29);
  67.         VK_MAP.put("LShift", 0x2a);
  68.         VK_MAP.put("\\", 0x2b);
  69.         VK_MAP.put("z", 0x2c);
  70.         VK_MAP.put("x", 0x2d);
  71.         VK_MAP.put("c", 0x2e);
  72.         VK_MAP.put("v", 0x2f);
  73.         VK_MAP.put("b", 0x30);
  74.         VK_MAP.put("n", 0x31);
  75.         VK_MAP.put("m", 0x32);
  76.         VK_MAP.put(",", 0x33);
  77.         VK_MAP.put(".", 0x34);
  78.         VK_MAP.put("/", 0x35);
  79.         VK_MAP.put("RShift", 0x36);
  80.         VK_MAP.put("LAlt", 0x38);
  81.         VK_MAP.put("Space", 0x39);
  82.         VK_MAP.put("CapsLock", 0x3a);
  83.         VK_MAP.put("F1", 0x3b);
  84.         VK_MAP.put("F2", 0x3c);
  85.         VK_MAP.put("F3", 0x3d);
  86.         VK_MAP.put("F4", 0x3e);
  87.         VK_MAP.put("F5", 0x3f);
  88.         VK_MAP.put("F6", 0x40);
  89.         VK_MAP.put("F7", 0x41);
  90.         VK_MAP.put("F8", 0x42);
  91.         VK_MAP.put("F9", 0x43);
  92.         VK_MAP.put("F10", 0x44);
  93.         VK_MAP.put("NumLock", 0x45);
  94.         VK_MAP.put("ScrollLock", 0x46);
  95.         VK_MAP.put("F11", 0x57);
  96.         VK_MAP.put("F12", 0x58);
  97.     }
  98.  
  99.     static {
  100.         NEED_SHIFT_VK.put("!", 0x02);
  101.         NEED_SHIFT_VK.put("@", 0x03);
  102.         NEED_SHIFT_VK.put("#", 0x04);
  103.         NEED_SHIFT_VK.put("$", 0x05);
  104.         NEED_SHIFT_VK.put("%", 0x06);
  105.         NEED_SHIFT_VK.put("^", 0x07);
  106.         NEED_SHIFT_VK.put("&", 0x08);
  107.         NEED_SHIFT_VK.put("*", 0x09);
  108.         NEED_SHIFT_VK.put("(", 0x0a);
  109.         NEED_SHIFT_VK.put(")", 0x0b);
  110.         NEED_SHIFT_VK.put("_", 0x0c);
  111.         NEED_SHIFT_VK.put("+", 0x0d);
  112.         NEED_SHIFT_VK.put("{", 0x1a);
  113.         NEED_SHIFT_VK.put("}", 0x1b);
  114.         NEED_SHIFT_VK.put(":", 0x27);
  115.         NEED_SHIFT_VK.put("\"", 0x28);
  116.         NEED_SHIFT_VK.put("~", 0x29);
  117.         NEED_SHIFT_VK.put("|", 0x2b);
  118.         NEED_SHIFT_VK.put("<", 0x33);
  119.         NEED_SHIFT_VK.put(">", 0x34);
  120.         NEED_SHIFT_VK.put("?", 0x35);
  121.         NEED_SHIFT_VK.put("Q", 0x10);
  122.         NEED_SHIFT_VK.put("W", 0x11);
  123.         NEED_SHIFT_VK.put("E", 0x12);
  124.         NEED_SHIFT_VK.put("R", 0x13);
  125.         NEED_SHIFT_VK.put("T", 0x14);
  126.         NEED_SHIFT_VK.put("Y", 0x15);
  127.         NEED_SHIFT_VK.put("U", 0x16);
  128.         NEED_SHIFT_VK.put("I", 0x17);
  129.         NEED_SHIFT_VK.put("O", 0x18);
  130.         NEED_SHIFT_VK.put("P", 0x19);
  131.         NEED_SHIFT_VK.put("A", 0x1e);
  132.         NEED_SHIFT_VK.put("S", 0x1f);
  133.         NEED_SHIFT_VK.put("D", 0x20);
  134.         NEED_SHIFT_VK.put("F", 0x21);
  135.         NEED_SHIFT_VK.put("G", 0x22);
  136.         NEED_SHIFT_VK.put("H", 0x23);
  137.         NEED_SHIFT_VK.put("J", 0x24);
  138.         NEED_SHIFT_VK.put("K", 0x25);
  139.         NEED_SHIFT_VK.put("L", 0x26);
  140.         NEED_SHIFT_VK.put("Z", 0x2c);
  141.         NEED_SHIFT_VK.put("X", 0x2d);
  142.         NEED_SHIFT_VK.put("C", 0x2e);
  143.         NEED_SHIFT_VK.put("V", 0x2f);
  144.         NEED_SHIFT_VK.put("B", 0x30);
  145.         NEED_SHIFT_VK.put("N", 0x31);
  146.         NEED_SHIFT_VK.put("M", 0x32);
  147.     }
  148.  
  149.     /**
  150.      * 返回所有支持的按键
  151.      */
  152.     public static String[] getSupportKeys() {
  153.         String[] vkArray = VK_MAP.keySet().toArray(new String[0]);
  154.         String[] needShiftVKArray = NEED_SHIFT_VK.keySet().toArray(new String[0]);
  155.         String[] supportKeys = new String[vkArray.length + needShiftVKArray.length];
  156.         System.arraycopy(vkArray, 0, supportKeys, 0, vkArray.length);
  157.         System.arraycopy(needShiftVKArray, 0, supportKeys, vkArray.length, needShiftVKArray.length);
  158.         return supportKeys;
  159.     }
  160.  
  161.     /**
  162.      * 返回是否支持按键
  163.      */
  164.     public static boolean isSupportKey(String key) {
  165.         return StringUtils.join(Arrays.asList(VirtualKBMapping.getSupportKeys()),"").contains(key);
  166.     }
  167. }

 

 c++装载驱动代码可以生成为dll文件调用，也可生成为exe文件调用。这里编译为exe。

注：生成dll文件及exe文件的时候一定生成64位的文件（32位系统不需要这个）。

  1. #include "stdafx.h"
  2.  
  3. #include <windows.h> 
  4. #include <winsvc.h> 
  5. #include <conio.h> 
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <tchar.h>
  9. #pragma comment (lib, "Advapi32.lib")
  10. #pragma comment( linker, "/subsystem:windows /entry:mainCRTStartup" )
  11.  
  12. #define DRIVER_NAME "WinIo64"
  13. #define DRIVER_PATH "C:\\Windows\\System32\\WinIo64.sys"
  14.  
  15. //装载NT驱动程序
  16. BOOL LoadNTDriver(char* lpszDriverName, char* lpszDriverPath)
  17. {
  18. 	char szDriverImagePath[256];
  19. 	//得到完整的驱动路径
  20. 	GetFullPathName(lpszDriverPath, 256, szDriverImagePath, NULL);
  21.  
  22. 	BOOL bRet = FALSE;
  23.  
  24. 	SC_HANDLE hServiceMgr = NULL;//SCM管理器的句柄
  25. 	SC_HANDLE hServiceDDK = NULL;//NT驱动程序的服务句柄
  26.  
  27. 	//打开服务控制管理器
  28. 	hServiceMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
  29.  
  30. 	if (hServiceMgr == NULL)
  31. 	{
  32. 		//OpenSCManager失败
  33. 		printf("OpenSCManager() Faild  ! \n");
  34. 		//printf(GetLastError());
  35. 		bRet = FALSE;
  36. 		goto BeforeLeave;
  37. 	}
  38. 	else
  39. 	{
  40. 		OpenSCManager成功
  41. 		printf("OpenSCManager() ok ! \n");
  42. 	}
  43.  
  44. 	//创建驱动所对应的服务
  45. 	hServiceDDK = CreateService(hServiceMgr,
  46. 		lpszDriverName, //驱动程序的在注册表中的名字 
  47. 		lpszDriverName, // 注册表驱动程序的 DisplayName 值 
  48. 		SERVICE_ALL_ACCESS, // 加载驱动程序的访问权限 
  49. 		SERVICE_KERNEL_DRIVER,// 表示加载的服务是驱动程序 
  50. 		SERVICE_DEMAND_START, // 注册表驱动程序的 Start 值 
  51. 		SERVICE_ERROR_IGNORE, // 注册表驱动程序的 ErrorControl 值 
  52. 		szDriverImagePath, // 注册表驱动程序的 ImagePath 值 
  53. 		NULL,
  54. 		NULL,
  55. 		NULL,
  56. 		NULL,
  57. 		NULL);
  58.  
  59. 	DWORD dwRtn;
  60. 	//判断服务是否失败
  61. 	if (hServiceDDK == NULL)
  62. 	{
  63. 		dwRtn = GetLastError();
  64. 		if (dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_EXISTS)
  65. 		{
  66. 			//由于其他原因创建服务失败
  67. 			printf("CrateService() Faild ! \n");
  68. 			///printf(dwRtn);
  69. 			bRet = FALSE;
  70. 			goto BeforeLeave;
  71. 		}
  72. 		else
  73. 		{
  74. 			//服务创建失败，是由于服务已经创立过
  75. 			printf("CrateService() Faild Service is ERROR_IO_PENDING or ERROR_SERVICE_EXISTS! \n");
  76. 		}
  77.  
  78. 		// 驱动程序已经加载，只需要打开 
  79. 		hServiceDDK = OpenService(hServiceMgr, lpszDriverName, SERVICE_ALL_ACCESS);
  80. 		if (hServiceDDK == NULL)
  81. 		{
  82. 			//如果打开服务也失败，则意味错误
  83. 			dwRtn = GetLastError();
  84. 			printf("OpenService() Faild  ! \n");
  85. 			//printf(dwRtn);
  86. 			bRet = FALSE;
  87. 			goto BeforeLeave;
  88. 		}
  89. 		else
  90. 		{
  91. 			printf("OpenService() ok ! \n");
  92. 		}
  93. 	}
  94. 	else
  95. 	{
  96. 		printf("CrateService() ok ! \n");
  97. 	}
  98.  
  99. 	//开启此项服务
  100. 	bRet = StartService(hServiceDDK, NULL, NULL);
  101. 	if (!bRet)
  102. 	{
  103. 		DWORD dwRtn = GetLastError();
  104. 		if (dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_ALREADY_RUNNING)
  105. 		{
  106. 			printf("StartService() Faild  ! \n" );
  107. 			//printf(dwRtn);
  108. 			bRet = FALSE;
  109. 			goto BeforeLeave;
  110. 		}
  111. 		else
  112. 		{
  113. 			if (dwRtn == ERROR_IO_PENDING)
  114. 			{
  115. 				//设备被挂住
  116. 				printf("StartService() Faild ERROR_IO_PENDING ! \n");
  117. 				bRet = FALSE;
  118. 				goto BeforeLeave;
  119. 			}
  120. 			else
  121. 			{
  122. 				//服务已经开启
  123. 				printf("StartService() Faild ERROR_SERVICE_ALREADY_RUNNING ! \n");
  124. 				bRet = TRUE;
  125. 				goto BeforeLeave;
  126. 			}
  127. 		}
  128. 	}
  129. 	bRet = TRUE;
  130. 	//离开前关闭句柄
  131. BeforeLeave:
  132. 	if (hServiceDDK)
  133. 	{
  134. 		CloseServiceHandle(hServiceDDK);
  135. 	}
  136. 	if (hServiceMgr)
  137. 	{
  138. 		CloseServiceHandle(hServiceMgr);
  139. 	}
  140. 	return bRet;
  141. }
  142.  
  143. //卸载驱动程序 
  144. BOOL UnloadNTDriver(char * szSvrName)
  145. {
  146. 	BOOL bRet = FALSE;
  147. 	SC_HANDLE hServiceMgr = NULL;//SCM管理器的句柄
  148. 	SC_HANDLE hServiceDDK = NULL;//NT驱动程序的服务句柄
  149. 	SERVICE_STATUS SvrSta;
  150. 	//打开SCM管理器
  151. 	hServiceMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
  152. 	if (hServiceMgr == NULL)
  153. 	{
  154. 		//带开SCM管理器失败
  155. 		printf("OpenSCManager() Faild ! \n");
  156. 		//printf(GetLastError());
  157. 		bRet = FALSE;
  158. 		goto BeforeLeave;
  159. 	}
  160. 	else
  161. 	{
  162. 		//带开SCM管理器失败成功
  163. 		printf("OpenSCManager() ok ! \n");
  164. 	}
  165. 	//打开驱动所对应的服务
  166. 	hServiceDDK = OpenService(hServiceMgr, szSvrName, SERVICE_ALL_ACCESS);
  167.  
  168. 	if (hServiceDDK == NULL)
  169. 	{
  170. 		//打开驱动所对应的服务失败
  171. 		printf("OpenService() Faild  ! \n");
  172. 		//printf(GetLastError());
  173. 		bRet = FALSE;
  174. 		goto BeforeLeave;
  175. 	}
  176. 	else
  177. 	{
  178. 		printf("OpenService() ok ! \n");
  179. 	}
  180. 	//停止驱动程序，如果停止失败，只有重新启动才能，再动态加载。 
  181. 	if (!ControlService(hServiceDDK, SERVICE_CONTROL_STOP, &SvrSta))
  182. 	{
  183. 		printf("ControlService() Faild %d !\n", GetLastError());
  184. 	}
  185. 	else
  186. 	{
  187. 		//打开驱动所对应的失败
  188. 		printf("ControlService() ok !\n");
  189. 	}
  190. 	//动态卸载驱动程序。 
  191. 	if (!DeleteService(hServiceDDK))
  192. 	{
  193. 		//卸载失败
  194. 		printf("DeleteSrevice() Faild %d !\n", GetLastError());
  195. 	}
  196. 	else
  197. 	{
  198. 		//卸载成功
  199. 		printf("DelServer:eleteSrevice() ok !\n");
  200. 	}
  201. 	bRet = TRUE;
  202. BeforeLeave:
  203. 	//离开前关闭打开的句柄
  204. 	if (hServiceDDK)
  205. 	{
  206. 		CloseServiceHandle(hServiceDDK);
  207. 	}
  208. 	if (hServiceMgr)
  209. 	{
  210. 		CloseServiceHandle(hServiceMgr);
  211. 	}
  212. 	return bRet;
  213. }
  214.  
  215.  
  216. int main(int argc, char* argv[])
  217. {
  218. 	//加载驱动
  219. 	BOOL bRet = LoadNTDriver(DRIVER_NAME, DRIVER_PATH);
  220. 	if (!bRet)
  221. 	{
  222. 		printf("install winio error\n");
  223. 		return 0;
  224. 	}
  225. 	//加载成功
  226.  
  227. 	//printf("install winio successed!\n");
  228. 	//getch();
  229.  
  230.  
  231. 	//这时候你可以通过注册表，或其他查看符号连接的软件验证。 
  232. 	//printf("press any to unload the driver!\n");
  233. 	//getch();
  234.  
  235. 	//卸载驱动
  236. 	//BOOL bRet = UnloadNTDriver(DRIVER_NAME);
  237. 	//if (!bRet)
  238. 	//{
  239. 	//	printf("unload winio error!\n");
  240. 	//	return 0;
  241. 	//}
  242. 	//printf("unload winio successed!\n");
  243. 	//return 0;
  244. }

 第四步：执行代码

大家按照上述代码都写好后就是执行了。有人可能成功了，有人可能还不行。所以下面介绍下这个代码基本的运行逻辑。供大家自行调整bug。

windows系统开启测试模式后，winio64.sys安装签名后。

执行代码：

1、***首先执行装载winio64.sys驱动代码，就是c++生成的dll或者exe文件里的LoadNTDriver方法。（这一步必须有，网上大部分没有这一步，所以大部分你试了都不会成功。）

2、执行winio的初始化方法 InitializeWinIo

3、KBCWait4IBE方法等待0x64控制端口空闲

4、0x64控制端口空闲时SetPortVal发送命令到0x64端口，在发送按键对应的虚拟码到0x60端口即可

5、winio.ShutdownWinIo释放资源

6、winio64.sys驱动加载后，系统重启后需要重新加载（注意）

以上即是本人实践总结，欢迎留言交流。

 

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号