办公软件WPS的JSA中模拟键盘输入

cutebe

办公软件WPS的表格：通过ExecuteExcel4Macro调用WinAPI实现

函数：

1. function 操作键盘(操作数组){
   
2.         let 序号=0,键盘数组=[];
   
3.         if(Array.isArray(操作数组)){
   
4.                 for(let i=0;i<操作数组.length;i++){
   
5.                         if(Array.isArray(操作数组[i])){
   
6.                                 for(let j=0;j<操作数组[i].length;j++){
   
7.                                         键盘数组[序号]=操作数组[i][j];序号++;
   
8.                                 }
   
9.                         }else{键盘数组[序号]=操作数组[i];序号++;}
   
10.                 }
    
11.         }else{键盘数组[序号]=操作数组;}
    
12.         let 操作组数=键盘数组.length;
    
13.         let 结构字节数=对象字节数(键盘数组[0]);        /*****计算结构对象字节数*****/
    
14.         let 总字节=结构字节数*操作组数;
    
15.         const 数组缓冲=new ArrayBuffer(总字节);        //操作对象数组写入缓冲
    
16.         for(let i=0;i<操作组数;i++){
    
17.                 结构对象填入数组缓冲(数组缓冲,i*结构字节数,键盘数组[i]);        /*****对象转数组缓冲*****/
    
18.         }
    
19.         const 执行宏调用=ExecuteExcel4Macro;        //申请内存
    
20.         const 内存地址=执行宏调用(`CALL("Kernel32","VirtualAlloc","JJJJJ",0,${总字节},${0x3000},4)`);
    
21.         数据写入内存(内存地址,数组缓冲,总字节);        /*****写入键盘操作结构*****/        //执行键盘操作
    
22.         键盘操作结果=执行宏调用(`CALL("User32","SendInput","JJJJ",${操作组数},${内存地址},${结构字节数})`);
    
23.         if(!键盘操作结果){console.log("错误代码："+执行宏调用(`CALL("Kernel32","GetLastError","I")`));}
    
24.         执行宏调用(`CALL("Kernel32", "VirtualFree", "JJJJ", ${内存地址}, 0, ${0x8000})`);        //释放内存
    
25. }

复制代码

测试：键盘输入测试();　　//执行函数前，请先打开一个记事本，将鼠标指针停在记事本窗口上方

测试及调用函数：

1. function 键盘输入测试(){
   
2.         //执行函数前，请先打开一个记事本，将鼠标指针停在记事本窗口上方
   
3.         let 点击=鼠标操作对象(2|4);
   
4.         操作鼠标([点击]);        /*****鼠标单击操作*****/
   
5. 
   
6.         let 字符串="WuYou.Net";        //无忧论坛，将网址输入到记事本
   
7.         let 字符数组=字符串.split(''),按键数组=[];
   
8.         for(let i=0;i<字符串.length;i++){
   
9.                 var 字符=字符数组[i];
   
10.                 if(字符>='a' && 字符<='z'){字符=字符.toUpperCase();}
    
11.                 按键数组[i]=键盘操作对象(字符);
    
12.         }
    
13.         操作键盘(按键数组);        /*****键盘操作*****/
    
14. }
    
15. 
    
16. function 键盘操作对象(键码){
    
17.         class 键盘操作 {        //类
    
18.                 constructor(按键,动作){        //类的构造方法，用于构造属性
    
19.                         this.输入类型1 = [4,1],        //键盘1        //字节数，数据
    
20.                         this.虚拟键码2 = [4,按键],        //同ASCII码
    
21.                         this.键扫描码3 = [4,0],
    
22.                         this.输入操作4 = [4,动作],        //按键弹起2        启用扫描码8
    
23.                         this.时间戳值5 = [4,0],        //系统确定
    
24.                         this.扩展信息6 = [4,0],
    
25.                         this.数据填充x = [4,0]        //都是4*7=28字节，不足部分补足
    
26.                 }
    
27.         };
    
28.         if(键码>='A'&&键码<='Z'){键码=键码.charCodeAt(0);}
    
29.         if(键码=='.'){键码=0xBE;}
    
30.         let 键盘对象 = new 键盘操作(键码,4|2);        //统一码0x4|2键弹起
    
31.         return 键盘对象;
    
32. }
    
