【蠢新学汇编】截取 子程序代码 字节集片段 终版

亿万

感谢分享

bianyuan456

感谢解答，原来是用来分析的。

神行

不好意思，之前提的意见，我没注意到你对汇编特别感兴趣。我对你的代码进行了改进。你看看如何。主要增加内存安全验证，优化搜索算法（函数头+函数尾双阶段搜索），添加安全计数（头100字节 尾500字节限制），多重失败检查点，无效长度处理，内存分配失败处理，减少不必要的内存访问，优化跳转逻辑，新增内存属性检查，安全长度限制4KB，独立内存分配复制，错误状态返回

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

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

变量名	类 型	静态	数组	备 注
机器码	字节集
长度	整数型

' 安全获取子程序机器码
机器码 ＝ 取函数机器码_增强版 (&子程序, 长度)
如果真 (取字节集长度 (机器码) ＝ 0)
信息框 ("获取机器码失败！", 0, "错误", )
调试输出 ("获取成功，长度：" ＋ 到文本 (长度), 机器码)

子程序名	返回值类型	公开	备 注
子程序	双精度小数型
参数名	类 型	参考	可空	数组	备 注
参数一	整数型
参数二	双精度小数型

返回 (参数一 ＋ 参数二)

子程序名	返回值类型	公开	备 注
取函数机器码_增强版	字节集
参数名	类 型	参考	可空	数组	备 注
函数指针	整数型				要获取机器码的函数地址
返回长度	整数型				返回获取的机器码长度

变量名	类 型	静态	数组	备 注
起始偏移	整数型
结束偏移	整数型
安全计数器	整数型
内存保护	整数型

' ================ 安全验证 ================
如果真 (函数指针 ＝ 0 或 是否可读内存 (函数指针, 1) ＝ 假)
返回 ({ })

