有没大佬过来帮忙看看这个64位搜索特征码的汇编怎么改

zhengzhikai

这个代码搜索地址到7FFFFFFF都没错,

.子程序 搜索代码
.参数 特征码, 字节集
.参数 模糊码, 字节集
.参数 起始地址, 整数型
.参数 区段大小, 整数型
.参数 数据缓冲区, 字节集
.参数 结果数组, 整数型, 参考 数组
.局部变量 搜寻个数, 整数型
.局部变量 局部_模糊码, 整数型
.局部变量 局部_数据缓冲区, 整数型

搜寻个数 ＝ 0
局部_模糊码 ＝ 0
局部_数据缓冲区 ＝ 0
置入代码 ({ 83, 86, 87, 139, 117, 24, 139, 54, 131, 198, 8, 137, 117, 244, 199, 69, 252, 0, 0, 0, 0, 139, 117, 8, 139, 54, 131, 198, 4, 235, 66, 51, 219, 139, 69, 12, 139, 0, 131, 192, 8, 137, 69, 248, 139, 254, 131, 199, 4, 235, 35, 139, 69, 252, 3, 195, 139, 85, 244, 51, 201, 138, 4, 16, 51, 210, 138, 23, 139, 77, 248, 51, 194, 51, 210, 138, 17, 33, 208, 117, 9, 67, 255, 69, 248, 71, 59, 30, 124, 217, 59, 30, 125, 13, 255, 69, 252, 139, 69, 20, 43, 6, 59, 69, 252, 125, 180, 139, 85, 20, 43, 22, 59, 85, 252, 124, 30, 139, 69, 252, 139, 93, 16, 1, 93, 252, 3, 6, 1, 69, 16, 1, 69, 244, 41, 69, 20, 232, 14, 0, 0, 0, 233, 123, 255, 255, 255, 95, 94, 91, 139, 229, 93, 194, 16, 0 })
加入成员 (结果数组, 搜寻个数)
置入代码 ({ 195 })
返回 ()
这个代码搜索地址到7FFFFFFF都没错,

接下来代码根据网上找的,数量找没错,但是地址会出错,有大佬帮忙看下怎么改吗

.版本 2

.子程序 搜索代码2
.参数 特征码, 字节集, , [ebp+8]
.参数 模糊码, 字节集, , [ebp+C]
.参数 初始值, 整数型, , [ebp+10] 这里填0
.参数 数据大小, 整数型, , [ebp+14]
.参数 数据缓冲区, 字节集, , [ebp+18]
.参数 起始地址, 长整数型
.参数 结果数组, 长整数型, 参考 数组
.局部变量 搜寻位置, 整数型, , , [ebp-4]
.局部变量 局部_模糊码, 整数型, , , [ebp-8]
.局部变量 局部_数据缓冲区, 整数型, , , [ebp-C]

搜寻位置 ＝ 0
局部_模糊码 ＝ 0
局部_数据缓冲区 ＝ 0
置入代码 ({ 83, 86, 87, 139, 117, 24, 139, 54, 131, 198, 8, 137, 117, 244, 199, 69, 252, 0, 0, 0, 0, 139, 117, 8, 139, 54, 131, 198, 4, 235, 66, 51, 219, 139, 69, 12, 139, 0, 131, 192, 8, 137, 69, 248, 139, 254, 131, 199, 4, 235, 35, 139, 69, 252, 3, 195, 139, 85, 244, 51, 201, 138, 4, 16, 51, 210, 138, 23, 139, 77, 248, 51, 194, 51, 210, 138, 17, 33, 208, 117, 9, 67, 255, 69, 248, 71, 59, 30, 124, 217, 59, 30, 125, 13, 255, 69, 252, 139, 69, 20, 43, 6, 59, 69, 252, 125, 180, 139, 85, 20, 43, 22, 59, 85, 252, 124, 30, 139, 69, 252, 139, 93, 16, 1, 93, 252, 3, 6, 1, 69, 16, 1, 69, 244, 41, 69, 20, 232, 14, 0, 0, 0, 233, 123, 255, 255, 255, 95, 94, 91, 139, 229, 93, 194, 32, 0 })
起始地址 ＝ 起始地址 ＋ 搜寻位置
加入成员 (结果数组, 起始地址)
置入代码 ({ 195 })
返回 ()

