远程push易语言的子窗口

dghjgg

看到过一些易语言窗口push工具
现在打算试着整一个
先写个小白鼠程序看看吧


没有调用dll，代码逻辑应该大都在.exe里
查看-可执行模块(alt+e)

右键-在 CPU 中查看代码

（如果没转过来就再转一次）
右键-查找-命令（ctrl+f）

查找 push 10001

记录地址

右键-查找-下个（ctrl+l）

直到条目未找到
然后 右键-二进制字符串（cl+b）


记录上面这个

一个登录窗口，一个功能窗口。一个暗桩窗口
ff25 这里貌似不方便分析 暂时跳过
push 06010008
push 52010009
push 06010015
push 52010016
这里修改之后调用应该可行
只要把窗口ID换成对应的就可以了
不过有关联的地方还没处理

跟进去


里面还有CALL


之前有给ebx赋值的操作
跟过去这个地址

还有CALL，跟。。

（这里我看漏了 mou eax,* 这句，后面写代码的时候修正了）

好
接下来把代码记录下来
我的打算是拼到一块，修正偏移，再记录，就不用每次申请地址都搜索特征码和计算偏移了，只用更改窗口ID和给ebx赋值的地址
（之后不用每次修正CALL偏移了，但是还是用到了特征码定位某段函数）

1. 00600000    55                              push ebp
   
2. 00600001    8BEC                            mov ebp,esp
   
3. 00600003    68 02000080                     push 0x80000002
   
4. 00600008    6A 00                           push 0x0
   
5. 0060000A    68 00000000                     push 0x0
   
6. 0060000F    6A 00                           push 0x0
   
7. 00600011    6A 00                           push 0x0
   
8. 00600013    6A 00                           push 0x0
   
9. 00600015    68 01000100                     push 0x10001
   
10. 0060001A    90                              nop
    
11. 0060001B    68 15000106                     push 0x6010015
    
12. 00600020    68 16000152                     push 0x52010016
    
13. 00600025    90                              nop
    
14. 00600026    68 03000000                     push 0x3
    
15. 0060002B    90                              nop
    
16. 0060002C    BB 71006000                     mov ebx,0x600071
    
17. 00600031    E8 09000000                     call 0060003F
    
18. 00600036    90                              nop
    
19. 00600037    83C4 28                         add esp,0x28
    
20. 0060003A    8BE5                            mov esp,ebp
    
21. 0060003C    5D                              pop ebp
    
22. 0060003D    C3                             retn
    
23. 0060003E    90                              nop
    
24. 0060003F    8D4424 08                       lea eax,dword ptr ss:[esp+0x8]
    
25. 00600043    83EC 0C                         sub esp,0xC
    
26. 00600046    50                              push eax
    
27. 00600047    FF7424 14                       push dword ptr ss:[esp+0x14]
    
28. 0060004B    33C0                            xor eax,eax
    
29. 0060004D    894424 08                       mov dword ptr ss:[esp+0x8],eax
    
30. 00600051    894424 0C                       mov dword ptr ss:[esp+0xC],eax
    
31. 00600055    894424 10                       mov dword ptr ss:[esp+0x10],eax
    
32. 00600059    8D5424 08                       lea edx,dword ptr ss:[esp+0x8]
    
33. 0060005D    52                              push edx
    
34. 0060005E    FFD3                            call ebx
    
35. 00600060    8B4424 0C                       mov eax,dword ptr ss:[esp+0xC]
    
36. 00600064    8B5424 10                       mov edx,dword ptr ss:[esp+0x10]
    
37. 00600068    8B4C24 14                       mov ecx,dword ptr ss:[esp+0x14]
    
38. 0060006C    83C4 18                         add esp,0x18
    
39. 0060006F    C3                              retn
    
40. 00600070    90                              nop
    
41. 00600071    83EC 0C                         sub esp,0xC
    
42. 00600074    33C0                            xor eax,eax
    
43. 00600076    56                              push esi
    
44. 00600077    8B7424 1C                       mov esi,dword ptr ss:[esp+0x1C]
    
45. 0060007B    57                              push edi
    
46. 0060007C    8B7C24 18                       mov edi,dword ptr ss:[esp+0x18]
    
47. 00600080    C707 00000000                   mov dword ptr ds:[edi],0x0
    
48. 00600086    8B4E 14                         mov ecx,dword ptr ds:[esi+0x14]
    
49. 00600089    85C9                            test ecx,ecx
    
50. 0060008B    74 13                           je X006000A0
    
51. 0060008D    50                              push eax
    
52. 0060008E    8B46 0C                         mov eax,dword ptr ds:[esi+0xC]
    
53. 00600091    50                              push eax
    
54. 00600092    68 D6070000                     push 0x7D6
    
55. 00600097    E8 37000000                     call 006000D3
    
56. 0060009C    85C0                            test eax,eax
    
57. 0060009E    74 2C                          je X006000CC
    
58. 006000A0    8B0E                            mov ecx,dword ptr ds:[esi]
    
59. 006000A2    8B56 18                         mov edx,dword ptr ds:[esi+0x18]
    
60. 006000A5    894424 0C                       mov dword ptr ss:[esp+0xC],eax
    
61. 006000A9    8D4424 08                       lea eax,dword ptr ss:[esp+0x8]
    
62. 006000AD    6A 00                           push 0x0
    
63. 006000AF    50                              push eax
    
64. 006000B0    68 D5070000                     push 0x7D5
    
65. 006000B5    894C24 14                       mov dword ptr ss:[esp+0x14],ecx
    