33. function 鼠标操作对象(操作){
    
34.         class 鼠标操作 {        //类
    
35.                 constructor(动作){        //类的构造方法，用于构造属性
    
36.                         this.输入类型1 = [4,0],        //鼠标0        //字节数，数据
    
37.                         this.水平坐标2 = [4,0],        //相对坐标，即移动量
    
38.                         this.垂直坐标3 = [4,0],
    
39.                         this.滚轮转量4 = [4,0],
    
40.                         this.输入操作5 = [4,动作],        //右键按下8        绝对坐标0x8000
    
41.                         this.时间戳值6 = [4,0],        //系统确定
    
42.                         this.扩展数据7 = [4,0]
    
43.                 }
    
44.         };
    
45.         let 鼠标对象 = new 鼠标操作(操作);
    
46.         return 鼠标对象;
    
47. }
    
48. function 对象字节数(结构对象){
    
49.         let 对象数据字节数=0;
    
50.         for (let 属性名 in 结构对象) {
    
51.                 if (结构对象.hasOwnProperty(属性名)) {
    
52.                         对象数据字节数+=结构对象[属性名][0];        //累加字节数
    
53.                 }
    
54.         }
    
55.         return 对象数据字节数;
    
56. }
    
57. function 结构对象填入数组缓冲(数组缓冲,偏移,结构对象){
    
58.         const 数据操作=new DataView(数组缓冲);
    
59.         let 字节数,待填数据;
    
60.         for (let 属性名 in 结构对象) {
    
61.                 if (结构对象.hasOwnProperty(属性名)) {
    
62.                         字节数=结构对象[属性名][0],待填数据=结构对象[属性名][1];
    
63.                         if(字节数==4){数据操作.setInt32(偏移,待填数据,true);}        //小端序
    
64.                         else{if(字节数==2){数据操作.setInt32(偏移,待填数据,true);}
    
65.                         else{if(字节数==1){数据操作.setInt32(偏移,待填数据,true);}}}
    
66.                         偏移+=字节数;
    
67.                 }
    
68.         }
    
69. }
    
70. function 操作鼠标(操作数组){
    
71.         let 操作组数=操作数组.length;
    
72.         let 结构字节数=对象字节数(操作数组[0]);        /*****计算结构对象字节数*****/
    
73.         let 总字节=结构字节数*操作组数;
    
74.         const 数组缓冲=new ArrayBuffer(总字节);        //操作对象数组写入缓冲
    
75.         for(let i=0;i<操作组数;i++){
    
76.                 结构对象填入数组缓冲(数组缓冲,i*结构字节数,操作数组[i]);        /*****对象转数组缓冲*****/
    
77.         }
    
78.         const 执行宏调用=ExecuteExcel4Macro;        //申请内存
    
79.         const 内存地址=执行宏调用(`CALL("Kernel32","VirtualAlloc","JJJJJ",0,${总字节},${0x3000},4)`);
    
80.         数据写入内存(内存地址,数组缓冲,总字节);        /*****写入鼠标操作结构*****/        //执行鼠标操作
    
81.         鼠标操作结果=执行宏调用(`CALL("User32","SendInput","JJJJ",${操作组数},${内存地址},${结构字节数})`);
    
82.         if(!鼠标操作结果){console.log("错误代码："+执行宏调用(`CALL("Kernel32","GetLastError","I")`));}
    
83.         执行宏调用(`CALL("Kernel32", "VirtualFree", "JJJJ", ${内存地址}, 0, ${0x8000})`);        //释放内存
    
84. }
    