' ================ 内存属性检查 ================
内存保护 ＝ 取内存保护属性 (函数指针)
如果真 (位与 (内存保护, #PAGE_EXECUTE_READ ) ＝ 0)
返回 ({ })

' ================ 汇编实现 ================
置入代码 ({ 139, 69, 8, 137, 69, 252, 51, 210, 137, 85, 248 })
' MOV EAX, [EBP+8]    ; 获取函数指针
' MOV [EBP-4], EAX    ; 起始偏移 = 函数地址
' XOR EDX, EDX        ; EDX = 0 (安全计数器)
' MOV [EBP-8], EDX    ; 结束偏移 = 0
' ================ 查找函数头 ================
置入代码 ({ 139, 77, 252, 138, 1, 60, 85, 117, 3, 235, 16, 144 })
' HEADER_SEARCH:
' MOV ECX, [EBP-4]    ; ECX = 当前地址
' MOV AL, [ECX]       ; 读取字节
' CMP AL, 0x55        ; 检查PUSH EBP
' JNE NOT_HEADER
' JMP HEADER_FOUND
' NOT_HEADER:
' NOP
置入代码 ({ 255, 69, 252, 255, 69, 244, 131, 125, 244, 100, 124, 229 })
' INC DWORD [EBP-4]   ; 地址+1
' INC DWORD [EBP-12]  ; 安全计数器+1
' CMP DWORD [EBP-12], 100 ; 最多检查100字节
' JL HEADER_SEARCH
置入代码 ({ 233, 88, 0, 0, 0 })
' JMP FAIL_EXIT       ; 未找到函数头
置入代码 ({ 131, 193, 1, 137, 77, 252 })
' HEADER_FOUND:
' ADD ECX, 1          ; 跳过函数头
' MOV [EBP-4], ECX    ; 更新起始地址
' ================ 查找函数尾 ================
置入代码 ({ 139, 85, 252, 137, 85, 248, 51, 210, 137, 85, 244 })
' MOV EDX, [EBP-4]    ; EDX = 起始地址
' MOV [EBP-8], EDX    ; 初始化结束地址
' XOR EDX, EDX        ; 清空EDX
' MOV [EBP-12], EDX   ; 重置安全计数器
置入代码 ({ 139, 117, 248, 138, 6, 60, 139, 117, 19 })
' TAIL_SEARCH:
' MOV ESI, [EBP-8]    ; ESI = 当前地址
' MOV AL, [ESI]       ; 读取字节
' CMP AL, 0x8B        ; 检查MOV EBP,ESP
' JNE NEXT_BYTE
置入代码 ({ 128, 126, 1, 229, 117, 12, 128, 126, 2, 93, 117, 8 })
' CMP BYTE [ESI+1], 0xE5 ; 检查完整指令
' JNE NEXT_BYTE
' CMP BYTE [ESI+2], 0x5D ; 检查POP EBP
' JNE NEXT_BYTE
置入代码 ({ 128, 126, 3, 194, 116, 8, 128, 126, 3, 195, 116, 4 })
' CMP BYTE [ESI+3], 0xC2 ; RETN xxxx
' JE TAIL_FOUND
' CMP BYTE [ESI+3], 0xC3 ; RETN
' JE TAIL_FOUND
置入代码 ({ 255, 69, 248, 255, 69, 244, 131, 125, 244, 500, 124, 204 })
' NEXT_BYTE:
' INC DWORD [EBP-8]   ; 地址+1
' INC DWORD [EBP-12]  ; 计数器+1
' CMP DWORD [EBP-12], 500 ; 最多检查500字节
' JL TAIL_SEARCH
置入代码 ({ 139, 77, 252, 43, 77, 248, 137, 77, 240 })
' TAIL_FOUND:
' MOV ECX, [EBP-8]    ; 结束地址
' SUB ECX, [EBP-4]    ; 计算长度
' MOV [EBP-16], ECX   ; 保存长度
' ================ 长度验证 ================
置入代码 ({ 131, 249, 0, 126, 29, 129, 249, 0, 16, 0, 0, 127, 22 })
' CMP ECX, 0          ; 检查长度有效性
' JLE INVALID_LEN
' CMP ECX, 4096       ; 最大4KB
' JG INVALID_LEN
置入代码 ({ 139, 85, 252, 139, 77, 248, 43, 202, 137, 77, 240, 233, 5, 0, 0, 0 })
' MOV EDX, [EBP-4]    ; 起始地址
' MOV ECX, [EBP-8]    ; 结束地址
' SUB ECX, EDX        ; 计算实际长度
' MOV [EBP-16], ECX   ; 保存长度
' JMP COPY_CODE
置入代码 ({ 51, 201, 137, 77, 240 })
' INVALID_LEN:
' XOR ECX, ECX        ; 长度置0
' MOV [EBP-16], ECX
' ================ 复制机器码 ================
置入代码 ({ 139, 117, 252, 139, 125, 240, 133, 255, 116, 19 })
' COPY_CODE:
' MOV ESI, [EBP-4]    ; 源地址
' MOV EDI, [EBP-16]   ; 长度
' TEST EDI, EDI       ; 检查长度
' JZ FAIL_EXIT
置入代码 ({ 106, 0, 255, 117, 240, 232, 40, 0, 0, 0, 137, 69, 232 })
' PUSH 0              ; 内存属性
' PUSH [EBP-16]       ; 长度
' CALL AllocMem       ; 调用内存分配
' MOV [EBP-24], EAX   ; 保存分配的内存地址
置入代码 ({ 139, 77, 240, 139, 117, 252, 139, 125, 232, 243, 164 })
' MOV ECX, [EBP-16]   ; 长度
' MOV ESI, [EBP-4]    ; 源地址
' MOV EDI, [EBP-24]   ; 目标地址
' REP MOVSB           ; 复制机器码
' ================ 返回结果 ================
置入代码 ({ 139, 69, 232, 233, 10, 0, 0, 0 })
' MOV EAX, [EBP-24]   ; 返回内存地址
' JMP SUCCESS_EXIT
置入代码 ({ 51, 192 })
' FAIL_EXIT:
' XOR EAX, EAX        ; 返回0表示失败
置入代码 ({ 139, 77, 240, 137, 77, 236 })
' SUCCESS_EXIT:
' MOV ECX, [EBP-16]   ; 获取长度
' MOV [EBP-20], ECX   ; 保存到局部变量
如果真 (是否为空 (返回长度) ＝ 假)
返回长度 ＝ 取变量数据地址_整数 (取变量地址 (起始偏移) － 取变量地址 (结束偏移))

返回 (指针到字节集 (取变量数据地址_整数 (起始偏移), 取变量数据地址_整数 (结束偏移 － 起始偏移)))

.版本 2<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 机器码, 字节集<br /> .局部变量 长度, 整数型<br /> <br /> ' 安全获取子程序机器码<br /> 机器码 ＝ 取函数机器码_增强版 (&子程序, 长度)<br /> .如果真 (取字节集长度 (机器码) ＝ 0)<br />     信息框 ("获取机器码失败！", 0, "错误", )<br />     调试输出 ("获取成功，长度：" ＋ 到文本 (长度), 机器码)<br /> .如果真结束<br /> <br /> <br /> .子程序 子程序, 双精度小数型<br /> .参数 参数一, 整数型<br /> .参数 参数二, 双精度小数型<br /> <br /> 返回 (参数一 ＋ 参数二)<br /> <br /> .子程序 取函数机器码_增强版, 字节集<br /> .参数 函数指针, 整数型, , 要获取机器码的函数地址<br /> .参数 返回长度, 整数型, 参考 可空, 返回获取的机器码长度<br /> .局部变量 起始偏移, 整数型<br /> .局部变量 结束偏移, 整数型<br /> .局部变量 安全计数器, 整数型<br /> .局部变量 内存保护, 整数型<br /> <br /> ' ================ 安全验证 ================<br /> .如果真 (函数指针 ＝ 0 或 是否可读内存 (函数指针, 1) ＝ 假)<br />     返回 ({ })<br /> .如果真结束<br /> <br /> ' ================ 内存属性检查 ================<br /> 内存保护 ＝ 取内存保护属性 (函数指针)<br /> .如果真 (位与 (内存保护, #PAGE_EXECUTE_READ) ＝ 0)<br />     返回 ({ })<br /> .如果真结束<br /> <br /> ' ================ 汇编实现 ================<br /> 置入代码 ({ 139, 69, 8, 137, 69, 252, 51, 210, 137, 85, 248 })<br /> ' MOV EAX, [EBP+8]    ; 获取函数指针<br /> ' MOV [EBP-4], EAX    ; 起始偏移 = 函数地址<br /> ' XOR EDX, EDX        ; EDX = 0 (安全计数器)<br /> ' MOV [EBP-8], EDX    ; 结束偏移 = 0<br /> <br /> ' ================ 查找函数头 ================<br /> 置入代码 ({ 139, 77, 252, 138, 1, 60, 85, 117, 3, 235, 16, 144 })<br /> ' HEADER_SEARCH:<br /> ' MOV ECX, [EBP-4]    ; ECX = 当前地址<br /> ' MOV AL, [ECX]       ; 读取字节<br /> ' CMP AL, 0x55        ; 检查PUSH EBP<br /> ' JNE NOT_HEADER<br /> ' JMP HEADER_FOUND<br /> ' NOT_HEADER:<br /> ' NOP<br /> <br /> 置入代码 ({ 255, 69, 252, 255, 69, 244, 131, 125, 244, 100, 124, 229 })<br /> ' INC DWORD [EBP-4]   ; 地址+1<br /> ' INC DWORD [EBP-12]  ; 安全计数器+1<br /> ' CMP DWORD [EBP-12], 100 ; 最多检查100字节<br /> ' JL HEADER_SEARCH<br /> <br /> 置入代码 ({ 233, 88, 0, 0, 0 })<br /> ' JMP FAIL_EXIT       ; 未找到函数头<br /> <br /> 置入代码 ({ 131, 193, 1, 137, 77, 252 })<br /> ' HEADER_FOUND:<br /> ' ADD ECX, 1          ; 跳过函数头<br /> ' MOV [EBP-4], ECX    ; 更新起始地址<br /> <br /> ' ================ 查找函数尾 ================<br /> 置入代码 ({ 139, 85, 252, 137, 85, 248, 51, 210, 137, 85, 244 })<br /> ' MOV EDX, [EBP-4]    ; EDX = 起始地址<br /> ' MOV [EBP-8], EDX    ; 初始化结束地址<br /> ' XOR EDX, EDX        ; 清空EDX<br /> ' MOV [EBP-12], EDX   ; 重置安全计数器<br /> <br /> 置入代码 ({ 139, 117, 248, 138, 6, 60, 139, 117, 19 })<br /> ' TAIL_SEARCH:<br /> ' MOV ESI, [EBP-8]    ; ESI = 当前地址<br /> ' MOV AL, [ESI]       ; 读取字节<br /> ' CMP AL, 0x8B        ; 检查MOV EBP,ESP<br /> ' JNE NEXT_BYTE<br /> <br /> 置入代码 ({ 128, 126, 1, 229, 117, 12, 128, 126, 2, 93, 117, 8 })<br /> ' CMP BYTE [ESI+1], 0xE5 ; 检查完整指令<br /> ' JNE NEXT_BYTE<br /> ' CMP BYTE [ESI+2], 0x5D ; 检查POP EBP<br /> ' JNE NEXT_BYTE<br /> <br /> 置入代码 ({ 128, 126, 3, 194, 116, 8, 128, 126, 3, 195, 116, 4 })<br /> ' CMP BYTE [ESI+3], 0xC2 ; RETN xxxx<br /> ' JE TAIL_FOUND<br /> ' CMP BYTE [ESI+3], 0xC3 ; RETN<br /> ' JE TAIL_FOUND<br /> <br /> 置入代码 ({ 255, 69, 248, 255, 69, 244, 131, 125, 244, 500, 124, 204 })<br /> ' NEXT_BYTE:<br /> ' INC DWORD [EBP-8]   ; 地址+1<br /> ' INC DWORD [EBP-12]  ; 计数器+1<br /> ' CMP DWORD [EBP-12], 500 ; 最多检查500字节<br /> ' JL TAIL_SEARCH<br /> <br /> 置入代码 ({ 139, 77, 252, 43, 77, 248, 137, 77, 240 })<br /> ' TAIL_FOUND:<br /> ' MOV ECX, [EBP-8]    ; 结束地址<br /> ' SUB ECX, [EBP-4]    ; 计算长度<br /> ' MOV [EBP-16], ECX   ; 保存长度<br /> <br /> ' ================ 长度验证 ================<br /> 置入代码 ({ 131, 249, 0, 126, 29, 129, 249, 0, 16, 0, 0, 127, 22 })<br /> ' CMP ECX, 0          ; 检查长度有效性<br /> ' JLE INVALID_LEN<br /> ' CMP ECX, 4096       ; 最大4KB<br /> ' JG INVALID_LEN<br /> <br /> 置入代码 ({ 139, 85, 252, 139, 77, 248, 43, 202, 137, 77, 240, 233, 5, 0, 0, 0 })<br /> ' MOV EDX, [EBP-4]    ; 起始地址<br /> ' MOV ECX, [EBP-8]    ; 结束地址<br /> ' SUB ECX, EDX        ; 计算实际长度<br /> ' MOV [EBP-16], ECX   ; 保存长度<br /> ' JMP COPY_CODE<br /> <br /> 置入代码 ({ 51, 201, 137, 77, 240 })<br /> ' INVALID_LEN:<br /> ' XOR ECX, ECX        ; 长度置0<br /> ' MOV [EBP-16], ECX<br /> <br /> ' ================ 复制机器码 ================<br /> 置入代码 ({ 139, 117, 252, 139, 125, 240, 133, 255, 116, 19 })<br /> ' COPY_CODE:<br /> ' MOV ESI, [EBP-4]    ; 源地址<br /> ' MOV EDI, [EBP-16]   ; 长度<br /> ' TEST EDI, EDI       ; 检查长度<br /> ' JZ FAIL_EXIT<br /> <br /> 置入代码 ({ 106, 0, 255, 117, 240, 232, 40, 0, 0, 0, 137, 69, 232 })<br /> ' PUSH 0              ; 内存属性<br /> ' PUSH [EBP-16]       ; 长度<br /> ' CALL AllocMem       ; 调用内存分配<br /> ' MOV [EBP-24], EAX   ; 保存分配的内存地址<br /> <br /> 置入代码 ({ 139, 77, 240, 139, 117, 252, 139, 125, 232, 243, 164 })<br /> ' MOV ECX, [EBP-16]   ; 长度<br /> ' MOV ESI, [EBP-4]    ; 源地址<br /> ' MOV EDI, [EBP-24]   ; 目标地址<br /> ' REP MOVSB           ; 复制机器码<br /> <br /> ' ================ 返回结果 ================<br /> 置入代码 ({ 139, 69, 232, 233, 10, 0, 0, 0 })<br /> ' MOV EAX, [EBP-24]   ; 返回内存地址<br /> ' JMP SUCCESS_EXIT<br /> <br /> 置入代码 ({ 51, 192 })<br /> ' FAIL_EXIT:<br /> ' XOR EAX, EAX        ; 返回0表示失败<br /> <br /> 置入代码 ({ 139, 77, 240, 137, 77, 236 })<br /> ' SUCCESS_EXIT:<br /> ' MOV ECX, [EBP-16]   ; 获取长度<br /> ' MOV [EBP-20], ECX   ; 保存到局部变量<br /> <br /> .如果真 (是否为空 (返回长度) ＝ 假)<br />     返回长度 ＝ 取变量数据地址_整数 (取变量地址 (起始偏移) － 取变量地址 (结束偏移))<br /> .如果真结束<br /> <br /> 返回 (指针到字节集 (取变量数据地址_整数 (起始偏移), 取变量数据地址_整数 (结束偏移 － 起始偏移)))

胖子葛格

请教大神：为什么使用置入代码命令运行 这个程序里“调试输出 (截取)” 获得的字节集，会没有反应？
（我把子程序的内容改为调试输出（“aaaaaaaaa”））
该怎样执行截取到的代码？

胖子葛格

感谢大神分享~！

bianyuan456

截取的字节集，再用置入代码 命令去调用么？
还是有别的用途？如果能在发一个怎么调用这个 截取字节集的方法就好了。。

神行

我给你提点建议吧
1.你使用了大量的硬编码汇编指令（置入代码），这些指令高度依赖x86架构和特定编译器生成的函数序言/结尾，而不同编译器或优化级别可能生成不同的函数开头/结尾模式
2.安全性问题：直接操作内存地址和机器码可能不安全，没有检查内存访问是否越界
3.变量使用问题：截取长度 变量在函数开始时声明，但实际值是在汇编代码中通过MOV DWORD [EBP-4],ECX设置的，这种隐式的变量赋值方式容易出错
4.第一段汇编代码在寻找函数入口点，跳过可能的跳转指令（0xE8）， 第二段汇编代码在查找函数结尾的典型模式（恢复栈帧和返回指令）， 第三段汇编代码处理无参数情况的返回指令（0xC3），这种技术通常用于低级编程或hook操作，但在实际使用环境中使用时需要非常非常谨慎。

这种技术通常用于低级编程或hook操作，但在生产环境中使用时需要非常谨慎
建议：添加错误检查机制，确保内存访问安全，考虑使用更可靠的方式确定函数边界，添加注释说明这种技术的限制和假设，如果可能，使用更高级的API来实现类似功能，检查子针到字节集函数是否能正确处理获取的长度

我基于你本来的逻辑，大致修改了一下，添加了一些必要的安全检查和错误处理，但是使用这种接近硬件或机器层面的代码编写手段在实际使用过程中依然存在很大风险，不建议实际中使用，特别是一些特别安全敏感的环境：

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

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

变量名	类 型	静态	数组	备 注
截取结果	字节集
安全标志	逻辑型

' 添加安全检查和错误处理
安全标志 ＝ 假
截取结果 ＝ 截取代码 (到整数 (&子程序), 安全标志)
如果真 (安全标志)
调试输出 ("安全截取成功", 取字节集长度 (截取结果), "字节")
.否则
信息框 ("函数截取失败，可能是不支持的函数格式或内存访问错误", 0, "错误", )
.如果真结束

子程序名	返回值类型	公开	备 注
子程序	双精度小数型
参数名	类 型	参考	可空	数组	备 注
参数一	整数型
参数二	双精度小数型

返回 (参数一 ＋ 参数二)

子程序名	返回值类型	公开	备 注
截取代码	字节集
参数名	类 型	参考	可空	数组	备 注
截取地址	整数型
是否安全	逻辑型

变量名	类 型	静态	数组	备 注
截取长度	整数型
最大长度	整数型
起始地址	整数型
结束地址	整数型

' 初始化安全标志
是否安全 ＝ 假

' 设置最大允许截取长度(4KB)
最大长度 ＝ 4096

' 验证地址是否有效
如果真 (截取地址 ≤ 0 或 截取地址 ≥ 2147483647)
返回 ({ })
.如果真结束

起始地址 ＝ 截取地址

' 查找函数入口点(更安全的方式)
置入代码 ({ 139, 69, 8, 128, 56, 85, 116, 19, 139, 77, 8, 65, 128, 57, 232, 117, 250, 139, 65, 1, 141, 92, 1, 5, 137, 93, 8 })
' MOV EAX,[EBP+8]   ; 获取截取地址
' CMP BYTE [EAX],85 ; 检查是否是push ebp(0x55)
' JE 跳过
' MOV ECX,[EBP+8]   ; 不是标准开头，查找call指令(0xE8)
' 入口循环:
' INC ECX
' CMP BYTE [ECX],232
' JNE 入口循环
' MOV EAX,[ECX+1]   ; 获取call目标偏移
' LEA EBX,[ECX+EAX+5] ; 计算实际地址
' MOV [EBP+8],EBX   ; 更新起始地址
' 跳过:

' 验证新地址是否有效
如果真 (起始地址 ≤ 0 或 起始地址 ≥ 2147483647)
返回 ({ })
.如果真结束

' 查找函数结束(添加边界检查)
置入代码 ({ 139, 77, 8, 137, 77, 252, 139, 85, 12, 138, 17, 65, 128, 250, 139, 117, 243, 128, 121, 255, 229, 117, 238, 128, 121, 254, 93, 117, 231, 128, 121, 253, 194, 117, 7, 131, 193, 3, 137, 77, 252, 235, 18 })
' MOV ECX,[EBP+8]   ; 起始地址
' MOV [EBP-4],ECX   ; 保存到截取长度(作为结束地址)
' MOV EDX,[EBP+12]  ; 最大长度
' 查找循环:
' MOV DL,[ECX]
' INC ECX
' CMP DL,139        ; 检查mov ebp,esp(0x8B)
' JNE 查找循环
' CMP BYTE [ECX-1],229 ; 0xE5
' JNE 查找循环
' CMP BYTE [ECX-2],93  ; 0x5D(pop ebp)
' JNE 查找循环
' CMP BYTE [ECX-3],194 ; 0xC2(retn)
' JNE 检查无参
' ADD ECX,3         ; 调整到retn之后
' MOV [EBP-4],ECX   ; 更新结束地址
' JMP 完成检查
' 检查无参:
置入代码 ({ 128, 121, 253, 195, 117, 213, 131, 193, 3, 137, 77, 252 })
' CMP BYTE [ECX-3],195 ; 0xC3(ret)
' JNE 查找循环
' ADD ECX,3         ; 调整到ret之后
' MOV [EBP-4],ECX   ; 更新结束地址
' 完成检查:

' 计算实际长度
截取长度 ＝ 结束地址 － 起始地址

' 验证长度是否合理
如果真 (截取长度 ≤ 0 或 截取长度 > 最大长度)
返回 ({ })
.如果真结束

' 设置安全标志
是否安全 ＝ 真

' 返回截取的代码
返回 (指针到字节集 (起始地址, 截取长度))

.版本 2<br /> <br /> .程序集 窗口程序集_启动窗口 <br /> <br /> .子程序 __启动窗口_创建完毕 <br /> .局部变量 截取结果, 字节集 <br /> .局部变量 安全标志, 逻辑型 <br /> <br /> ' 添加安全检查和错误处理 <br /> 安全标志 ＝ 假 <br /> 截取结果 ＝ 截取代码 (到整数 (&子程序), 安全标志)<br /> .如果真 (安全标志)<br />     调试输出 ("安全截取成功", 取字节集长度 (截取结果), "字节")<br /> .否则 <br />     信息框 ("函数截取失败，可能是不支持的函数格式或内存访问错误", 0, "错误", )<br /> .如果真结束 <br /> <br /> .子程序 子程序, 双精度小数型 <br /> .参数 参数一, 整数型 <br /> .参数 参数二, 双精度小数型 <br /> <br /> 返回 (参数一 ＋ 参数二)<br /> <br /> .子程序 截取代码, 字节集 <br /> .参数 截取地址, 整数型 <br /> .参数 是否安全, 逻辑型, 参考 可空 <br /> .局部变量 截取长度, 整数型 <br /> .局部变量 最大长度, 整数型 <br /> .局部变量 起始地址, 整数型 <br /> .局部变量 结束地址, 整数型 <br /> <br /> ' 初始化安全标志 <br /> 是否安全 ＝ 假 <br /> <br /> ' 设置最大允许截取长度(4KB)<br /> 最大长度 ＝ 4096 <br /> <br /> ' 验证地址是否有效 <br /> .如果真 (截取地址 ≤ 0 或 截取地址 ≥ 2147483647)<br />     返回 ({ })<br /> .如果真结束 <br /> <br /> 起始地址 ＝ 截取地址 <br /> <br /> ' 查找函数入口点(更安全的方式)<br /> 置入代码 ({ 139, 69, 8, 128, 56, 85, 116, 19, 139, 77, 8, 65, 128, 57, 232, 117, 250, 139, 65, 1, 141, 92, 1, 5, 137, 93, 8 })<br /> ' MOV EAX,[EBP+8]   ; 获取截取地址 <br /> ' CMP BYTE [EAX],85 ; 检查是否是push ebp(0x55)<br /> ' JE 跳过 <br /> ' MOV ECX,[EBP+8]   ; 不是标准开头，查找call指令(0xE8)<br /> ' 入口循环:<br /> ' INC ECX <br /> ' CMP BYTE [ECX],232 <br /> ' JNE 入口循环 <br /> ' MOV EAX,[ECX+1]   ; 获取call目标偏移 <br /> ' LEA EBX,[ECX+EAX+5] ; 计算实际地址 <br /> ' MOV [EBP+8],EBX   ; 更新起始地址 <br /> ' 跳过:<br /> <br /> ' 验证新地址是否有效 <br /> .如果真 (起始地址 ≤ 0 或 起始地址 ≥ 2147483647)<br />     返回 ({ })<br /> .如果真结束 <br /> <br /> ' 查找函数结束(添加边界检查)<br /> 置入代码 ({ 139, 77, 8, 137, 77, 252, 139, 85, 12, 138, 17, 65, 128, 250, 139, 117, 243, 128, 121, 255, 229, 117, 238, 128, 121, 254, 93, 117, 231, 128, 121, 253, 194, 117, 7, 131, 193, 3, 137, 77, 252, 235, 18 })<br /> ' MOV ECX,[EBP+8]   ; 起始地址 <br /> ' MOV [EBP-4],ECX   ; 保存到截取长度(作为结束地址)<br /> ' MOV EDX,[EBP+12]  ; 最大长度 <br /> ' 查找循环:<br /> ' MOV DL,[ECX]<br /> ' INC ECX <br /> ' CMP DL,139        ; 检查mov ebp,esp(0x8B)<br /> ' JNE 查找循环 <br /> ' CMP BYTE [ECX-1],229 ; 0xE5 <br /> ' JNE 查找循环 <br /> ' CMP BYTE [ECX-2],93  ; 0x5D(pop ebp)<br /> ' JNE 查找循环 <br /> ' CMP BYTE [ECX-3],194 ; 0xC2(retn)<br /> ' JNE 检查无参 <br /> ' ADD ECX,3         ; 调整到retn之后 <br /> ' MOV [EBP-4],ECX   ; 更新结束地址 <br /> ' JMP 完成检查 <br /> ' 检查无参:<br /> 置入代码 ({ 128, 121, 253, 195, 117, 213, 131, 193, 3, 137, 77, 252 })<br /> ' CMP BYTE [ECX-3],195 ; 0xC3(ret)<br /> ' JNE 查找循环 <br /> ' ADD ECX,3         ; 调整到ret之后 <br /> ' MOV [EBP-4],ECX   ; 更新结束地址 <br /> ' 完成检查:<br /> <br /> ' 计算实际长度 <br /> 截取长度 ＝ 结束地址 － 起始地址 <br /> <br /> ' 验证长度是否合理 <br /> .如果真 (截取长度 ≤ 0 或 截取长度 > 最大长度)<br />     返回 ({ })<br /> .如果真结束 <br /> <br /> ' 设置安全标志 <br /> 是否安全 ＝ 真 <br /> <br /> ' 返回截取的代码 <br /> 返回 (指针到字节集 (起始地址, 截取长度))

所以，为了你的CPU硬件安全，我对这个代码又进行了一次改进。这次不使用可以直接操作CPU指令的这些低级代码，大致思路，没有经过测试。

  

窗口程序集名	保 留	保 留	备 注
高级函数分析器
变量名	类 型	数组	备 注
内存保护属性	整数型
最大扫描长度	整数型		4096
最小函数长度	整数型		16

子程序名	返回值类型	公开	备 注
初始化分析器	逻辑型

内存保护属性 ＝ 取内存保护属性 (GetCurrentProcess ())
最大扫描长度 ＝ 4096
最小函数长度 ＝ 16
返回 真

子程序名	返回值类型	公开	备 注
安全截取函数代码	字节集
参数名	类 型	参考	可空	数组	备 注
函数指针	整数型
结果状态	整数型				0=成功 1=无效指针 2=内存不可读 3=超出范围 4=模式不匹配

变量名	类 型	静态	数组	备 注
函数长度	整数型
内存信息	内存基本信息
安全缓冲区	字节集

' 1. 参数验证
如果真 (函数指针 ≤ 0)
结果状态 ＝ 1
返回 ({ })

' 2. 检查内存可读性
内存信息 ＝ 取内存信息 (函数指针)
如果真 (位与 (内存信息.保护, 内存保护属性.PAGE_READABLE) ＝ 0)
结果状态 ＝ 2
返回 ({ })

' 3. 智能分析函数边界
函数长度 ＝ 智能分析函数长度 (函数指针)
如果真 (函数长度 ＜ 最小函数长度 或 函数长度 ＞ 最大扫描长度)
结果状态 ＝ 3
返回 ({ })

' 4. 安全复制函数代码
安全缓冲区 ＝ 取空白字节集 (函数长度)
复制内存 (取变量数据地址 (安全缓冲区), 函数指针, 函数长度)
' 5. 验证复制内容
如果真 (校验字节集 (安全缓冲区) ＝ 假)
结果状态 ＝ 4
返回 ({ })

结果状态 ＝ 0
返回 安全缓冲区

子程序名	返回值类型	公开	备 注
智能分析函数长度	整数型
参数名	类 型	参考	可空	数组	备 注
起始地址	整数型

变量名	类 型	静态	数组	备 注
当前地址	整数型
扫描计数器	整数型
指令分析器	整数型

当前地址 ＝ 起始地址
指令分析器 ＝ 创建指令分析器 ()
' 使用启发式规则分析函数边界
判断循环首 (当前地址 － 起始地址 ＜ 最大扫描长度)
扫描计数器 ＝ 扫描计数器 ＋ 1
' 使用指令分析器判断是否到达函数结尾
如果 (分析指令 (指令分析器, 当前地址) ＝ "RET")
如果 (验证函数结尾 (当前地址))
跳出循环 ()


' 检查常见函数序言
如果真 (扫描计数器 ＝ 1 且 分析指令 (指令分析器, 当前地址) ≠ "PUSH EBP")
当前地址 ＝ 查找真实入口 (当前地址)

当前地址 ＝ 当前地址 ＋ 取指令长度 (指令分析器)
释放指令分析器 (指令分析器)
' 确保长度有效
如果 (当前地址 － 起始地址 ≥ 最小函数长度 且 当前地址 － 起始地址 ≤ 最大扫描长度)
返回 (当前地址 － 起始地址)
返回 (0)

' 验证标准的函数结尾序列
返回 (取字节集长度 (指针到字节集 (地址, 4)) ＝ 4 且
指针到字节集 (地址, 4) ＝ { 139, 229, 93, 195 }) ' MOV ESP,EBP; POP EBP; RET

子程序名	返回值类型	公开	备 注
验证函数结尾	逻辑型
参数名	类 型	参考	可空	数组	备 注
地址	整数型

子程序名	返回值类型	公开	备 注
查找真实入口	整数型
参数名	类 型	参考	可空	数组	备 注
疑似地址	整数型

变量名	类 型	静态	数组	备 注
当前地址	整数型

' 处理编译器优化情况下的函数入口
当前地址 ＝ 疑似地址
判断循环首 (当前地址 － 疑似地址 ＜ 32) ' 在32字节范围内查找
如果 (指针到字节集 (当前地址, 2) ＝ { 85, 139 }) ' PUSH EBP; MOV EBP,ESP
返回 (当前地址)
当前地址 ＝ 当前地址 ＋ 1

判断循环尾
返回 (疑似地址) ' 找不到则返回原地址

子程序名	返回值类型	公开	备 注
校验字节集	逻辑型
参数名	类 型	参考	可空	数组	备 注
代码块	字节集

变量名	类 型	静态	数组	备 注
校验和	整数型
i	整数型

' 验证代码块有效性
计次循环首 (取字节集长度 (代码块), i)
校验和 ＝ 位异或 (校验和, 取字节集数据 (代码块, i, #字节型 ))
计次循环尾
' 简单校验和验证
返回 (校验和 ≠ 0)

.版本 2<br /> <br /> .程序集 高级函数分析器<br /> .程序集变量 内存保护属性, 整数型<br /> .程序集变量 最大扫描长度, 整数型, , , 4096<br /> .程序集变量 最小函数长度, 整数型, , , 16<br /> <br /> .子程序 初始化分析器, 逻辑型<br /> <br /> 内存保护属性 ＝ 取内存保护属性 (GetCurrentProcess())<br /> 最大扫描长度 ＝ 4096<br /> 最小函数长度 ＝ 16<br /> 返回 真<br /> <br /> .子程序 安全截取函数代码, 字节集, 公开<br /> .参数 函数指针, 整数型<br /> .参数 结果状态, 整数型, 参考 可空, 0=成功 1=无效指针 2=内存不可读 3=超出范围 4=模式不匹配<br /> .局部变量 函数长度, 整数型<br /> .局部变量 内存信息, 内存基本信息<br /> .局部变量 安全缓冲区, 字节集<br /> <br /> ' 1. 参数验证<br /> .如果真 (函数指针 ≤ 0)<br />     结果状态 ＝ 1<br />     返回 ({ })<br /> .如果真结束<br /> <br /> ' 2. 检查内存可读性<br /> 内存信息 ＝ 取内存信息 (函数指针)<br /> .如果真 (位与 (内存信息.保护, 内存保护属性.PAGE_READABLE) ＝ 0)<br />     结果状态 ＝ 2<br />     返回 ({ })<br /> .如果真结束<br /> <br /> ' 3. 智能分析函数边界<br /> 函数长度 ＝ 智能分析函数长度 (函数指针)<br /> .如果真 (函数长度 ＜ 最小函数长度 或 函数长度 ＞ 最大扫描长度)<br />     结果状态 ＝ 3<br />     返回 ({ })<br /> .如果真结束<br /> <br /> ' 4. 安全复制函数代码<br /> 安全缓冲区 ＝ 取空白字节集 (函数长度)<br /> 复制内存 (取变量数据地址 (安全缓冲区), 函数指针, 函数长度)<br /> <br /> ' 5. 验证复制内容<br /> .如果真 (校验字节集 (安全缓冲区) ＝ 假)<br />     结果状态 ＝ 4<br />     返回 ({ })<br /> .如果真结束<br /> <br /> 结果状态 ＝ 0<br /> 返回 安全缓冲区<br /> <br /> .子程序 智能分析函数长度, 整数型<br /> .参数 起始地址, 整数型<br /> .局部变量 当前地址, 整数型<br /> .局部变量 扫描计数器, 整数型<br /> .局部变量 指令分析器, 整数型<br /> <br /> 当前地址 ＝ 起始地址<br /> 指令分析器 ＝ 创建指令分析器 ()<br /> <br /> ' 使用启发式规则分析函数边界<br /> 判断循环首 (当前地址 － 起始地址 ＜ 最大扫描长度)<br /> 扫描计数器 ＝ 扫描计数器 ＋ 1<br /> <br /> ' 使用指令分析器判断是否到达函数结尾<br /> 如果 (分析指令 (指令分析器, 当前地址) ＝ "RET")<br /> .如果 (验证函数结尾 (当前地址))<br />     跳出循环 ()<br /> .否则<br /> <br /> .如果结束<br /> ' 检查常见函数序言<br /> .如果真 (扫描计数器 ＝ 1 且 分析指令 (指令分析器, 当前地址) ≠ "PUSH EBP")<br />     当前地址 ＝ 查找真实入口 (当前地址)<br /> .如果真结束<br /> <br /> 当前地址 ＝ 当前地址 ＋ 取指令长度 (指令分析器)<br /> <br /> 释放指令分析器 (指令分析器)<br /> <br /> ' 确保长度有效<br /> .如果 (当前地址 － 起始地址 ≥ 最小函数长度 且 当前地址 － 起始地址 ≤ 最大扫描长度)<br />     返回 (当前地址 － 起始地址)<br /> .否则<br />     返回 (0)<br /> .如果结束<br /> <br /> ' 验证标准的函数结尾序列<br /> 返回 (取字节集长度 (指针到字节集 (地址, 4)) ＝ 4 且<br /> 指针到字节集 (地址, 4) ＝ { 139, 229, 93, 195 }) ' MOV ESP,EBP; POP EBP; RET<br /> <br /> .子程序 验证函数结尾, 逻辑型<br /> .参数 地址, 整数型<br /> <br /> <br /> <br /> .子程序 查找真实入口, 整数型<br /> .参数 疑似地址, 整数型<br /> .局部变量 当前地址, 整数型<br /> <br /> ' 处理编译器优化情况下的函数入口<br /> <br /> 当前地址 ＝ 疑似地址<br /> .判断循环首 (当前地址 － 疑似地址 ＜ 32) ' 在32字节范围内查找<br />     .如果 (指针到字节集 (当前地址, 2) ＝ { 85, 139 }) ' PUSH EBP; MOV EBP,ESP<br />         返回 (当前地址)<br />     .否则<br />         当前地址 ＝ 当前地址 ＋ 1<br />     .如果结束<br /> <br /> .判断循环尾<br /> <br /> 返回 (疑似地址) ' 找不到则返回原地址<br /> <br /> .子程序 校验字节集, 逻辑型<br /> .参数 代码块, 字节集<br /> .局部变量 校验和, 整数型<br /> .局部变量 i, 整数型<br /> <br /> ' 验证代码块有效性<br /> <br /> .计次循环首 (取字节集长度 (代码块), i)<br />     校验和 ＝ 位异或 (校验和, 取字节集数据 (代码块, i, #字节型))<br /> .计次循环尾<br /> <br /> ' 简单校验和验证<br /> 返回 (校验和 ≠ 0)

.子程序

  

.版本 2

沐白

支持开源~！感谢分享

gaoqing

谢谢分享

轻描淡写zzz

感谢分享，