66. 006000B9    895424 1C                       mov dword ptr ss:[esp+0x1C],edx
    
67. 006000BD    E8 11000000                     call 006000D3
    
68. 006000C2    85C0                            test eax,eax
    
69. 006000C4    75 06                           jnz X006000CC
    
70. 006000C6    C707 01000000                  mov dword ptr ds:[edi],0x1
    
71. 006000CC    5F                             pop edi
    
72. 006000CD    5E                              pop esi
    
73. 006000CE    83C4 0C                         add esp,0xC
    
74. 006000D1    C3                              retn
    
75. 006000D2    90                              nop
    
76. 006000D3    A1 6C674B00                     mov eax,dword ptr ds:[0x4B676C]
    
77. 006000D8    85C0                            test eax,eax
    
78. 006000DA    74 14                           je X006000F0
    
79. 006000DC    8B4C24 0C                       mov ecx,dword ptr ss:[esp+0xC]
    
80. 006000E0    8B5424 08                       mov edx,dword ptr ss:[esp+0x8]
    
81. 006000E4    51                              push ecx
    
82. 006000E5    8B4C24 08                       mov ecx,dword ptr ss:[esp+0x8]
    
83. 006000E9    52                              push edx
    
84. 006000EA    51                              push ecx
    
85. 006000EB    FFD0                            call eax
    
86. 006000ED    C2 0C00                         retn 0xC
    
87. 006000F0    33C0                            xor eax,eax
    
88. 006000F2    C2 0C00                         retn 0xC
    
89. 006000F5    90                              nop
    

复制代码

要申请 F6 也就是 246 个字节的长度的内存
申请的地址 +1C 即 +28 为 060*****的地址
申请的地址 +21 即 +33 为 520*****的地址
060***** 和 520***** 相差 4C00 0001
060***** 520***** mov ebx,******** 要每次调整
接下来到易语言了
过程很繁琐
只记录了一点点
写的时候发现有数据错了
申请的地址 +45 为 mov ebx,* 的赋值指令地址
+113 为 赋值指令指向地址

ebx位置的CALL的里面的CALL没法拼过来了
只能特征码搜索地址并修正偏移了

85 C0 74 14 8B 4C 24 0C 8B 54 24 08 51 8B 4C 24 08 52 51 FF D0 C2 0C 00 33 C0 C2 0C 00
搜索到的地址-4 即是

不过，我后面想到可以把搜索到的地址的字节复制到未修正的代码处
好像这个也没方便多少，阿巴

申请 + 211 被修正的ebx_c_call


越写越乱

不过搞了好久
总算写完了写入和修正数据的部分了


很好看的一个UI，对吧

  

子程序名	返回值类型	公开	备 注
_窗口1_创建完毕

进程_提升权限到Debug ()
图片框_PID.鼠标指针 ＝ { 8 }

子程序名	返回值类型	公开	备 注
_图片框_PID_鼠标左键被按下	逻辑型
参数名	类 型	参考	可空	数组	备 注
横向位置	整数型
纵向位置	整数型
功能键状态	整数型

图片框_PID.鼠标指针 ＝ { 8 }
图片框_PID.背景颜色 ＝ #白色
处理事件 ()
鼠标_捕获 (图片框_PID.取窗口句柄 ())

子程序名	返回值类型	公开	备 注
_图片框_PID_鼠标左键被放开	逻辑型
参数名	类 型	参考	可空	数组	备 注
横向位置	整数型
纵向位置	整数型
功能键状态	整数型

鼠标_释放 ()
处理事件 ()
窗口句柄 ＝ 取鼠标所在窗口句柄 ()
PID ＝ 窗口_句柄取进程ID (窗口句柄)
进程名 ＝ 窗口_句柄取进程名 (窗口句柄)
标签_PID.标题 ＝ 到文本 (PID) ＋ #换行符 ＋ 进程名
图片框_PID.背景颜色 ＝ #黑色

i支持库列表	支持库注释
eAPI	应用接口支持库

.版本 2<br /> .支持库 eAPI<br /> <br /> .子程序 _窗口1_创建完毕<br /> <br /> 进程_提升权限到Debug ()<br /> 图片框_PID.鼠标指针 ＝ { 8 }<br /> <br /> <br /> .子程序 _图片框_PID_鼠标左键被按下, 逻辑型<br /> .参数 横向位置, 整数型<br /> .参数 纵向位置, 整数型<br /> .参数 功能键状态, 整数型<br /> <br /> 图片框_PID.鼠标指针 ＝ { 8 }<br /> 图片框_PID.背景颜色 ＝ #白色<br /> 处理事件 ()<br /> 鼠标_捕获 (图片框_PID.取窗口句柄 ())<br /> <br /> <br /> .子程序 _图片框_PID_鼠标左键被放开, 逻辑型<br /> .参数 横向位置, 整数型<br /> .参数 纵向位置, 整数型<br /> .参数 功能键状态, 整数型<br /> <br /> 鼠标_释放 ()<br /> 处理事件 ()<br /> 窗口句柄 ＝ 取鼠标所在窗口句柄 ()<br /> PID ＝ 窗口_句柄取进程ID (窗口句柄)<br /> 进程名 ＝ 窗口_句柄取进程名 (窗口句柄)<br /> 标签_PID.标题 ＝ 到文本 (PID) ＋ #换行符 ＋ 进程名<br /> 图片框_PID.背景颜色 ＝ #黑色

这里是获得PID的代码逻辑

  

子程序名	返回值类型	公开	备 注
_按钮_获取信息_被单击