zhengzhikai

上面第一段搜索到7FFFFFFF都不会出错,接下来就会出错,下面那段搜索数量没错,但是地址出错,有大佬出手帮我改下吗

你是猪饿

楼主搞定了吗

zhengzhikai

你是猪饿 发表于 2019-10-20 23:37
楼主搞定了吗

没有!!!我拷贝了个代码搜索出来的数量正确,但是地址错误

zhengzhikai

[Asm] 纯文本查看 复制代码

.版本 2
.支持库 spec

.子程序 搜索怪物血量64位长整数, 文本型
.局部变量 n, 整数型
.局部变量 a, 整数型
.局部变量 结果, 长整数型
.局部变量 o, 长整数型
.局部变量 结果数组, 长整数型, , "0"
.局部变量 i, 整数型
.局部变量 JCID_j, 整数型

调试输出 (进制_十六到十 (“10000000”), 进制_十六到十 (“8f000000”))

结果 ＝ 特征码模糊搜索长整数 (jcid, “1111111FFFFFF”, 结果数组, 十六到十 (“7f000000”), 进制_十六到十 (“9f000000”))


.如果真 (结果 ＞ 0)
    JCID_j ＝ OpenProcess (#PROCESS_ALL_ACCESS, 假, jcid)
    _启动窗口.标题 ＝ 到文本 (取数组成员数 (结果数组))
    .计次循环首 (取数组成员数 (结果数组), i)
        ' 调试输出 (i, 结果数组 [i] ＋ 8, 进制_十到十六 (结果数组 [i] ＋ 8), 读内存整数型_64 (JCID_j, 结果数组 [i] ＋ 8))

        .如果真 (读内存整数型_64 (JCID_j, 结果数组 [i] ＋ 8) ＞ 1000)

            调试输出 (i, 结果数组 [i] ＋ 8, 十到十六 (结果数组 [i] ＋ 8), 读内存整数型_64 (JCID_j, 结果数组 [i] ＋ 8))

            写内存整数型_64 (JCID_j, 到数值 (结果数组 [i] ＋ 8), 1)

        .如果真结束


    .计次循环尾 ()
    CloseHandle (JCID_j)

    o ＝ 结果数组 [1]
    返回 (十到十六 (o))
.如果真结束
返回 (“-1”)
[mw_shl_code=asm,true].版本 2
.支持库 spec

.子程序 特征码模糊搜索长整数, 整数型, , 搜索规则与OD相同,返回搜寻的地址数目.如有BUG可以反馈至fjqisba
.参数 PID, 整数型, , 进程ID,-1代表自身
.参数 特征码, 文本型, , 十六进制文本，如“68 00 00 00 40 ?? ?? ?? ?? ?? ?? ?? ?? 50 E8”
.参数 结果数组, 长整数型, 参考 数组, 存放结果
.参数 搜寻起始地址, 长整数型, 可空, 默认为"00401000"
.参数 搜寻结束地址, 长整数型, 可空, 如果为空,则只搜索搜寻起始地址所在的内存段
.局部变量 备份_特征码, 文本型, , , 为了传递进来的参数不发生改变
.局部变量 局部_特征码, 字节集
.局部变量 hProcess, 整数型
.局部变量 内存信息, MEMORY_BASIC_INFORMATION64
.局部变量 区段大小, 长整数型
.局部变量 数据缓冲区, 字节集
.局部变量 读取结果, 逻辑型
.局部变量 校验大小, 长整数型
.局部变量 模糊码, 字节集

清除数组 (结果数组)

备份_特征码 ＝ 特征码

.如果真 (是否为空 (搜寻起始地址))
    搜寻起始地址 ＝ 十六到十 (“00401000”)
.如果真结束

备份_特征码 ＝ 子文本替换 (备份_特征码, “ ”, “”, , , 真)  ' 去除空格

.如果真 (位与 (取文本长度 (备份_特征码), 1) ≠ 0)  ' 补全为偶数个数
    备份_特征码 ＝ 备份_特征码 ＋ “?”
.如果真结束

模糊码 ＝ 取模糊码 (备份_特征码)

备份_特征码 ＝ 子文本替换 (备份_特征码, “?”, “0”, , , 真)  ' 修改问号
局部_特征码 ＝ 十六进制到字节集 (备份_特征码)

.如果 (PID ＝ -1)
    hProcess ＝ GetCurrentProcess ()
.否则
    hProcess ＝ OpenProcess (#PROCESS_ALL_ACCESS, 假, PID)

.如果结束
' 调试输出 (VirtualQueryEx64 (hProcess, 搜寻起始地址, 指针到整数 (取变量数据地址 (内存信息)), 48))

.判断循环首 (VirtualQueryEx64 (hProcess, 搜寻起始地址, 指针到整数 (取变量数据地址 (内存信息)), 48) ≠ 0)

    .如果真 (内存信息.Protect ≠ 16 且 内存信息.Protect ≠ 1 且 内存信息.Protect ≠ 512)
        区段大小 ＝ 内存信息.BaseAddress ＋ 内存信息.RegionSize － 搜寻起始地址
        数据缓冲区 ＝ 取空白字节集 (区段大小 ＋ 1)

        读取结果 ＝ ReadProcessMemory64 (hProcess, 搜寻起始地址, 取变量数据地址 (数据缓冲区), 区段大小, 校验大小)

        .如果真 (读取结果 ≠ 假 且 校验大小 ＝ 区段大小)
            搜索代码2 (局部_特征码, 模糊码, 0, 区段大小, 数据缓冲区, 搜寻起始地址, 结果数组)

        .如果真结束

    .如果真结束

    .如果真 (是否为空 (搜寻结束地址))  ' 只搜索第一个区段
        跳出循环 ()
    .如果真结束

    搜寻起始地址 ＝ 搜寻起始地址 ＋ 内存信息.RegionSize
    .如果真 (搜寻起始地址 ＞ 搜寻结束地址)

        跳出循环 ()
    .如果真结束

.判断循环尾 ()
CloseHandle (hProcess)
调试输出 (取数组成员数 (结果数组))

返回 (取数组成员数 (结果数组))
[mw_shl_code=asm,true].版本 2

.子程序 搜索代码2
.参数 特征码, 字节集, , [ebp+8]
.参数 模糊码, 字节集, , [ebp+C]
.参数 初始值, 整数型, , [ebp+10] 这里填0
.参数 数据大小, 整数型, , [ebp+14]
.参数 数据缓冲区, 字节集, , [ebp+18]
.参数 起始地址, 长整数型
.参数 结果数组, 长整数型, 参考 数组
.局部变量 搜寻位置, 整数型, , , [ebp-4]
.局部变量 局部_模糊码, 整数型, , , [ebp-8]
.局部变量 局部_数据缓冲区, 整数型, , , [ebp-C]

搜寻位置 ＝ 0
局部_模糊码 ＝ 0
局部_数据缓冲区 ＝ 0
置入代码 ({ 83, 86, 87, 139, 117, 24, 139, 54, 131, 198, 8, 137, 117, 244, 199, 69, 252, 0, 0, 0, 0, 139, 117, 8, 139, 54, 131, 198, 4, 235, 66, 51, 219, 139, 69, 12, 139, 0, 131, 192, 8, 137, 69, 248, 139, 254, 131, 199, 4, 235, 35, 139, 69, 252, 3, 195, 139, 85, 244, 51, 201, 138, 4, 16, 51, 210, 138, 23, 139, 77, 248, 51, 194, 51, 210, 138, 17, 33, 208, 117, 9, 67, 255, 69, 248, 71, 59, 30, 124, 217, 59, 30, 125, 13, 255, 69, 252, 139, 69, 20, 43, 6, 59, 69, 252, 125, 180, 139, 85, 20, 43, 22, 59, 85, 252, 124, 30, 139, 69, 252, 139, 93, 16, 1, 93, 252, 3, 6, 1, 69, 16, 1, 69, 244, 41, 69, 20, 232, 14, 0, 0, 0, 233, 123, 255, 255, 255, 95, 94, 91, 139, 229, 93, 194, 32, 0 })
起始地址 ＝ 起始地址 ＋ 搜寻位置
加入成员 (结果数组, 起始地址)
置入代码 ({ 195 })
返回 ()

[/mw_shl_code][/mw_shl_code]