85. function 数据写入内存(内存地址,数组缓冲,字节数){
    
86.         const 数据操作=new DataView(数组缓冲);
    
87.         let 偏移=i=0,待写数据=[],写入字节=[];
    
88.         while(字节数>偏移){
    
89.                 if(字节数-偏移>=4){待写数据[i]=数据操作.getInt32(偏移,true);写入字节[i]=4;i++;偏移+=4;}
    
90.                 else{if(字节数-偏移>=2){待写数据[i]=数据操作.getInt16(偏移,true);写入字节[i]=2;i++;偏移+=2;}
    
91.                 else{if(字节数-偏移==1){待写数据[i]=数据操作.getInt8(偏移,true);写入字节[i]=1;i++;偏移++;}}}
    
92.         }
    
93.         const 执行宏调用=ExecuteExcel4Macro;
    
94.         for(偏移=i=0;i<写入字节.length;i++){        //写入
    
95.                 执行宏调用(`CALL("Kernel32","RtlMoveMemory","2JNJ",${内存地址+偏移},${待写数据[i]},${写入字节[i]})`);
    
96.                 偏移+=写入字节[i];
    
97.         }
    
98. }

复制代码

数据结构类似鼠标操作。

1e3e

谢谢分享坐个沙发

yyz219195888

很复杂的代码，表示看不懂，惭愧

cutebe

测试及调用函数：

1. function 找到窗口键盘输入测试(){        //记事本编辑框中输入内容
   
2.         console.clear();
   
3.         const 执行宏调用=ExecuteExcel4Macro;
   
4.        
   
5.         let 记事本类="Notepad";        //找到那个打开的记事本窗口
   
6.         var 记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
   
7.         console.log("记事本句柄："+记事本句柄);
   
8.         执行宏调用(`CALL("User32","ShowWindow","JJJ",${记事本句柄},9)`);        //激活并显示SW_RESTORE=9
   
9.     执行宏调用(`CALL("User32","SetForegroundWindow","JJ",${记事本句柄})`);        //前置
   
10.        
    
11.         //'A'=0x41, 'B'=0x42, 'C'=0x43, 'N'=0x4E, 'Z'=0x5A
    
12.         let 字符串="WuYou.Net";        //无忧论坛网址，用来填写
    
13.         let 字符数组=字符串.split(''),按键数组=[];
    
14.         for(let i=0;i<字符串.length;i++){
    
15.                 var 字符=字符数组[i];
    
16.                 if(字符>='a' && 字符<='z'){字符=字符.toUpperCase();}
    
17.                 按键数组[i]=键盘操作对象(字符);
    
18.         }
    
19.         操作键盘(按键数组);        /*****键盘操作*****/
    
20. }
    
21. 
    
22. function 操作键盘(操作数组){
    
23.         let 序号=0,键盘数组=[];
    
24.         if(Array.isArray(操作数组)){
    
25.                 for(let i=0;i<操作数组.length;i++){
    
26.                         if(Array.isArray(操作数组[i])){
    
27.                                 for(let j=0;j<操作数组[i].length;j++){
    
28.                                         键盘数组[序号]=操作数组[i][j];序号++;
    
29.                                 }
    
30.                         }else{键盘数组[序号]=操作数组[i];序号++;}
    
31.                 }
    
32.         }else{键盘数组[序号]=操作数组;}
    
33.         let 操作组数=键盘数组.length;
    
34.         let 结构字节数=对象字节数(键盘数组[0]);        /*****计算结构对象字节数*****/
    
35.         let 总字节=结构字节数*操作组数;
    
36.        
    
37.         const 数组缓冲=new ArrayBuffer(总字节);        //操作对象数组写入缓冲
    
38.         for(let i=0;i<操作组数;i++){
    
39.                 结构对象填入数组缓冲(数组缓冲,i*结构字节数,键盘数组[i]);        /*****对象转数组缓冲*****/
    
40.         }
    
41.         const 执行宏调用=ExecuteExcel4Macro;        //申请内存
    
42.         const 内存地址=执行宏调用(`CALL("Kernel32","VirtualAlloc","JJJJJ",0,${总字节},${0x3000},4)`);
    
43.         数据写入内存(内存地址,数组缓冲,总字节);        /*****写入键盘操作结构*****/        //执行键盘操作
    
44.         键盘操作结果=执行宏调用(`CALL("User32","SendInput","JJJJ",${操作组数},${内存地址},${结构字节数})`);
    
45.         if(!键盘操作结果){console.log("错误代码："+执行宏调用(`CALL("Kernel32","GetLastError","I")`));}
    
46.         执行宏调用(`CALL("Kernel32", "VirtualFree", "JJJJ", ${内存地址}, 0, ${0x8000})`);        //释放内存
    
47. }
    