变量名	类 型	静态	数组	备 注
i	整数型
目标地址数量	整数型
目标地址	整数型		0
窗口ID地址	整数型		0

清除数组 (窗口ID地址)
编辑框_信息.加入文本 ( #换行符 ＋ “正在搜索 push 10001 请等亿下” ＋ #换行符 ＋ #换行符 )
目标地址数量 ＝ _搜索字节集 (PID, { 104, 1, 0, 1, 0 }, 目标地址)  ' 搜索 push 10001 6A 00 6A 00 6A 00 68 01 00 01 00
计次循环首 (目标地址数量, i)
如果真 (遍历_地址所在模块_32 (PID, 目标地址 [i]))
编辑框_信息.加入文本 (进制_十到十六 (目标地址 [i], ) ＋ #换行符 )
加入成员 (窗口ID地址, 内存.读整数 (PID, 目标地址 [i] ＋ 11))

计次循环尾 ()
编辑框_信息.加入文本 ( #换行符 ＋ “正在搜索 FF 25 请等亿下” ＋ #换行符 ＋ #换行符 )
目标地址数量 ＝ _搜索字节集 (PID, { 51, 192, 195, 255, 37 }, 目标地址)  ' 搜索 FF 25 | 33 C0 C3 FF 25
计次循环首 (目标地址数量, i)
如果真 (遍历_地址所在模块_32 (PID, 目标地址 [i]))
编辑框_信息.加入文本 (进制_十到十六 (目标地址 [i], ) ＋ #换行符 )
加入成员 (窗口ID地址, 内存.读整数 (PID, 目标地址 [i] － 17))

计次循环尾 ()
编辑框_信息.加入文本 ( #换行符 ＋ “正在搜索 ebx位置的CALL的里面的CALL的地址 请等亿下” ＋ #换行符 ＋ #换行符 )
' 85 C0 74 14 8B 4C 24 0C 8B 54 24 08 51 8B 4C 24 08 52 51 FF D0 C2 0C 00 33 C0 C2 0C 00
_搜索字节集 (PID, { 133, 192, 116, 20, 139, 76, 36, 12, 139, 84, 36, 8, 81, 139, 76, 36, 8, 82, 81, 255, 208, 194, 12, 0, 51, 192, 194, 12, 0 }, ebx位置的CALL的里面的CALL地址)  ' 搜索 ebx位置的CALL的里面的CALL的地址
如果 (取数组成员数 (ebx位置的CALL的里面的CALL地址) ＞ 0)
ebx_call_call ＝ ebx位置的CALL的里面的CALL地址 [1] － 5
编辑框_信息.加入文本 (进制_十到十六 (ebx位置的CALL的里面的CALL地址 [1] － 5, ) ＋ #换行符 )
编辑框_信息.加入文本 (“没有搜索到ebx位置的CALL的里面的CALL的地址” ＋ #换行符 )
编辑框_信息.加入文本 ( #换行符 ＋ “窗口ID：” ＋ #换行符 ＋ #换行符 )
计次循环首 (取数组成员数 (窗口ID地址), i)
编辑框_信息.加入文本 (进制_十到十六 (窗口ID地址 [i], ) ＋ #换行符 )
计次循环尾 ()

子程序名	返回值类型	公开	备 注
_搜索字节集	整数型		精易模块扣下来的
参数名	类 型	参考	可空	数组	备 注
进程ID	整数型				进程ID
搜索内容	字节集				欲搜索的内容  其他类型-需自行转换为字节集类型
结果数组	整数型	√		√	用来保存搜索的结果

变量名	类 型	静态	数组	备 注
长度	整数型
操作句柄	整数型
内存地址	整数型
内存块信息	精易_内存属性
数据缓冲区	字节集
读取结果	逻辑型
找到地址	整数型

清除数组 (结果数组)
长度 ＝ 取字节集长度 (搜索内容)
操作句柄 ＝ OpenProcess (2035711, 0, 进程ID)  ' 取得操作句柄
判断循环首 (VirtualQueryEx (操作句柄, 内存地址, 内存块信息, 28) ≠ 0)  ' 取得内存块信息
如果真 (内存块信息.保留值 ＝ 4096 且 内存块信息.当前属性 ≠ 4 且 内存块信息.页类型 ＝ 16777216 且 内存块信息.当前属性 ≠ 8 且 内存块信息.当前属性 ≠ 64)  ' 判断保护状态
调试输出 (内存块信息.当前属性)
' 内存块信息.当前属性 ≠ 4 且 内存块信息.当前属性 ≠ 8 且 内存块信息.当前属性 ≠ 64
数据缓冲区 ＝ 取空白字节集 (内存块信息.区域长度)
读取结果 ＝ ReadProcessMemory_字节集 (操作句柄, 内存地址, 数据缓冲区, 内存块信息.区域长度, 0)
判断循环首 (读取结果 ≠ 假)
找到地址 ＝ 寻找字节集 (数据缓冲区, 搜索内容, 找到地址)  ' 查找是否有要搜索的数据
如果 (找到地址 ＝ -1)  ' 跳出 进行下次循环
跳出循环 ()
' dghjgg
加入成员 (结果数组, 到数值 (内存地址 ＋ 找到地址 － 1))
找到地址 ＝ 找到地址 ＋ 长度
判断循环尾 ()
内存地址 ＝ 内存地址 ＋ 内存块信息.区域长度  ' 搜索下一内存块
处理事件 ()
判断循环尾 ()
CloseHandle (操作句柄)
返回 (取数组成员数 (结果数组))

子程序名	返回值类型	公开	备 注
遍历_地址所在模块_32	逻辑型		在进程名模块返回真 用某个程序的某个子程序改了改
参数名	类 型	参考	可空	数组	备 注
进程ID	整数型				PID
目标地址	整数型				查之地址

变量名	类 型	静态	数组	备 注
ret	字节集
偏移量	整数型
快照句柄	整数型
查找状态	逻辑型
模块信息	LPMODULEENTRY32

' 置入代码 (#保护函数头)
快照句柄 ＝ API_CreateToolhelp32Snapshot (8, 进程ID)
如果真 (快照句柄 ≠ -1)
模块信息.size ＝ 548
查找状态 ＝ API_Module32First (快照句柄, 模块信息)
如果真 (查找状态)
判断循环首 (查找状态)
' 标准输出 (, “模块ID”, 字符 (9), 模块信息.模块ID, #换行符)
' 标准输出 (, “进程ID”, 字符 (9), 模块信息.进程ID, #换行符)
' 标准输出 (, “模块名”, 字符 (9), 到文本 (模块信息.模块名), #换行符)
' 标准输出 (, “模块基址”, 字符 (9), 模块信息.模块基址, #换行符)
' 标准输出 (, “模块大小”, 字符 (9), 模块信息.模块大小, #换行符)
' 标准输出 (, “模块句柄”, 字符 (9), 模块信息.模块句柄, #换行符)
' 标准输出 (, “模块路径”, 字符 (9), 到文本 (模块信息.模块路径), #换行符)
如果真 (进程名 ＝ 到文本 (模块信息.模块名))
' 暂停 ()
如果真 (目标地址 ≥ 模块信息.模块基址 且 目标地址 ≤ 模块信息.模块基址 ＋ 模块信息.模块大小 － 1)
API_CloseHandle (快照句柄)
返回 (真)

查找状态 ＝ API_Module32Next (快照句柄, 模块信息)
判断循环尾 ()
API_CloseHandle (快照句柄)

返回 (假)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _按钮_获取信息_被单击<br /> .局部变量 i, 整数型<br /> .局部变量 目标地址数量, 整数型<br /> .局部变量 目标地址, 整数型, , "0"<br /> .局部变量 窗口ID地址, 整数型, , "0"<br /> <br /> 清除数组 (窗口ID地址)<br /> 编辑框_信息.加入文本 (#换行符 ＋ “正在搜索 push 10001 请等亿下” ＋ #换行符 ＋ #换行符)<br /> 目标地址数量 ＝ _搜索字节集 (PID, { 104, 1, 0, 1, 0 }, 目标地址)  ' 搜索 push 10001 6A 00 6A 00 6A 00 68 01 00 01 00<br /> .计次循环首 (目标地址数量, i)<br />     .如果真 (遍历_地址所在模块_32 (PID, 目标地址 <i>))<br />         编辑框_信息.加入文本 (进制_十到十六 (目标地址 <i>, ) ＋ #换行符)<br />         加入成员 (窗口ID地址, 内存.读整数 (PID, 目标地址 <i> ＋ 11))<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 编辑框_信息.加入文本 (#换行符 ＋ “正在搜索 FF 25 请等亿下” ＋ #换行符 ＋ #换行符)<br /> 目标地址数量 ＝ _搜索字节集 (PID, { 51, 192, 195, 255, 37 }, 目标地址)  ' 搜索 FF 25 | 33 C0 C3 FF 25<br /> .计次循环首 (目标地址数量, i)<br />     .如果真 (遍历_地址所在模块_32 (PID, 目标地址 <i>))<br />         编辑框_信息.加入文本 (进制_十到十六 (目标地址 <i>, ) ＋ #换行符)<br />         加入成员 (窗口ID地址, 内存.读整数 (PID, 目标地址 <i> － 17))<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 编辑框_信息.加入文本 (#换行符 ＋ “正在搜索 ebx位置的CALL的里面的CALL的地址 请等亿下” ＋ #换行符 ＋ #换行符)<br /> ' 85 C0 74 14 8B 4C 24 0C 8B 54 24 08 51 8B 4C 24 08 52 51 FF D0 C2 0C 00 33 C0 C2 0C 00<br /> _搜索字节集 (PID, { 133, 192, 116, 20, 139, 76, 36, 12, 139, 84, 36, 8, 81, 139, 76, 36, 8, 82, 81, 255, 208, 194, 12, 0, 51, 192, 194, 12, 0 }, ebx位置的CALL的里面的CALL地址)  ' 搜索 ebx位置的CALL的里面的CALL的地址<br /> .如果 (取数组成员数 (ebx位置的CALL的里面的CALL地址) ＞ 0)<br />     ebx_call_call ＝ ebx位置的CALL的里面的CALL地址 [1] － 5<br />     编辑框_信息.加入文本 (进制_十到十六 (ebx位置的CALL的里面的CALL地址 [1] － 5, ) ＋ #换行符)<br /> .否则<br />     编辑框_信息.加入文本 (“没有搜索到ebx位置的CALL的里面的CALL的地址” ＋ #换行符)<br /> .如果结束<br /> 编辑框_信息.加入文本 (#换行符 ＋ “窗口ID：” ＋ #换行符 ＋ #换行符)<br /> .计次循环首 (取数组成员数 (窗口ID地址), i)<br />     编辑框_信息.加入文本 (进制_十到十六 (窗口ID地址 <i>, ) ＋ #换行符)<br /> .计次循环尾 ()<br /> <br /> <br /> <br /> .子程序 _搜索字节集, 整数型, , 精易模块扣下来的<br /> .参数 进程ID, 整数型, , 进程ID<br /> .参数 搜索内容, 字节集, , 欲搜索的内容  其他类型-需自行转换为字节集类型<br /> .参数 结果数组, 整数型, 参考 数组, 用来保存搜索的结果<br /> .局部变量 长度, 整数型<br /> .局部变量 操作句柄, 整数型<br /> .局部变量 内存地址, 整数型<br /> .局部变量 内存块信息, 精易_内存属性<br /> .局部变量 数据缓冲区, 字节集<br /> .局部变量 读取结果, 逻辑型<br /> .局部变量 找到地址, 整数型<br /> <br /> 清除数组 (结果数组)<br /> 长度 ＝ 取字节集长度 (搜索内容)<br /> 操作句柄 ＝ OpenProcess (2035711, 0, 进程ID)  ' 取得操作句柄<br /> .判断循环首 (VirtualQueryEx (操作句柄, 内存地址, 内存块信息, 28) ≠ 0)  ' 取得内存块信息<br />     .如果真 (内存块信息.保留值 ＝ 4096 且 内存块信息.当前属性 ≠ 4 且 内存块信息.页类型 ＝ 16777216 且 内存块信息.当前属性 ≠ 8 且 内存块信息.当前属性 ≠ 64)  ' 判断保护状态<br />         调试输出 (内存块信息.当前属性)<br />         ' 内存块信息.当前属性 ≠ 4 且 内存块信息.当前属性 ≠ 8 且 内存块信息.当前属性 ≠ 64<br />         数据缓冲区 ＝ 取空白字节集 (内存块信息.区域长度)<br />         读取结果 ＝ ReadProcessMemory_字节集 (操作句柄, 内存地址, 数据缓冲区, 内存块信息.区域长度, 0)<br />         .判断循环首 (读取结果 ≠ 假)<br />             找到地址 ＝ 寻找字节集 (数据缓冲区, 搜索内容, 找到地址)  ' 查找是否有要搜索的数据<br />             .如果 (找到地址 ＝ -1)  ' 跳出 进行下次循环<br />                 跳出循环 ()<br />                 ' dghjgg<br />             .否则<br />                 加入成员 (结果数组, 到数值 (内存地址 ＋ 找到地址 － 1))<br />             .如果结束<br />             找到地址 ＝ 找到地址 ＋ 长度<br />         .判断循环尾 ()<br />     .如果真结束<br />     内存地址 ＝ 内存地址 ＋ 内存块信息.区域长度  ' 搜索下一内存块<br />     处理事件 ()<br /> .判断循环尾 ()<br /> CloseHandle (操作句柄)<br /> 返回 (取数组成员数 (结果数组))<br /> <br /> <br /> .子程序 遍历_地址所在模块_32, 逻辑型, , 在进程名模块返回真 用某个程序的某个子程序改了改<br /> .参数 进程ID, 整数型, , PID<br /> .参数 目标地址, 整数型, , 查之地址<br /> .局部变量 ret, 字节集<br /> .局部变量 偏移量, 整数型<br /> .局部变量 快照句柄, 整数型<br /> .局部变量 查找状态, 逻辑型<br /> .局部变量 模块信息, LPMODULEENTRY32<br /> <br /> ' 置入代码 (#保护函数头)<br /> 快照句柄 ＝ API_CreateToolhelp32Snapshot (8, 进程ID)<br /> .如果真 (快照句柄 ≠ -1)<br />     模块信息.size ＝ 548<br />     查找状态 ＝ API_Module32First (快照句柄, 模块信息)<br />     .如果真 (查找状态)<br />         .判断循环首 (查找状态)<br />             ' 标准输出 (, “模块ID”, 字符 (9), 模块信息.模块ID, #换行符)<br />             ' 标准输出 (, “进程ID”, 字符 (9), 模块信息.进程ID, #换行符)<br />             ' 标准输出 (, “模块名”, 字符 (9), 到文本 (模块信息.模块名), #换行符)<br />             ' 标准输出 (, “模块基址”, 字符 (9), 模块信息.模块基址, #换行符)<br />             ' 标准输出 (, “模块大小”, 字符 (9), 模块信息.模块大小, #换行符)<br />             ' 标准输出 (, “模块句柄”, 字符 (9), 模块信息.模块句柄, #换行符)<br />             ' 标准输出 (, “模块路径”, 字符 (9), 到文本 (模块信息.模块路径), #换行符)<br />             .如果真 (进程名 ＝ 到文本 (模块信息.模块名))<br />                 ' 暂停 ()<br />                 .如果真 (目标地址 ≥ 模块信息.模块基址 且 目标地址 ≤ 模块信息.模块基址 ＋ 模块信息.模块大小 － 1)<br />                     API_CloseHandle (快照句柄)<br />                     返回 (真)<br />                 .如果真结束<br /> <br />             .如果真结束<br />             查找状态 ＝ API_Module32Next (快照句柄, 模块信息)<br />         .判断循环尾 ()<br />     .如果真结束<br />     API_CloseHandle (快照句柄)<br /> .如果真结束<br /> <br /> 返回 (假)

这里是获取目标进程的窗口ID的代码逻辑

  

子程序名	返回值类型	公开	备 注
_按钮_载入窗口_被单击

变量名	类 型	静态	数组	备 注
申请地址	整数型
阿巴阿巴地址	整数型
窗口ID地址	整数型
未修正代码写入状态	逻辑型
所载窗口ID	整数型
ebx赋值指令指向地址	整数型
ebx赋值指令地址	整数型
被修正的ebx_c_c	整数型

如果真 (编辑框_窗口ID.内容 ＝ “”)
信息框 (“请输入窗口ID”, 0, , )
返回 ()
申请地址 ＝ _远程申请内存 (PID, 246)
如果 (申请地址 ≠ 0)
编辑框_信息.加入文本 (“申请内存成功 地址是 ” ＋ 进制_十到十六 (申请地址, ) ＋ #换行符 )
' 55 8B EC 68 02 00 00 80 6A 00 68 00 00 00 00 6A 00 6A 00 6A 00 68 01 00 01 00 90 68 15 00 01 06 68 16 00 01 52 90 68 03 00 00 00 90 BB 71 00 60 00 E8 09 00 00 00 90 83 C4 28 8B E5 5D C3 90 8D 44 24 08 83 EC 0C 50 FF 74 24 14 33 C0 89 44 24 08 89 44 24 0C 89 44 24 10 8D 54 24 08 52 FF D3 8B 44 24 0C 8B 54 24 10 8B 4C 24 14 83 C4 18 C3 90 83 EC 0C 33 C0 56 8B 74 24 1C 57 8B 7C 24 18 C7 07 00 00 00 00 8B 4E 14 85 C9 74 13 50 8B 46 0C 50 68 D6 07 00 00 E8 37 00 00 00 85 C0 74 2C 8B 0E 8B 56 18 89 44 24 0C 8D 44 24 08 6A 00 50 68 D5 07 00 00 89 4C 24 14 89 54 24 1C E8 11 00 00 00 85 C0 75 06 C7 07 01 00 00 00 5F 5E 83 C4 0C C3 90 A1 6C 67 4B 00 85 C0 74 14 8B 4C 24 0C 8B 54 24 08 51 8B 4C 24 08 52 51 FF D0 C2 0C 00 33 C0 C2 0C 00 90
未修正代码写入状态 ＝ 内存.写字节集 (PID, 申请地址, { 85, 139, 236, 104, 2, 0, 0, 128, 106, 0, 104, 0, 0, 0, 0, 106, 0, 106, 0, 106, 0, 104, 1, 0, 1, 0, 144, 104, 21, 0, 1, 6, 104, 22, 0, 1, 82, 144, 104, 3, 0, 0, 0, 144, 187, 113, 0, 96, 0, 232, 9, 0, 0, 0, 144, 131, 196, 40, 139, 229, 93, 195, 144, 141, 68, 36, 8, 131, 236, 12, 80, 255, 116, 36, 20, 51, 192, 137, 68, 36, 8, 137, 68, 36, 12, 137, 68, 36, 16, 141, 84, 36, 8, 82, 255, 211, 139, 68, 36, 12, 139, 84, 36, 16, 139, 76, 36, 20, 131, 196, 24, 195, 144, 131, 236, 12, 51, 192, 86, 139, 116, 36, 28, 87, 139, 124, 36, 24, 199, 7, 0, 0, 0, 0, 139, 78, 20, 133, 201, 116, 19, 80, 139, 70, 12, 80, 104, 214, 7, 0, 0, 232, 55, 0, 0, 0, 133, 192, 116, 44, 139, 14, 139, 86, 24, 137, 68, 36, 12, 141, 68, 36, 8, 106, 0, 80, 104, 213, 7, 0, 0, 137, 76, 36, 20, 137, 84, 36, 28, 232, 17, 0, 0, 0, 133, 192, 117, 6, 199, 7, 1, 0, 0, 0, 95, 94, 131, 196, 12, 195, 144, 161, 108, 103, 75, 0, 133, 192, 116, 20, 139, 76, 36, 12, 139, 84, 36, 8, 81, 139, 76, 36, 8, 82, 81, 255, 208, 194, 12, 0, 51, 192, 194, 12, 0, 144 })  ' 额 该怎么说呢 问就是 带个好举高高 低功耗九宫格 反正不是 dghjgg
如果 (未修正代码写入状态)
阿巴阿巴地址 ＝ 申请地址 ＋ 28
窗口ID地址 ＝ 申请地址 ＋ 33
所载窗口ID ＝ 进制_十六到十 (编辑框_窗口ID.内容)
ebx赋值指令地址 ＝ 申请地址 ＋ 45
ebx赋值指令指向地址 ＝ 申请地址 ＋ 113
被修正的ebx_c_c ＝ 申请地址 ＋ 211
调试输出 (进制_十到十六 (阿巴阿巴地址, ), 进制_十到十六 (窗口ID地址, ), 进制_十到十六 (所载窗口ID, ), 进制_十到十六 (ebx赋值指令地址, ))
如果真 (ebx_call_call ＞ 0)
内存.写字节集 (PID, 被修正的ebx_c_c, 内存.读字节集 (PID, ebx_call_call, 5))
调试输出 (进制_十到十六 (ebx_call_call, ), 进制_十到十六 (被修正的ebx_c_c, ))
内存.写整数 (PID, 阿巴阿巴地址, 所载窗口ID － 到整数 (进制_十六到十 (“4C000001”)), )
内存.写整数 (PID, 窗口ID地址, 所载窗口ID, )
内存.写整数 (PID, ebx赋值指令地址, ebx赋值指令指向地址, )
进程句柄 ＝ 进程_打开1 (PID)
调试输出 (进程句柄)
启动线程_hThread (进程句柄, 申请地址, , )
进程_关闭 (进程句柄)

编辑框_信息.加入文本 (“写入未修正逻辑代码失败” ＋ #换行符 )


编辑框_信息.加入文本 (“申请内存失败” ＋ #换行符 )

子程序名	返回值类型	公开	备 注
启动线程_hThread	整数型		某个子程序移过来的 诶嘿
参数名	类 型	参考	可空	数组	备 注
进程句柄	整数型
子程序地址	整数型
参数	整数型		√
线程ID	整数型	√	√		可提供变量保存新建线程的ID，不需要请留空。

返回 (API_CreateRemoteThread (进程句柄, 0, 0, 子程序地址, 参数, 0, 线程ID))

子程序名	返回值类型	公开	备 注
_远程申请内存	整数型
参数名	类 型	参考	可空	数组	备 注
进程ID	整数型
申请长度	整数型

变量名	类 型	静态	数组	备 注
ret	整数型
进程句柄	整数型

进程句柄 ＝ OpenProcess (2035711, 0, 进程ID)
ret ＝ API_VirtualAllocEx (进程句柄, 0, 申请长度, 4096, 64)
CloseHandle (进程句柄)
返回 (ret)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _按钮_载入窗口_被单击<br /> .局部变量 申请地址, 整数型<br /> .局部变量 阿巴阿巴地址, 整数型<br /> .局部变量 窗口ID地址, 整数型<br /> .局部变量 未修正代码写入状态, 逻辑型<br /> .局部变量 所载窗口ID, 整数型<br /> .局部变量 ebx赋值指令指向地址, 整数型<br /> .局部变量 ebx赋值指令地址, 整数型<br /> .局部变量 被修正的ebx_c_c, 整数型<br /> <br /> .如果真 (编辑框_窗口ID.内容 ＝ “”)<br />     信息框 (“请输入窗口ID”, 0, , )<br />     返回 ()<br /> .如果真结束<br /> 申请地址 ＝ _远程申请内存 (PID, 246)<br /> .如果 (申请地址 ≠ 0)<br />     编辑框_信息.加入文本 (“申请内存成功 地址是 ” ＋ 进制_十到十六 (申请地址, ) ＋ #换行符)<br />     ' 55 8B EC 68 02 00 00 80 6A 00 68 00 00 00 00 6A 00 6A 00 6A 00 68 01 00 01 00 90 68 15 00 01 06 68 16 00 01 52 90 68 03 00 00 00 90 BB 71 00 60 00 E8 09 00 00 00 90 83 C4 28 8B E5 5D C3 90 8D 44 24 08 83 EC 0C 50 FF 74 24 14 33 C0 89 44 24 08 89 44 24 0C 89 44 24 10 8D 54 24 08 52 FF D3 8B 44 24 0C 8B 54 24 10 8B 4C 24 14 83 C4 18 C3 90 83 EC 0C 33 C0 56 8B 74 24 1C 57 8B 7C 24 18 C7 07 00 00 00 00 8B 4E 14 85 C9 74 13 50 8B 46 0C 50 68 D6 07 00 00 E8 37 00 00 00 85 C0 74 2C 8B 0E 8B 56 18 89 44 24 0C 8D 44 24 08 6A 00 50 68 D5 07 00 00 89 4C 24 14 89 54 24 1C E8 11 00 00 00 85 C0 75 06 C7 07 01 00 00 00 5F 5E 83 C4 0C C3 90 A1 6C 67 4B 00 85 C0 74 14 8B 4C 24 0C 8B 54 24 08 51 8B 4C 24 08 52 51 FF D0 C2 0C 00 33 C0 C2 0C 00 90<br />     未修正代码写入状态 ＝ 内存.写字节集 (PID, 申请地址, { 85, 139, 236, 104, 2, 0, 0, 128, 106, 0, 104, 0, 0, 0, 0, 106, 0, 106, 0, 106, 0, 104, 1, 0, 1, 0, 144, 104, 21, 0, 1, 6, 104, 22, 0, 1, 82, 144, 104, 3, 0, 0, 0, 144, 187, 113, 0, 96, 0, 232, 9, 0, 0, 0, 144, 131, 196, 40, 139, 229, 93, 195, 144, 141, 68, 36, 8, 131, 236, 12, 80, 255, 116, 36, 20, 51, 192, 137, 68, 36, 8, 137, 68, 36, 12, 137, 68, 36, 16, 141, 84, 36, 8, 82, 255, 211, 139, 68, 36, 12, 139, 84, 36, 16, 139, 76, 36, 20, 131, 196, 24, 195, 144, 131, 236, 12, 51, 192, 86, 139, 116, 36, 28, 87, 139, 124, 36, 24, 199, 7, 0, 0, 0, 0, 139, 78, 20, 133, 201, 116, 19, 80, 139, 70, 12, 80, 104, 214, 7, 0, 0, 232, 55, 0, 0, 0, 133, 192, 116, 44, 139, 14, 139, 86, 24, 137, 68, 36, 12, 141, 68, 36, 8, 106, 0, 80, 104, 213, 7, 0, 0, 137, 76, 36, 20, 137, 84, 36, 28, 232, 17, 0, 0, 0, 133, 192, 117, 6, 199, 7, 1, 0, 0, 0, 95, 94, 131, 196, 12, 195, 144, 161, 108, 103, 75, 0, 133, 192, 116, 20, 139, 76, 36, 12, 139, 84, 36, 8, 81, 139, 76, 36, 8, 82, 81, 255, 208, 194, 12, 0, 51, 192, 194, 12, 0, 144 })  ' 额 该怎么说呢 问就是 带个好举高高 低功耗九宫格 反正不是 dghjgg<br /> <br />     .如果 (未修正代码写入状态)<br />         阿巴阿巴地址 ＝ 申请地址 ＋ 28<br />         窗口ID地址 ＝ 申请地址 ＋ 33<br />         所载窗口ID ＝ 进制_十六到十 (编辑框_窗口ID.内容)<br />         ebx赋值指令地址 ＝ 申请地址 ＋ 45<br />         ebx赋值指令指向地址 ＝ 申请地址 ＋ 113<br />         被修正的ebx_c_c ＝ 申请地址 ＋ 211<br />         调试输出 (进制_十到十六 (阿巴阿巴地址, ), 进制_十到十六 (窗口ID地址, ), 进制_十到十六 (所载窗口ID, ), 进制_十到十六 (ebx赋值指令地址, ))<br />         .如果真 (ebx_call_call ＞ 0)<br />             内存.写字节集 (PID, 被修正的ebx_c_c, 内存.读字节集 (PID, ebx_call_call, 5))<br />             调试输出 (进制_十到十六 (ebx_call_call, ), 进制_十到十六 (被修正的ebx_c_c, ))<br />         .如果真结束<br />         内存.写整数 (PID, 阿巴阿巴地址, 所载窗口ID － 到整数 (进制_十六到十 (“4C000001”)), )<br />         内存.写整数 (PID, 窗口ID地址, 所载窗口ID, )<br />         内存.写整数 (PID, ebx赋值指令地址, ebx赋值指令指向地址, )<br /> <br />         进程句柄 ＝ 进程_打开1 (PID)<br />         调试输出 (进程句柄)<br />         启动线程_hThread (进程句柄, 申请地址, , )<br />         进程_关闭 (进程句柄)<br /> <br />     .否则<br />         编辑框_信息.加入文本 (“写入未修正逻辑代码失败” ＋ #换行符)<br />     .如果结束<br /> <br /> <br /> <br /> .否则<br />     编辑框_信息.加入文本 (“申请内存失败” ＋ #换行符)<br /> .如果结束<br /> <br /> <br /> <br /> .子程序 启动线程_hThread, 整数型, , 某个子程序移过来的 诶嘿<br /> .参数 进程句柄, 整数型<br /> .参数 子程序地址, 整数型<br /> .参数 参数, 整数型, 可空<br /> .参数 线程ID, 整数型, 参考 可空, 可提供变量保存新建线程的ID，不需要请留空。<br /> <br /> 返回 (API_CreateRemoteThread (进程句柄, 0, 0, 子程序地址, 参数, 0, 线程ID))<br /> <br /> <br /> .子程序 _远程申请内存, 整数型<br /> .参数 进程ID, 整数型<br /> .参数 申请长度, 整数型<br /> .局部变量 ret, 整数型<br /> .局部变量 进程句柄, 整数型<br /> <br /> 进程句柄 ＝ OpenProcess (2035711, 0, 进程ID)<br /> ret ＝ API_VirtualAllocEx (进程句柄, 0, 申请长度, 4096, 64)<br /> CloseHandle (进程句柄)<br /> 返回 (ret)

这里是载入指定窗口的代码逻辑

刚刚讲到到这了

按下载入窗口后

只有一闪而过的窗口
我多按几次按钮


额
多个窗口一闪而过
这个问题
我不会
所以
摆烂吧
学其他工具和插件
载入子窗口

看看区别

1. 55 8B EC 68 02 00 00 80 6A 00 68 01 00 00 00
   
2. 
   
3. 55 8B EC 68 02 00 00 80 6A 00 68 01 00 00 00 6A 00 6A 00 6A 00 68 01 00 01 00 90 68 15 00 01 06 68 16 00 01 52 90 68 03 00 00 00 90 BB 71 00 60 00 E8 09 00 00 00 90 83 C4 28 8B E5 5D C3 90 8D 44 24 08 83 EC 0C 50 FF 74 24 14 33 C0 89 44 24 08 89 44 24 0C 89 44 24 10 8D 54 24 08 52 FF D3 8B 44 24 0C 8B 54 24 10 8B 4C 24 14 83 C4 18 C3 90 83 EC 0C 33 C0 56 8B 74 24 1C 57 8B 7C 24 18 C7 07 00 00 00 00 8B 4E 14 85 C9 74 13 50 8B 46 0C 50 68 D6 07 00 00 E8 37 00 00 00 85 C0 74 2C 8B 0E 8B 56 18 89 44 24 0C 8D 44 24 08 6A 00 50 68 D5 07 00 00 89 4C 24 14 89 54 24 1C E8 11 00 00 00 85 C0 75 06 C7 07 01 00 00 00 5F 5E 83 C4 0C C3 90 A1 6C 67 4B 00 85 C0 74 14 8B 4C 24 0C 8B 54 24 08 51 8B 4C 24 08 52 51 FF D0 C2 0C 00 33 C0 C2 0C 00 90
   

复制代码

修改完了

其他2个窗口可以以子窗口形式载入了

算法其实做得很差
但是不管了

加个皮肤
完

moci

非常棒非常详细的一篇帖子，很赞
但建议下次这么长的帖子将源代码通过附件发送或分帖发

忘川

帖子非常的明确，希望作者能够继续努力的发布原创作品，陌辞论坛支持原创，陌辞有你更精彩。

水.

帖子非常的明确，希望作者能够继续努力的发布原创作品，陌辞论坛支持原创，陌辞有你更精彩。

无名氏人氏无人

不管你信不信，反正我是信了。

QQ3544223415

感谢楼主分享，学到了许多，我太爱你了，我们结婚吧

dghjgg

QQ3544223415 发表于 2022-1-27 17:18
感谢楼主分享，学到了许多，我太爱你了，我们结婚吧

liangci

啥也不说了，楼主就是给力！