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

bianyuan456 · 发表于 2025-4-1 16:04:48

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

神行 · 发表于 2025-4-1 15:29:38

本帖最后由神行于 2025-4-1 15:37 编辑

我给你提点建议吧
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)

.子程序