WinIO3.0调用键盘实践-winxp、win7、win10下32位64位都适用
萧秋月
目录
第一步：Windows系统开启测试模式（针对64位系统，32系统不需要）
第二步：WinIo64.sys安装签名（针对64位系统，32系统不需要）
准备
开发环境：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依赖：
<dependencies>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>4.4.0</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
<version>4.4.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>
</dependencies>winio代码实现
import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.WString;
import com.sun.jna.win32.W32APIOptions;
/**
* author songxq
* date 2020/6/18
* description
*/
public interface WinIo extends Library {
/**
* 系统架构32位或者64位
*/
String ARCH = System.getProperty("os.arch");
/**
* 使用的winio版本
*/
String WIN_IO_LIB_NAME = "x86".equals(ARCH) ? "WinIo32" : "WinIo64";
WinIo INSTANCE = (WinIo) Native.loadLibrary(WIN_IO_LIB_NAME, WinIo.class, W32APIOptions.DEFAULT_OPTIONS);
/**
* PS/2键盘的命令端口
*/
int CONTROL_PORT = 0x64;
/**
* PS/2键盘的数据端口
*/
int DATA_PORT = 0x60;
/**
* 初始化winiolib库
* @param path 驱动文件绝对路径
* @return
*/
boolean InitializeWinIo(WString path);
/**
* 释放资源及开辟的内存空间
*/
void ShutdownWinIo();
/**
* 读数据
* 98/ME系列使用GetPortVal NT/2000/XP系列可以使用_inp/_inpw/_inpd
* @param portAddr io地址
* @param pPortVal 指针变量
* @param size 数据大小
* @return
*/
boolean GetPortVal(int portAddr, Pointer pPortVal, int size);
/**
* 写数据
* @param portAddr io地址
* @param portVal 指针变量
* @param size 数据大小
* @return
*/
boolean SetPortVal(int portAddr, int portVal, int size);
}
键盘调用代码
import com.sun.jna.Memory;
import com.sun.jna.Pointer;
import com.sun.jna.WString;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
/**
* author songxq
* date 2020/6/18
* description
*/
public class VirtualKB {
private static final WinIo WIN_IO = WinIo.INSTANCE;
private static final String WIN_BASE_SYSTEM32 = "C:\\Windows\\System32";
private static final String WINIO_INSTALL_PATH = "C:\\INSTALLWINIO";
private static final String WINIO_INSTALL_EXE = "C:\\INSTALLWINIO\\InstallWinIo.exe";
private static final String WIN_32_SYS = "WinIo32.sys";
private static final String WIN_64_SYS = "WinIo64.sys";
//keyame
public static final String Tab = "Tab";
public static final String Esc = "Esc";
public static final String Backspace = "Backspace";
public static final String Enter = "Enter";
public static final String LCtrl = "LCtrl";
public static final String LShift = "LShift";
public static final String RShift = "RShift";
public static final String LAlt = "LAlt";
public static final String Space = "Space";
public static final String CapsLock = "CapsLock";
public static final String F1 = "F1";
public static final String F2 = "F2";
public static final String F3 = "F3";
public static final String F4 = "F4";
public static final String F5 = "F5";
public static final String F6 = "F6";
public static final String F7 = "F7";
public static final String F8 = "F8";
public static final String F9 = "F9";
public static final String F10 = "F10";
public static final String F11 = "F11";
public static final String F12 = "F12";
public static final String NumLock = "NumLock";
public static final String ScrollLock = "ScrollLock";
static{
String x86 = "x86";
String driverName;
if (x86.equals(WinIo.ARCH)) {
driverName = WIN_BASE_SYSTEM32 + File.separator + WIN_32_SYS;
} else {
driverName = WIN_BASE_SYSTEM32 + File.separator + WIN_64_SYS;
}
if(!WIN_IO.InitializeWinIo(new WString(driverName))){
installSys();
}
}
/**
* 等待缓冲区置空
*/
private static void KBCWait4IBE() {
int val;
do {
Pointer p = new Memory(8);
if (!WIN_IO.GetPortVal(WinIo.CONTROL_PORT, p, 1)) {
throw new RuntimeException("Cannot Get The Port!");
}
val = p.getInt(0);
} while ((0x2 & val) > 0);
}
private static void down(int key) {
KBCWait4IBE();
WIN_IO.SetPortVal(WinIo.CONTROL_PORT, 0xd2, 1);
KBCWait4IBE();
WIN_IO.SetPortVal(WinIo.DATA_PORT, key, 1);
}
private static void up(int key) {
KBCWait4IBE();
WIN_IO.SetPortVal(WinIo.CONTROL_PORT, 0xd2, 1);
KBCWait4IBE();
WIN_IO.SetPortVal(WinIo.DATA_PORT, (key | 0x80), 1);
}
private static void press(String[] words, long firstSleepTime, long sleepTime) throws Exception{
if (null == words || words.length == 0) {
throw new IllegalArgumentException("words Is NULL Or Empty");
}
int minSleepTime = 50;
if (sleepTime < minSleepTime) {
throw new IllegalArgumentException("SleepTime Less Than 50 ms");
}
if (firstSleepTime > 0) {
Thread.sleep(firstSleepTime);
}
for (String word : words) {
Integer vk = VirtualKBMapping.VK_MAP.get(word);
if (null == vk) {
vk = VirtualKBMapping.NEED_SHIFT_VK.get(word);
}
if (null == vk) {
throw new RuntimeException(word + " Not Support");
}
boolean needShift = word.length() == 1 && null != VirtualKBMapping.NEED_SHIFT_VK.get(word);
if (needShift) {
down(VirtualKBMapping.VK_MAP.get("LShift"));
}
down(vk);
Thread.sleep(sleepTime);
up(vk);
if (needShift) {
up(VirtualKBMapping.VK_MAP.get("LShift"));
}
}
}
/**
* 键盘输入文本
* @param content 文本
* @param sleepTime 等待时间间隔
*/
public static void inputStr(String content,long sleepTime) throws Exception {
if (null == content || content.length() == 0) {
throw new IllegalArgumentException("content Is NULL Or Empty");
}
char[] chars = content.toCharArray();
for (int i=0;i<chars.length;i++){
press(new String[]{String.valueOf(chars[i])},sleepTime,50);
}
}
/**
* 键盘按键
* @param keyname 按键名称
* @param sleepTime 等待时间间隔
*/
public static void pressKey(String keyname,long sleepTime) throws Exception {
if (null == keyname || keyname.length() == 0) {
throw new IllegalArgumentException("keyname Is NULL Or Empty");
}
press(new String[]{keyname},sleepTime,50);
}
private static void extract(final String fileName, final String name) {
if (new File(fileName).exists()) {
return;
}
try(InputStream inputStream = VirtualKB.class.getResourceAsStream("/" + name)) {
Files.copy(inputStream, Paths.get(fileName), StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 执行sys驱动安装
*/
public static void installSys() {
if (!new File(WINIO_INSTALL_EXE).exists()) {
if(!new File(WINIO_INSTALL_PATH).exists()){
new File(WINIO_INSTALL_PATH).mkdirs();
}
extract(WINIO_INSTALL_EXE,"InstallWinIo.exe");
}
Runtime rn = Runtime.getRuntime();
Process p = null;
try {
p = rn.exec(WINIO_INSTALL_EXE);
} catch (Exception e) {
e.printStackTrace();
}
}
}虚拟键盘映射代码
import org.apache.commons.lang3.StringUtils;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* author songxq
* date 2020/6/18
* description
*/
public class VirtualKBMapping {
/**
* 映射基本键map
*/
static final Map<String, Integer> VK_MAP = new HashMap<>();
/**
* 映射shift转换键map
*/
static final Map<String, Integer> NEED_SHIFT_VK = new HashMap<>();
static {
VK_MAP.put("Esc", 0x01);
VK_MAP.put("1", 0x02);
VK_MAP.put("2", 0x03);
VK_MAP.put("3", 0x04);
VK_MAP.put("4", 0x05);
VK_MAP.put("5", 0x06);
VK_MAP.put("6", 0x07);
VK_MAP.put("7", 0x08);
VK_MAP.put("8", 0x09);
VK_MAP.put("9", 0x0a);
VK_MAP.put("0", 0x0b);
VK_MAP.put("-", 0x0c);
VK_MAP.put("=", 0x0d);
VK_MAP.put("Backspace", 0x0e);
VK_MAP.put("Tab", 0x0f);
VK_MAP.put("q", 0x10);
VK_MAP.put("w", 0x11);
VK_MAP.put("e", 0x12);
VK_MAP.put("r", 0x13);
VK_MAP.put("t", 0x14);
VK_MAP.put("y", 0x15);
VK_MAP.put("u", 0x16);
VK_MAP.put("i", 0x17);
VK_MAP.put("o", 0x18);
VK_MAP.put("p", 0x19);
VK_MAP.put("[", 0x1a);
VK_MAP.put("]", 0x1b);
VK_MAP.put("Enter", 0x1c);
VK_MAP.put("LCtrl", 0x1d);
VK_MAP.put("a", 0x1e);
VK_MAP.put("s", 0x1f);
VK_MAP.put("d", 0x20);
VK_MAP.put("f", 0x21);
VK_MAP.put("g", 0x22);
VK_MAP.put("h", 0x23);
VK_MAP.put("j", 0x24);
VK_MAP.put("k", 0x25);
VK_MAP.put("l", 0x26);
VK_MAP.put(";", 0x27);
VK_MAP.put("'", 0x28);
VK_MAP.put("`", 0x29);
VK_MAP.put("LShift", 0x2a);
VK_MAP.put("\\", 0x2b);
VK_MAP.put("z", 0x2c);
VK_MAP.put("x", 0x2d);
VK_MAP.put("c", 0x2e);
VK_MAP.put("v", 0x2f);
VK_MAP.put("b", 0x30);
VK_MAP.put("n", 0x31);
VK_MAP.put("m", 0x32);
VK_MAP.put(",", 0x33);
VK_MAP.put(".", 0x34);
VK_MAP.put("/", 0x35);
VK_MAP.put("RShift", 0x36);
VK_MAP.put("LAlt", 0x38);
VK_MAP.put("Space", 0x39);
VK_MAP.put("CapsLock", 0x3a);
VK_MAP.put("F1", 0x3b);
VK_MAP.put("F2", 0x3c);
VK_MAP.put("F3", 0x3d);
VK_MAP.put("F4", 0x3e);
VK_MAP.put("F5", 0x3f);
VK_MAP.put("F6", 0x40);
VK_MAP.put("F7", 0x41);
VK_MAP.put("F8", 0x42);
VK_MAP.put("F9", 0x43);
VK_MAP.put("F10", 0x44);
VK_MAP.put("NumLock", 0x45);
VK_MAP.put("ScrollLock", 0x46);
VK_MAP.put("F11", 0x57);
VK_MAP.put("F12", 0x58);
}
static {
NEED_SHIFT_VK.put("!", 0x02);
NEED_SHIFT_VK.put("@", 0x03);
NEED_SHIFT_VK.put("#", 0x04);
NEED_SHIFT_VK.put("$", 0x05);
NEED_SHIFT_VK.put("%", 0x06);
NEED_SHIFT_VK.put("^", 0x07);
NEED_SHIFT_VK.put("&", 0x08);
NEED_SHIFT_VK.put("*", 0x09);
NEED_SHIFT_VK.put("(", 0x0a);
NEED_SHIFT_VK.put(")", 0x0b);
NEED_SHIFT_VK.put("_", 0x0c);
NEED_SHIFT_VK.put("+", 0x0d);
NEED_SHIFT_VK.put("{", 0x1a);
NEED_SHIFT_VK.put("}", 0x1b);
NEED_SHIFT_VK.put(":", 0x27);
NEED_SHIFT_VK.put("\"", 0x28);
NEED_SHIFT_VK.put("~", 0x29);
NEED_SHIFT_VK.put("|", 0x2b);
NEED_SHIFT_VK.put("<", 0x33);
NEED_SHIFT_VK.put(">", 0x34);
NEED_SHIFT_VK.put("?", 0x35);
NEED_SHIFT_VK.put("Q", 0x10);
NEED_SHIFT_VK.put("W", 0x11);
NEED_SHIFT_VK.put("E", 0x12);
NEED_SHIFT_VK.put("R", 0x13);
NEED_SHIFT_VK.put("T", 0x14);
NEED_SHIFT_VK.put("Y", 0x15);
NEED_SHIFT_VK.put("U", 0x16);
NEED_SHIFT_VK.put("I", 0x17);
NEED_SHIFT_VK.put("O", 0x18);
NEED_SHIFT_VK.put("P", 0x19);
NEED_SHIFT_VK.put("A", 0x1e);
NEED_SHIFT_VK.put("S", 0x1f);
NEED_SHIFT_VK.put("D", 0x20);
NEED_SHIFT_VK.put("F", 0x21);
NEED_SHIFT_VK.put("G", 0x22);
NEED_SHIFT_VK.put("H", 0x23);
NEED_SHIFT_VK.put("J", 0x24);
NEED_SHIFT_VK.put("K", 0x25);
NEED_SHIFT_VK.put("L", 0x26);
NEED_SHIFT_VK.put("Z", 0x2c);
NEED_SHIFT_VK.put("X", 0x2d);
NEED_SHIFT_VK.put("C", 0x2e);
NEED_SHIFT_VK.put("V", 0x2f);
NEED_SHIFT_VK.put("B", 0x30);
NEED_SHIFT_VK.put("N", 0x31);
NEED_SHIFT_VK.put("M", 0x32);
}
/**
* 返回所有支持的按键
*/
public static String[] getSupportKeys() {
String[] vkArray = VK_MAP.keySet().toArray(new String[0]);
String[] needShiftVKArray = NEED_SHIFT_VK.keySet().toArray(new String[0]);
String[] supportKeys = new String[vkArray.length + needShiftVKArray.length];
System.arraycopy(vkArray, 0, supportKeys, 0, vkArray.length);
System.arraycopy(needShiftVKArray, 0, supportKeys, vkArray.length, needShiftVKArray.length);
return supportKeys;
}
/**
* 返回是否支持按键
*/
public static boolean isSupportKey(String key) {
return StringUtils.join(Arrays.asList(VirtualKBMapping.getSupportKeys()),"").contains(key);
}
}
c++装载驱动代码可以生成为dll文件调用，也可生成为exe文件调用。这里编译为exe。
注：生成dll文件及exe文件的时候一定生成64位的文件（32位系统不需要这个）。
#include "stdafx.h"
#include <windows.h>
#include <winsvc.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <tchar.h>
#pragma comment (lib, "Advapi32.lib")
#pragma comment( linker, "/subsystem:windows /entry:mainCRTStartup" )
#define DRIVER_NAME "WinIo64"
#define DRIVER_PATH "C:\\Windows\\System32\\WinIo64.sys"
//装载NT驱动程序
BOOL LoadNTDriver(char* lpszDriverName, char* lpszDriverPath)
{
char szDriverImagePath[256];
//得到完整的驱动路径
GetFullPathName(lpszDriverPath, 256, szDriverImagePath, NULL);
BOOL bRet = FALSE;
SC_HANDLE hServiceMgr = NULL;//SCM管理器的句柄
SC_HANDLE hServiceDDK = NULL;//NT驱动程序的服务句柄
//打开服务控制管理器
hServiceMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hServiceMgr == NULL)
{
//OpenSCManager失败
printf("OpenSCManager() Faild ! \n");
//printf(GetLastError());
bRet = FALSE;
goto BeforeLeave;
}
else
{
OpenSCManager成功
printf("OpenSCManager() ok ! \n");
}
//创建驱动所对应的服务
hServiceDDK = CreateService(hServiceMgr,
lpszDriverName, //驱动程序的在注册表中的名字
lpszDriverName, // 注册表驱动程序的 DisplayName 值
SERVICE_ALL_ACCESS, // 加载驱动程序的访问权限
SERVICE_KERNEL_DRIVER,// 表示加载的服务是驱动程序
SERVICE_DEMAND_START, // 注册表驱动程序的 Start 值
SERVICE_ERROR_IGNORE, // 注册表驱动程序的 ErrorControl 值
szDriverImagePath, // 注册表驱动程序的 ImagePath 值
NULL,
NULL,
NULL,
NULL,
NULL);
DWORD dwRtn;
//判断服务是否失败
if (hServiceDDK == NULL)
{
dwRtn = GetLastError();
if (dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_EXISTS)
{
//由于其他原因创建服务失败
printf("CrateService() Faild ! \n");
///printf(dwRtn);
bRet = FALSE;
goto BeforeLeave;
}
else
{
//服务创建失败，是由于服务已经创立过
printf("CrateService() Faild Service is ERROR_IO_PENDING or ERROR_SERVICE_EXISTS! \n");
}
// 驱动程序已经加载，只需要打开
hServiceDDK = OpenService(hServiceMgr, lpszDriverName, SERVICE_ALL_ACCESS);
if (hServiceDDK == NULL)
{
//如果打开服务也失败，则意味错误
dwRtn = GetLastError();
printf("OpenService() Faild ! \n");
//printf(dwRtn);
bRet = FALSE;
goto BeforeLeave;
}
else
{
printf("OpenService() ok ! \n");
}
}
else
{
printf("CrateService() ok ! \n");
}
//开启此项服务
bRet = StartService(hServiceDDK, NULL, NULL);
if (!bRet)
{
DWORD dwRtn = GetLastError();
if (dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_ALREADY_RUNNING)
{
printf("StartService() Faild ! \n" );
//printf(dwRtn);
bRet = FALSE;
goto BeforeLeave;
}
else
{
if (dwRtn == ERROR_IO_PENDING)
{
//设备被挂住
printf("StartService() Faild ERROR_IO_PENDING ! \n");
bRet = FALSE;
goto BeforeLeave;
}
else
{
//服务已经开启
printf("StartService() Faild ERROR_SERVICE_ALREADY_RUNNING ! \n");
bRet = TRUE;
goto BeforeLeave;
}
}
}
bRet = TRUE;
//离开前关闭句柄
BeforeLeave:
if (hServiceDDK)
{
CloseServiceHandle(hServiceDDK);
}
if (hServiceMgr)
{
CloseServiceHandle(hServiceMgr);
}
return bRet;
}
//卸载驱动程序
BOOL UnloadNTDriver(char * szSvrName)
{
BOOL bRet = FALSE;
SC_HANDLE hServiceMgr = NULL;//SCM管理器的句柄
SC_HANDLE hServiceDDK = NULL;//NT驱动程序的服务句柄
SERVICE_STATUS SvrSta;
//打开SCM管理器
hServiceMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hServiceMgr == NULL)
{
//带开SCM管理器失败
printf("OpenSCManager() Faild ! \n");
//printf(GetLastError());
bRet = FALSE;
goto BeforeLeave;
}
else
{
//带开SCM管理器失败成功
printf("OpenSCManager() ok ! \n");
}
//打开驱动所对应的服务
hServiceDDK = OpenService(hServiceMgr, szSvrName, SERVICE_ALL_ACCESS);
if (hServiceDDK == NULL)
{
//打开驱动所对应的服务失败
printf("OpenService() Faild ! \n");
//printf(GetLastError());
bRet = FALSE;
goto BeforeLeave;
}
else
{
printf("OpenService() ok ! \n");
}
//停止驱动程序，如果停止失败，只有重新启动才能，再动态加载。
if (!ControlService(hServiceDDK, SERVICE_CONTROL_STOP, &SvrSta))
{
printf("ControlService() Faild %d !\n", GetLastError());
}
else
{
//打开驱动所对应的失败
printf("ControlService() ok !\n");
}
//动态卸载驱动程序。
if (!DeleteService(hServiceDDK))
{
//卸载失败
printf("DeleteSrevice() Faild %d !\n", GetLastError());
}
else
{
//卸载成功
printf("DelServer:eleteSrevice() ok !\n");
}
bRet = TRUE;
BeforeLeave:
//离开前关闭打开的句柄
if (hServiceDDK)
{
CloseServiceHandle(hServiceDDK);
}
if (hServiceMgr)
{
CloseServiceHandle(hServiceMgr);
}
return bRet;
}
int main(int argc, char* argv[])
{
//加载驱动
BOOL bRet = LoadNTDriver(DRIVER_NAME, DRIVER_PATH);
if (!bRet)
{
printf("install winio error\n");
return 0;
}
//加载成功
//printf("install winio successed!\n");
//getch();
//这时候你可以通过注册表，或其他查看符号连接的软件验证。
//printf("press any to unload the driver!\n");
//getch();
//卸载驱动
//BOOL bRet = UnloadNTDriver(DRIVER_NAME);
//if (!bRet)
//{
// printf("unload winio error!\n");
// return 0;
//}
//printf("unload winio successed!\n");
//return 0;
}第四步：执行代码
大家按照上述代码都写好后就是执行了。有人可能成功了，有人可能还不行。所以下面介绍下这个代码基本的运行逻辑。供大家自行调整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驱动加载后，系统重启后需要重新加载（注意）
以上即是本人实践总结，欢迎留言交流。
类似资料：