48. function 键盘操作对象(键码){
    
49.         class 键盘操作 {        //类
    
50.                 constructor(按键,动作){        //类的构造方法，用于构造属性
    
51.                         this.输入类型1 = [4,1],        //键盘1        //字节数，数据
    
52.                         this.虚拟键码2 = [4,按键],        //同ASCII码
    
53.                         this.键扫描码3 = [4,0],
    
54.                         this.输入操作4 = [4,动作],        //按键弹起2        启用扫描码8
    
55.                         this.时间戳值5 = [4,0],        //系统确定
    
56.                         this.扩展信息6 = [4,0],
    
57.                         this.数据填充0 = [4,0]        //都是4*7=28字节，不足部分补足
    
58.                 }
    
59.         };
    
60.         if(键码>='A'&&键码<='Z'){键码=键码.charCodeAt(0);}
    
61.         if(键码=='.'){键码=0xBE;}
    
62.         let 键盘对象 = new 键盘操作(键码,4|2);        //统一码0x4|2键弹起
    
63.         return 键盘对象;
    
64. }
    
65. function 对象字节数(结构对象){
    
66.         let 对象数据字节数=0;
    
67.         for (let 属性名 in 结构对象) {
    
68.                 if (结构对象.hasOwnProperty(属性名)) {
    
69.                         对象数据字节数+=结构对象[属性名][0];        //累加字节数
    
70.                 }
    
71.         }
    
72.         return 对象数据字节数;
    
73. }
    
74. function 结构对象填入数组缓冲(数组缓冲,偏移,结构对象){
    
75.         const 数据操作=new DataView(数组缓冲);
    
76.         let 字节数,待填数据;
    
77.         for (let 属性名 in 结构对象) {
    
78.                 if (结构对象.hasOwnProperty(属性名)) {
    
79.                         字节数=结构对象[属性名][0],待填数据=结构对象[属性名][1];
    
80.                         if(字节数==4){数据操作.setInt32(偏移,待填数据,true);}        //小端序
    
81.                         else{if(字节数==2){数据操作.setInt32(偏移,待填数据,true);}
    
82.                         else{if(字节数==1){数据操作.setInt32(偏移,待填数据,true);}}}
    
83.                         偏移+=字节数;
    
84.                 }
    
85.         }
    
86. }
    
87. function 数据写入内存(内存地址,数组缓冲,字节数){
    
88.         const 数据操作=new DataView(数组缓冲);
    
89.         let 偏移=i=0,待写数据=[],写入字节=[];
    
90.         while(字节数>偏移){
    
91.                 if(字节数-偏移>=4){待写数据[i]=数据操作.getInt32(偏移,true);写入字节[i]=4;i++;偏移+=4;}
    
92.                 else{if(字节数-偏移>=2){待写数据[i]=数据操作.getInt16(偏移,true);写入字节[i]=2;i++;偏移+=2;}
    
93.                 else{if(字节数-偏移==1){待写数据[i]=数据操作.getInt8(偏移,true);写入字节[i]=1;i++;偏移++;}}}
    
94.         }
    
95.         const 执行宏调用=ExecuteExcel4Macro;
    
96.         for(偏移=i=0;i<写入字节.length;i++){        //写入
    
97.                 执行宏调用(`CALL("Kernel32","RtlMoveMemory","2JNJ",${内存地址+偏移},${待写数据[i]},${写入字节[i]})`);
    
98.                 偏移+=写入字节[i];
    
99.         }
    
100. }

复制代码

a66

了解了