-
-
[原创]网易某某老鼠逆向记录 —— 补环境调试与动调调试
-
发表于: 4天前 726
-
本文是对一次客户端格式分析与运行时观测工作的技术记录,按调试方法分两部:第一部「补环境调试」=不挂目标进程,在宿主侧把素材、格式、符号、依赖补齐后离线复算;第二部「动调调试」=挂目标进程实时观测,取运行时才存在的东西。
已对目标名称、包名、域名、路径、密钥、接口与业务标识做脱敏;文中地址、字节、数量均照原始笔记转述。
整理日期 2026-11-14。
范围与合规说明
- 本文只讨论文件格式解析、ELF 结构、指令集还原、静态分析方法和运行时观测方法论。
- 不包含漏洞内容、接口清单、请求参数、POC、定级结论与修复建议;不包含针对在线游戏的规避、注入、修改、反作弊对抗或证书校验绕过的可复现流程;不提供可直接用于未授权测试的完整脚本。
- 不披露任何密钥、令牌、设备标识或业务密钥常量。涉及密钥的地方只写「存在一份默认 key 常量」这类结构性描述,值一律略去。
- 相关研究应在授权范围内进行。文中提及的商业客户端与第三方服务均作匿名化处理。
- 未做任何复现、验证、请求发送或哈希校验。原始报告自己标注的「静态完成、动态未验证」「动态复测待办」等口径,本文一律沿用。
- 材料范围:根目录的阶段笔记、若干脚本的开头片段、部分日志与产出样本。绝大多数脚本、原始二进制、内存镜像与完整反汇编只看了文件名或清单,未逐个打开,因此本文不是对该工程的完整综述。
- 补充材料:另参考同一工作的会话记录中与文件格式、离线加载、静态判定、观测方法有关的描述;其中的漏洞、密钥、业务端点、内存改写与对抗性内容一律不取用,也不在本文复述。
TOP0 阅读顺序与两部结构
0.1 结构树
网易某某老鼠逆向记录
│
├── TOP0 前置:结构 / 环境 / 范围
│
├── 第一部 补环境调试 ──────────────────────────────────────┐
│ │ 不挂进程,输入是文件,手段是宿主侧程序 │
│ │ 输出:格式定义、地址表、排除表、反汇编文本、静态改写 │
│ │ │
│ TOP1 素材准备与离线输入 │
│ TOP2 ELF 环境补齐 │
│ TOP3 符号表可信度判定 │
│ TOP4 文件格式层 │
│ TOP5 静态排除清单 │
│ TOP6 XXTEA 变体重构 │
│ TOP7 位级求解与 Z3 路线 │
│ TOP8 userext::Crypto 绑定链与命名反转 │
│ TOP9 魔改 Lua VM 指令格式 │
│ TOP10 反编译器与语义还原 │
│ TOP11 静态字节改写与可复核性 │
│ TOP12 补环境的边界与失效点 ┘
│
├── 第二部 动调调试 ────────────────────────────────────────┐
│ │ 输入是运行中的目标进程,手段是系统接口与运行时插桩 │
│ │ 输出:明文分片、段清单、IO 日志、运行时防护观察 │
│ │ │
│ TOP13 运行环境与 attach 前置 │
│ TOP14 零注入内存取证 │
│ TOP15 模块与段枚举 │
│ TOP16 落盘通道自检 │
│ TOP17 IO 链路观测 │
│ TOP18 数据面 hook:memcpy → malloc │
│ TOP19 明文落盘、回收与回灌 │
│ TOP20 失败案例与根因 │
│ TOP21 运行时防护观察与扫描纪律 │
│ TOP22 动态复测待办 ┘
│
└── 收尾
TOP23 未解决清单与方法
TOP24 函数与地址速查
TOP25 基础知识可补
两部不是先后顺序,是并列的两套方法。补环境负责把静态面榨干,动调负责拿运行时才有的东西,两边通过同一批二进制产物(字节码、密文块、段镜像)互相验证。
0.2 环境参数(泛化)
宿主 Windows / Python 3 / IDA / capstone / readelf / z3
设备 Android 模拟器(ADB 连接,root shell 可用)
注:目标库为 ARM 32 位,在 x86_64 模拟器上经二进制翻译层执行
引擎 Cocos2d-x Lua(Java 入口为常规 Activity)
主库 混淆壳版主库,体积约 25 MB
脚本 加密资源 + 魔改 Lua 5.1 字节码
TLS 客户端内嵌多份不同版本的静态 TLS 实现
注意:ARM 库运行在 x86_64 模拟器上、经过翻译层,这一点后来解释了多处「静态地址存在但运行时不经过」的现象(TOP12、TOP20)。
0.3 时间线(按文件时间记录,仅标相对顺序)
第 1–2 天 技术栈、抓取管线、静态排除表、素材全量拉取
第 2 天 C++ 加解密绑定链路、内存字节码格式破译(设备已关,纯离线)
第 4 天 opcode 实证、全局槽号方案、数学路线判死
第 8 天 数据拷贝点观测,发现「解密非原地」
第 9 天 分配点观测打通明文字节码全量捕获
第 10–11 天 运行时防护观察、资产面收口
第 14 天 唯一一次 git commit
约 2 个月后 静态字节改写线
约 3 个月后 内存 dump、完整性清单
第一部 补环境调试
定义
├── 不挂目标进程(设备可关)
├── 输入是文件:安装包资产 / 动态库 / 资源密文 / 内存镜像
├── 手段是宿主侧程序:Python 解析、capstone 反汇编、readelf、约束求解、静态字节改写
└── 输出可复算:格式定义、地址表、排除表、反汇编文本、改写前后校验清单
优势
├── 不触发运行时防护,无账号风险
├── 可反复跑、可批量、可留 diff
└── 结论不依赖某一次进程状态
天花板
├── 拿不到运行时才构造的数据
├── 符号表可能被系统性污染(TOP3)
├── 静态地址可能不在真实执行路径上(TOP12)
└── 静态改写无法自证运行有效(TOP22)
阶段笔记里有一节专门记「本轮工具链(全部可用,离线)」,列的就是这一部:字节码提取器、标准反汇编器、完整脚本提取器、注册表定位与 opcode 差分工具、加解密测试套件。下文按环节说明各自执行的是哪个文件。
TOP1 素材准备与离线输入
1.1 输入类型
离线分析的四类输入
├── ① 安装包静态解包
│ ├── 脚本密文(一种自定义容器头)
│ ├── 资源密文(另一种容器头)
│ ├── 资源清单 JSON(数十 MB)
│ └── base64 编码的分发配置
├── ② 设备侧落盘回传
│ ├── 混淆壳版主库与若干动态库
│ ├── 一批加密脚本文件
│ ├── 内存镜像(数百 MB)
│ └── 少量内存字节码样本及其反汇编文本
├── ③ 资源分发侧全量拉取
│ └── 按版本清单逐文件取回,逐个校验摘要
└── ④ 引擎符号表
└── 数万条符号名与地址
素材齐全解决的是「齐不齐」,不是「能不能读」。地址对不对在 TOP3 判,密钥拿不拿得到在 TOP5–TOP7 判。
1.2 全量拉取
这一步执行的是 cdn_pull.py。流程是取版本号与文件清单,按清单逐项请求,落盘后逐个核对摘要。记录的结果是 10,950 / 10,950 个脚本、41.3 MB、摘要全部通过,并产出一份脚本名到摘要的对应清单。
cdn_pull.py 的流程
├── 取 patch_version 与 filelist
├── 逐文件请求资源分发路径
├── md5 校验
└── 落盘 + 生成清单
同一个环节还有 scan_apk_libs.py(安装包内动态库盘点)、dex_strings.py(Java 层字符串)、find_openssl_version_ref.py 与 search_version_ints.py(版本串定位)。这些都在宿主侧跑,不碰进程。
1.3 完整性与清单
完整性清单是一份约 11,300 行的 SHA256 列表,覆盖约 6.61 GB。原始记录里混入了版本控制目录的内部文件;作为交付或举证材料,这一点需要清理,属于工程治理观察,不是技术结论。
index_plains.py 负责给捕获到的明文分片建索引,organize.py 与 repack.py 负责归档。索引的实际形态是一个 JSON 数组,每项四元组:
[
"<分片文件名>",
<字节数>,
"OK",
"@src/<路径>\\u0000"
]
注意索引里同一路径会重复出现多次,是多次捕获的重复落盘,不是不同脚本。
1.4 输入与后续环节的对应
安装包脚本密文 ─────→ TOP4 格式 / TOP5 排除 / TOP6 算法重构
资源分发密文 ───────→ TOP7 约束求解输入 / 第二部 S2 密文对齐
混淆壳主库 ─────────→ TOP2 ELF / TOP3 符号 / TOP6 反汇编 / TOP9 格式表
内存镜像文件 ───────→ TOP4 字节码提取 / TOP10 反编译输入
若干动态库 ─────────→ TOP11 静态改写
明文分片(动调产出)→ TOP10 离线反编译(两部交点)
TOP2 ELF 环境补齐:PT_DYNAMIC / .dynsym / GOT
「补环境」最典型的一节。目标不是运行动态库,而是把 ELF 里能承载地址信息的结构手工重建出来,绕开被混淆的 Section Header。
2.1 ELF 结构
ELF64 Header(文件偏移)
├── 0x00 e_ident[16] 7f 45 4c 46 / class / endian
├── 0x28 e_shoff (Q) Section Header 表偏移
├── 0x3a e_shentsize (H)
├── 0x3c e_shnum (H)
├── 0x3e e_shstrndx (H)
└── e_phoff Program Header 表偏移
│
├── PT_LOAD 段映射与权限(加载器只认这一层)
└── PT_DYNAMIC ──→ .dynamic
├── DT_SYMTAB ──→ .dynsym 符号名 + st_value
├── DT_STRTAB ──→ .dynstr
├── DT_JMPREL ──→ .rela.plt
├── DT_PLTGOT ──→ .got
└── DT_NEEDED ──→ 依赖库
│
└── e_shoff ──→ Section Headers 给静态工具看,可混淆 / strip / 填假
加载器只认 Program Header;Section Header 是给静态分析工具看的,可以混淆、strip、填假值而不影响运行。
2.2 elf_syms2.py:手工解析
这一步执行的是 elf_syms2.py。它不调用 readelf,而是直接从 ELF Header 的定长偏移取字段、手工 unpack 节头:
# -*- coding: utf-8 -*-
"""解析 ELF 动态符号表: 尝试多种编码解码被混淆的符号名"""
import struct, sys
LIB = sys.argv[1]
def parse_elf(path):
data = open(path, 'rb').read()
assert data[:4] == b'\x7fELF'
is64 = data[4] == 2
endian = '<' if data[5] == 1 else '>'
if is64:
e_shoff = struct.unpack_from(endian + 'Q', data, 0x28)[0]
e_shentsize = struct.unpack_from(endian + 'H', data, 0x3a)[0]
e_shnum = struct.unpack_from(endian + 'H', data, 0x3c)[0]
e_shstrndx = struct.unpack_from(endian + 'H', data, 0x3e)[0]
else:
e_shoff = struct.unpack_from(endian + 'I', data, 0x20)[0]
e_shentsize = struct.unpack_from(endian + 'H', data, 0x2e)[0]
e_shnum = struct.unpack_from(endian + 'H', data, 0x30)[0]
e_shstrndx = struct.unpack_from(endian + 'H', data, 0x32)[0]
shdrs = []
for i in range(e_shnum):
off = e_shoff + i * e_shentsize
if is64:
sh = struct.unpack_from(endian + 'IIQQQQIIQQ', data, off)
shdrs.append(dict(name=sh[0], type=sh[1], flags=sh[2], addr=sh[3],
offset=sh[4], size=sh[5], link=sh[6], info=sh[7],
addralign=sh[8], entsize=sh[9]))
shstr = shdrs[e_shstrndx]
shstr_data = data[shstr['offset']:shstr['offset'] + shstr['size']]
def get_str(tab_off, off):
tab = data[tab_off:tab_off + 0x100000]
end = tab.find(b'\x00', off)
return tab[off:end] if end != -1 else b''
strtab = None
for sh in shdrs:
sname = get_str(shstr['offset'], sh['name']).decode('utf-8', 'replace')
if sname in ('.dynstr', '.strtab'):
strtab = sh
break
if strtab is None:
print("no strtab"); return
# 解码候选: raw / utf-16-le / gbk / latin1 各种变换
elf_syms2.py 的补法
├── 不依赖静态工具(Section Header 被混淆时输出不可信)
├── ELF Header 定长偏移 → e_shoff / e_shentsize / e_shnum / e_shstrndx
├── shdr 结构 IIQQQQIIQQ 手工 unpack
├── shstrndx 取节名,定位 .dynstr / .strtab
├── 符号名尝试 raw / utf-16-le / gbk / latin1 多种解码
└── 结果:数万条符号(名字可读,st_value 另判,见 TOP3)
同一族里还执行过 elf_syms.py、elf_dynsyms.py、parse_elf_sym.py、parse_syms_plain.py、scan_exports.py / scan_exports2.py(符号解析),plt_finder.py / plt_finder2.py / plt_finder3.py / plt_full_map.py、got_indirect_scan.py、got_unisdk_scan.py(PLT 与 GOT),以及 epay_elf.py / epay_shdr.py / epay_rela.py / epay_xref.py / epay_jni.py(节、重定位与 JNI 侧)。
注意:这批脚本多数是一次性探针,同类变体有五六个,没有统一入口和参数化。这是探索日志,不是工具链。
2.3 GOT / PLT 补出的调用关系
某校验函数入口
└── 内部 PLT 桩 → GOT 项 → 指回同一函数
│
另一处理函数
└── 某偏移处 bl <PLT 桩> → 调用后使用返回值
│
第三处错误路径
└── 分支条件被静态改写
│
旁证:业务侧确实配置了校验回调
├── GOT JUMP_SLOT 指向 set_keylog_callback
├── GOT JUMP_SLOT 指向 set_verify
└── 存在 TLS 密钥日志钩子函数
有 set_verify 的 GOT 项,说明业务代码主动配置了校验回调,不是默认不校验。这一条决定静态改写面是否值得做,也是「先验证符号可信、再谈地址」的落点。
2.4 三条 ELF 解析路径的函数级对照
同一批符号被三条互不依赖的路径各解析过一遍,目的不是重复,是互相证伪:节头表可以给静态工具填假值,PT_DYNAMIC 才是加载器真正读的那份。
elf_dynsyms.py 走动态段,函数拆成三段:
def parse_phdrs(data):
is64 = data[4] == 2
endian = '<' if data[5] == 1 else '>'
e_phoff = struct.unpack_from(endian + 'Q', data, 0x20)[0]
e_phentsize = struct.unpack_from(endian + 'H', data, 0x36)[0]
e_phnum = struct.unpack_from(endian + 'H', data, 0x38)[0]
for i in range(e_phnum):
off = e_phoff + i * e_phentsize
p_type, p_flags, p_offset, p_vaddr, p_paddr, p_filesz, p_memsz, p_align = (
struct.unpack_from(endian + 'IIQQQQQQ', data, off))
# PT_LOAD=1 保留 vaddr/filesz/memsz, PT_DYNAMIC=2 单独取
def get_dynamic(data):
for i in range(0, sz - 16, 16): # ELF64 每条 16 B
tag, val = struct.unpack_from(endian + 'qQ', data, off + i)
entries[tag] = val # ELF32 改 'iI'、步长 8
def vaddr_to_offset(data, vaddr):
for ph in phdrs:
if ph['type'] == 1 and ph['vaddr'] <= vaddr < ph['vaddr'] + min(ph['filesz'], ph['memsz']):
return ph['offset'] + (vaddr - ph['vaddr'])
return None
main() 里还写了一个可复核的估值:符号数不直接给,用 (strtab_off - symtab_off) // syment 估,上限 300000;名字偏移 > 0x400000 直接丢;按 st_value 排序输出。解不出 utf-8 / ascii 的名字也直接丢——磁盘上的 .dynstr 本身是密文时,这一步会表现为「符号全在、名字全乱码」,后来被离线加载实验独立证实(TOP12)。
elf_syms2.py 走节头表,Elf64_Sym 按 24 B 步进,过滤条件全在循环里:
entsize = sh['entsize'] or (24 if is64 else 16)
st_name, st_info, st_other, st_shndx, st_value, st_size = (
struct.unpack_from(endian + 'IBBHQQ', data, off)) # ELF32 是 'IIIBBH'
if st_name == 0: continue
bind = (st_info >> 4) & 0xf
typ = st_info & 0xf
if typ not in (0, 1, 2): continue
if st_value == 0 and typ != 0: continue
scan_exports2.py 把两条路都实现了,节头解析返回 None 就退到动态段;动态段路径里符号数要从哈希表推:
# 第一个 PT_LOAD 给 base_va(+0x10) / base_off(+0x08)
# PT_DYNAMIC 给 dyn_va(+0x10) / dyn_sz(+0x20)
def va2off(va):
return va - base_va + base_off
symtab, strtab = tags.get(6), tags.get(5) # DT_SYMTAB / DT_STRTAB
if 4 in tags: # DT_HASH
n = struct.unpack_from('<I', data, va2off(tags[4]) + 4)[0] # nchain
elif 0x6ffffef5 in tags: # DT_GNU_HASH
nbucket, symoffset, bloom_sz = struct.unpack_from('<III', data, ho)
# bucket 取最大索引, 再沿 chain 走到奇数项确定 n
三条路径对照
├── elf_syms2.py 节头表 → .dynsym/.dynstr → 24 B Sym
│ ├── 依赖 e_shoff / e_shnum / e_shstrndx
│ ├── 名字需按多种编码尝试解码
│ └── 风险:节头可填假,符号名与 st_value 都可能不可信
├── elf_dynsyms.py PT_DYNAMIC → DT_SYMTAB / DT_STRTAB / DT_SYMENT
│ ├── 符号数靠两表文件间距估算
│ └── 风险:估算依赖两表在文件里相邻
└── scan_exports2.py 双路兜底 + DT_HASH / DT_GNU_HASH 推 n
├── 先看节头,失败再走动态段
└── 风险:GNU_HASH 的 n 需沿 chain 找尾,最易实现错
DT tag 速查(脚本实际用到的)
├── 4 DT_HASH nchain 在 +4
├── 5 DT_STRTAB
├── 6 DT_SYMTAB
├── 10 DT_STRSZ
├── 11 DT_SYMENT 默认 24
├── 0x6ffffef5 DT_GNU_HASH nbucket / symoffset / bloom_sz
└── 1 / 2 PT_LOAD / PT_DYNAMIC(Program Header 类型)
Elf64_Sym(24 B)
├── +0 st_name I .dynstr 内偏移
├── +4 st_info B bind = 高 4 位 / type = 低 4 位
├── +5 st_other B
├── +6 st_shndx H
├── +8 st_value Q 静态地址(可信度另判,见 TOP3)
└── +16 st_size Q
2.5 PLT stub 与 GOT 间接跳转的判定模板
plt_finder.py、plt_finder2.py、plt_finder3.py、got_indirect_scan.py、xref_pin_scan.py 是同一套模板的多次实现。判定链固定:
PLT stub 识别链
├── ① readelf -r 取 GOT 地址;节头剥离时改用 PHDR 推 .plt 区间
├── ② text 段扫 adrp xN,<GOT页> / ldr xM,[xN,#off] / br xM 三件套
│ └── 变体:add x16,... 后 br x17;或 blr xN
├── ③ 每条 ldr 看紧邻下一条是不是 blr / br
├── ④ GOT 条目 → .dynsym 索引 → 名字
└── ⑤ 与字符串 xref 交叉,确认这条调用真的在用
plt_finder.py 的注释里写明了扫描区间与失败条件:只在可执行 PT_LOAD 中范围最大的那段里找 ldr/ldur 取 GOT 的指令,然后前向搜索紧邻的 blr;got_indirect_scan.py 更保守,先收集全部 ldr xM,[xN,#imm],再反向找最近的 adrp xN 算出 got 地址,避免把普通常量加载误判成 GOT 引用;xref_pin_scan.py 只找两类——BL 直调和 ADRP+LDR 数据引用。
一次实证(说明模板为什么必要)
├── 现象:0x085620 处一条 bl 0x6be50 被当成普通函数调用
├── 反汇编:0x6be50 / 0x6c5d0 都是 adrp 0x266000 + ldr + br
├── 定位:0x266000 区是 GOT,0x6xxxx 段全是动态符号跳板
├── 结论:真实目标是动态符号,不是本地函数
└── 同节另一类误判:OLLVM 平坦化函数用 cmp w8,状态常量 分派
├── 整段无标准 prologue
└── movk 出来的大常量是 switch case 值,不是算法常数
"无引用"结论的修正
├── 过严扫描:只认精确 imm 匹配 → 全部报"无引用"
├── 放宽后:adrp 页基址 + imm 相加 → 命中目标 VA
│ └── 例:adrp 0x26b000 + imm 0x6c8 = 0x26b6c8
├── 附带产出:同一引用簇里连续 7 个点,间隔 8 B
└── 纪律:先反汇编确认寻址模式,再定扫描阈值
"无 xref" 是扫描参数的函数,不是事实。笔记里把这条单独记成一次修正,因为它推翻了前一版的多处结论。
TOP3 符号表可信度判定
TOP2 解决「能不能读」,这一节解决「读到的值是不是真的」。
3.1 两份动态库的差别
同一客户端
├── 主库(内嵌较旧版本 TLS 实现)
│ ├── Section Headers 被混淆
│ ├── PT_DYNAMIC 完好 → .dynsym 可读
│ ├── st_value 被系统性偏移(FUNC 与 OBJECT 都改)
│ └── 定位结果 主动放弃
│
└── 另一动态库(内嵌较新版本 TLS 实现)
├── 无该层混淆
├── 符号名与地址一一对应
└── 定位结果 静态改写点据此确定
差别不是「能不能读符号表」,是「读到的值是不是真的」。
3.2 逐条反汇编反证
| 符号(表内地址) | 反汇编现场 | 判定 |
|---|---|---|
SSL_accept @0xc8d6cc |
实为 ssl_ctrl switch(跳转表 @0xdeb068,cmd 0x10~0x4e)某 case 尾部 b #0xc8d610 公共 epilogue |
不是函数入口 |
BN_rand @0xbfd3ec |
首条指令即 ret |
函数中间 |
RAND_poll @0xc1ce5c |
首条即 b |
跳板 |
ssl3_undef_enc_method @0x157ee90 |
读出 0x181 / 0xc030… 小整数占位,非函数指针 |
OBJECT 值同样被改 |
这一步执行过 disasm_ssl_accept.py、disasm_x509_entry.py、disasm_full_verify.py、confirm_x509_verify_cert.py、show_errstr_callers.py 等一批反汇编探针,逐条把表内地址与序言对上。
3.3 证据分层
证据分层
├── 可用 ──────────────────────────────────────────┐
│ 版本串与构建日期串(若干固定地址) │
│ 证书错误串: │
│ "certificate verify failed" │
│ "unable to get local issuer certificate" │
│ "self signed certificate" │
│ "unsupported certificate purpose" │
│ │
└── 不可用 ────────────────────────────────────────┤
错误串 xref 只达错误串表 / PLT 桩区
未达校验函数体 → 字符串池被搬过或引用被改写
3.4 判定顺序
拿到符号
├── ① 反汇编看序言 / 首条指令
├── ② 与符号语义比对
├── ③ 不匹配 → 记为不可信,不硬用
└── ④ 匹配 → 用 GOT / PLT / 字符串 xref 交叉证明该栈确实在用
放弃理由按原始口径:混淆库的精确入口需要运行时内存扫描或反混淆工具,静态定位成本高于收益,因此主交付不基于它。TOP3 与 TOP5 是同一种操作:把搜索空间里走不通的部分标出来。区别是 TOP3 判「地址」,TOP5 判「假设」。
TOP4 文件格式层:容器头 / 字节码 / Proto
4.1 两种容器头与一个内部标记
① 脚本密文文件头
+----------+----------+-------------------------------+
| 8 B | 4 B | payload |
| 自定义魔数 | 文件专属 | 熵 7.997 / 长度 == 明文长度 |
+----------+----------+-------------------------------+
偏移 12 起为密文,n = ceil(len/4)
4B 字段同脚本恒定(非真随机,文件专属)
笔记里修正过一次:早期记为 4B 0,后改正
② 资源密文文件头
[4B 另一魔数][u32 1][数据]
8,055 个;IO 日志里 spine 资源读到这一魔数
③ 内存缓存内部标记
同一 8 字节串作为 tag 使用,不是文件头
注意:载荷长度等于明文长度,没有标准 XXTEA 常见的 +8 特征。这一条直接卡掉了后续差分攻击的前提(TOP7)。
4.2 字节码结构
luac 文件
└── Header 12 B 1b 4c 75 61 51 00 01 04 04 04 08 00
│ └ Lua 5.1 / int=4 / size_t=4 / instr=4 / num=8(double)
└── Proto(递归)
├── source: u32 len + 内容(len 含 \0)
├── linedefined / lastlinedefined (4+4)
├── nups / numparams / is_vararg / maxstacksize (1×4)
├── sizecode u32 → ncode × 4 B 指令
├── sizek u32 → TValue 数组
│ └── t=0 nil / t=1 bool(1B) / t=3 double(8B)
│ / t=4 string(u32 len + 内容,len 含 \0)
├── sizep u32 → 子 Proto 递归
└── debug lineinfo / locvars / upval 名
TValue 类型编码
├── t=0 nil 0 B
├── t=1 bool 1 B
├── t=3 double 8 B
└── t=4 string u32 len + len B(len 含 \0)
这一步执行的是 vm_rev_decompiler.py,它的 parse_proto 把上面的布局写死了:
def parse_proto(b, pos=12, depth=0):
if pos + 4 > len(b): return None
src_len = struct.unpack_from('<I', b, pos)[0]
if src_len > 0x100000: return None
pos += 4 + src_len
pos += 12
if pos + 4 > len(b): return None
sc = struct.unpack_from('<I', b, pos)[0]
if sc > 0x1000000: return None
pos += 4
code = list(struct.unpack_from('<%dI' % sc, b, pos)) if sc > 0 else []
pos += sc * 4
if pos + 4 > len(b): return None
sizek = struct.unpack_from('<I', b, pos)[0]
pos += 4
consts = []
for _ in range(sizek):
if pos >= len(b): return None
t = b[pos]; pos += 1
if t == 0:
consts.append(None)
elif t == 1:
consts.append(bool(b[pos])); pos += 1
elif t == 3:
consts.append(struct.unpack_from('<d', b, pos)[0]); pos += 8
elif t == 4:
l = struct.unpack_from('<I', b, pos)[0]
if l > 0x100000: return None
pos += 4
consts.append(b[pos:pos+l].decode('utf-8', 'replace'))
pos += l
else:
return None
# ... sizep / 递归 parse_proto
每一处都有上界检查(0x100000 / 0x1000000),因为输入是从堆内存里切出来的,尾部经常被别的堆对象打断。阶段笔记记了具体位置:launcher 主缓冲在 0x4fa1 后被堆对象打断,所以只能提取主函数 + 前约 20 个子函数。
4.3 标准反汇编器作对照
这一步执行的是 lua51_disasm.py,用于验证「结构是不是标准」:
OPS = ['MOVE','LOADK','LOADBOOL','LOADNIL','GETUPVAL','GETGLOBAL','GETTABLE','SETGLOBAL',
'SETUPVAL','SETTABLE','NEWTABLE','SELF','ADD','SUB','MUL','DIV','MOD','POW','UNM',
'NOT','LEN','CONCAT','JMP','EQ','LT','LE','TEST','TESTSET','CALL','TAILCALL','RETURN',
'FORLOOP','FORPREP','TFORLOOP','SETLIST','CLOSE','CLOSURE','VARARG']
def parse(b, p, dump):
def rs():
nonlocal p
l = u32(b, p); p += 4
s = b[p:p + max(l - 1, 0)].decode('latin-1', 'replace') if 0 < l < 4096 else ''
p += l
return s
src = rs()
p += 4 + 4 + 4
ncode = u32(b, p); p += 4
code = [u32(b, p + i * 4) for i in range(ncode)]
# ... 常量 / debug / 子 Proto 递归
if __name__ == '__main__':
hdr_ok = b[:12] == b'\x1bLua\x51\x00\x01\x04\x04\x04\x08\x00'
print('header:', '标准Lua5.1(dbl)' if hdr_ok else '异常! ' + b[:12].hex())
end = parse(b, 12, True)
print('解析结束偏移:', end, '/ 文件大小:', len(b),
'→', '完整' if end == len(b) else '不完整(差 %d)' % (len(b) - end))
对照结果:
结构层 标准 Lua 5.1 → lua51_disasm.py 可直接解析
语义层 opcode 表重排 → 标准 OPS 表输出的名字不可信
笔记记:LOADK=34, GETGLOBAL≈20(非标准 1/5)
→ 必须建自己的 NAMES 表(TOP9)
4.4 从内存镜像里切字节码
这一步执行的是 vm_extract_mega_luac.py。输入是数百 MB 的内存镜像文件,用头搜索切块(路径已略去):
data = open(DUMP, 'rb').read()
OUT = 'mega_luac'
HDR = b'\x1b\x4c\x75\x61\x51\x00'
heads = []
pos = 0
while True:
i = data.find(HDR, pos)
if i < 0: break
pos = i + 1
ln = struct.unpack_from('<I', data, i+12)[0]
if not (0 < ln < 500): continue
src = data[i+16:i+16+ln-1]
if src.startswith(b'@src'):
heads.append((i, src))
print(f'@src 块头: {len(heads)}')
seen = set()
for idx, (i, src) in enumerate(heads):
end = heads[idx+1][0] if idx+1 < len(heads) else min(i + 3_000_000, len(data))
key = (src, end - i)
if key in seen: continue
seen.add(key)
name = src.decode('utf-8','replace').replace('/', '_').replace('@', '').strip()
fn = os.path.join(OUT, f'{name}.luac')
with open(fn, 'wb') as f:
f.write(data[i:end])
切块规则
├── 头 1b4c75615100
├── 偏移 +12 取 source 长度 u32,限定 0 < ln < 500
├── 偏移 +16 起读 source,要求以 @src 开头
├── 块尾 = 下一个头(或 +3,000,000 兜底)
├── (src, 长度) 去重
└── 落盘单个 .luac
阶段笔记里这条链路记成更短的一行:零注入读进程内存 → 镜像文件 + 段映射 JSON → 提取脚本 → 反汇编。抓取在第二部 TOP14,切块与反汇编在宿主侧离线做,是两部的交界。
同族还执行过 extract_boot_luacs.py、extract_live_luacs.py、extract_chunks.py、extract_gameplay.py、scan_all_luac.py、luac_sizes.py、luadump.py。
4.5 三个切块 / 重建解析器的函数级差异
从内存镜像里拿字节码,笔记里同时用了三种解析器。它们的输入都是二进制,但假设不同:一种按文件格式的严格长度递归,一种只要算出消耗长度,第三种读的是运行时对象而不是序列化文件。
extract_chunks.py 最严格,parse_function 每一步都检查上界,任一步抛异常就退回 j+1 重新找头:
def parse_function(b, p, trace=None):
def read_str():
nonlocal p
l = u32(b, p); p += 4
if l > 64 * 1024 * 1024: raise ValueError('str %d' % l)
if l > len(b) - p: raise ValueError('str overflow')
p += l
s_len = u32(b, p); p += 4
if s_len > len(b) - p: raise ValueError('src overflow')
p += s_len
p += 4 + 4 # linedefined, lastlinedefined
p += 1 + 1 + 1 + 1 # nups, params, isvararg, maxstack
n = u32(b, p); p += 4 # code[]
if n * 4 > len(b) - p: raise ValueError('code ovf')
p += n * 4
n = u32(b, p); p += 4 # constants[]
for _ in range(n):
t = b[p]; p += 1
if t == 0: pass
elif t == 1: p += 1
elif t == 3: p += 8
elif t == 4: read_str()
else: raise ValueError('const type %d' % t)
# debug: lineinfo / locvars / upvalue names(strip 时三段计数为 0)
return p
def scan_chunks(b, dbg=False):
j = b.find(b'\x1bLua\x51', i)
if j + 12 <= len(b) and b[j + 5:j + 12] == b'\x00\x01\x04\x04\x04\x08\x00':
end = parse_function(b, j + 12) # 全解析成功才算一个 chunk
out.append((name, j, end))
i = end # 成功后跳过整块
harvest_luacs.py 与 harvest_all.py 放宽到只算长度,rd_tstr 返回 (内容, 新偏移),parse_proto_size 返回消耗字节,深度上限 60:
def rd_tstr(b, p):
ln = struct.unpack_from('<I', b, p)[0]
if ln == 0 or ln > 0x100000: return b'', p + 4
if p + 4 + ln > len(b): return None, p
return b[p+4:p+4+ln-1], p + 4 + ln
def parse_proto_size(b, p, depth=0):
if depth > 60: return None
src, p = rd_tstr(b, p)
p += 12
sc = struct.unpack_from('<I', b, p)[0]
if sc > 0x1000000: return None
p += 4 + sc * 4
sizek = struct.unpack_from('<I', b, p)[0]
if sizek > 0x100000: return None
# 常量 / 子 Proto / debug 三段依次推进,最后返回 p
proto_extract.py 是第三条路:它不解析 luac 文件,而是从进程内存里的运行时对象反推,再序列化回标准 luac。段寻址用 bisect:
starts = [s[0] for s in segmap]
def read_va(va, n):
i = bisect.bisect_right(starts, va) - 1
if i < 0 or va + n > ends[i]: return None
return datas[i][va - starts[i]: va - starts[i] + n]
def tstring_str(va):
hdr = read_va(va, 32)
ln = u64(hdr, 24) # CommonHeader 16B + hash 8B + len 8B
if ln <= 0 or ln > 2000: return None
return read_va(va + 32, ln).rstrip(b'\x00').decode('latin-1', 'replace')
三种解析器对照
├── extract_chunks.py 输入:任意 dump 缓冲
│ ├── 假设:完整 luac 序列化结构
│ ├── 判据:头 12 B 参数 + 递归解析不抛异常
│ └── 失败:退回 j+1 重找,不产出残缺块
├── harvest_*.py 输入:已落盘分片
│ ├── 假设:只要 Proto 长度自洽
│ ├── 判据:各计数字段上界 + depth<=60
│ └── 产出:source 名 + 消耗字节
└── proto_extract.py 输入:段镜像 + segmap
├── 假设:运行时 Proto / TString 对象布局已知
├── 判据:116 B 头里各 size 字段上界
└── 产出:重新序列化的 .luac
运行时 Proto 对象(116 B 头的字段偏移)
├── +16 k_ptr 常量数组指针
├── +24 code_ptr 指令数组指针
├── +32 p_ptr 子 Proto 指针数组
├── +64 src_ptr source 的 TString*
├── +72 sizeupvalues u32
├── +76 sizek u32
├── +80 sizecode u32
├── +84 sizelineinfo u32
├── +88 sizep u32
├── +92 sizelocvars u32
├── +96 linedefined u32
├── +100 lastlinedefined u32
├── +112..115 nups / params / vararg / maxstack 各 1 B
└── 校验 sizecode<=2000000, sizek<=200000, sizep<=20000,
nups<=200, maxstack<=250, linedefined<=10000000
TValue(16 B)与 TString
├── TValue +0 value(8 B) / +8 tt(1 B) / +9..15 pad
│ ├── tt=0 nil tt=1 bool tt=3 number(double)
│ └── tt=4 string → value 是 GCObject*
├── TString +0 CommonHeader(16 B) / +16 hash(8 B) / +24 len(8 B) / +32 data
└── 子 Proto 指针数组:每项 8 B
回写侧 ser_str 用 u32 len + 内容 + \0,ser_proto 按 source / 两个行号 / 四个 1B 字段 / sizecode+code / sizek+常量 / 三段 debug 写 0 / sizep+递归 的顺序拼,make_luac 在前面补 12 B 标准头。这条链的价值是把「内存里看到的对象」变成「能用标准工具打开的文件」,两部在这里合流。
主流程还有一步值得记:先在全部段里正则找干净的脚本名 TString,再把名字的 VA 打包成 8 B 指针去段里 find,命中位置减去 64 就是 Proto 起点候选,逐个交给 parse_proto 校验。visited 集合防环,found > 400 直接停。
4.6 两处自定义序列化的实证
前面 4.2 写的是标准 Lua 5.1 布局。后面又补了一次实证:真正卡住解析的不是加密,也不是截断,是这个构建改了两处序列化。
标准 Lua 5.1 vs 该构建
├── lineinfo u8 数组 → u32 数组
├── opcode 表 标准顺序 → 整体重排
├── 解析器步进 p += n → p += n * 4
└── RETURN 30 → 5
判据是硬观测,不是猜:
├── 修正解析器后,某主脚本 24,703 B 全量耗尽、0 字节残留
├── 还原 39 个原型(含嵌套)+ 全部常量池 + 指令流 + 行号
├── 反汇编文本 97 KB
└── 39/39 个原型的末指令 opcode 均为 5
└── 标准 Lua 5.1 的 RETURN 是 30 → 末指令位置天然是 opcode 判定的锚
这一步执行的是 lua51_disasm.py 与 lua_insn_layout.py。lua_insn_layout.py 专门负责把 lineinfo 的步长从 1 改成 4 并验证剩余字节;lua51_disasm.py 则同时保留标准 OPS 表和自建 NAMES 表,输出时明确区分「结构标准」与「语义重排」。
解析错位的两种根因(不要混为一谈)
├── 结构层:lineinfo 用 u32 存储
│ ├── 症状:debug 段之后所有偏移整体错位
│ └── 修法:改步长,重算消耗字节
└── 语义层:opcode 表重排 + B/C 交换 + 全局槽号
├── 症状:结构能解析完,但指令含义全错
└── 修法:建 NAMES 表、差分实证、改索引命名空间(TOP9.4)
同一轮还闭环了资源目录命名的来源:顶层原型的常量池里含一处路径哈希注册项与若干搜索路径模板,资源目录里那串 32 位十六进制名字是路径哈希计算的产物,不是随机目录名。这一条解释了 1.1 里「按版本清单逐文件取回」为什么会得到那种目录结构。此处只记录命名机制,不涉及任何具体常量值。
TOP5 静态排除清单
5.1 搜索空间按假设分类
目标:资产层解密 key
│
├── A 固定 / 流式密钥 ────────────────────────────────┐
│ ├── A1 固定密钥流 XOR / RC4 → 300 文件前 12B 两两比对
│ ├── A2 文件内嵌 key → 魔数后 8/16/24/32B 作 key
│ └── A3 魔数单字节 XOR 编码 → 256 种穷举
│
├── B 标准分组密码 ────────────────────────────────┐
│ ├── B1 硬件 AES → 扫 AESE/AESD/AESMC/AESIMC
│ ├── B2 软件 AES → 静态 S-box 表特征
│ └── B3 已知明文扫 AES key → 320 万窗口
│
├── C 静态常量型 XXTEA key ────────────────────────┐
│ ├── C1 rodata 任意 16B 窗口 → 250 万窗口 × 2 目标文件
│ └── C2 movk 常量装载模式 → 全库扫描
│
└── D 剩余(未被排除)─────────────────────────────┐
└── 每文件独立 IV + 运行时构造的 key
5.2 排除表
| # | 假设 | 验证方式 | 规模 | 结论 |
|---|---|---|---|---|
| 1 | A1 固定密钥流 (XOR / RC4) | 300 文件前 12B 密钥流两两比对 | 300 | 全不同,排除 |
| 2 | A2 文件内嵌 key + XOR/RC4 | 魔数后 8/16/24/32B 作 key | 全试 | 排除 |
| 3 | B1 硬件 AES | 密集代码区扫 AESE/AESD/AESMC/AESIMC |
0x400000–0x1000000 |
0 条;之前 42 条是数据误报 |
| 4 | B2 软件 AES | 静态 S-box 表特征 | 全库 | 无,排除 |
| 5 | C1 rodata 任意 16B 窗口作 key | 窗口 × 2 目标文件 | 250 万窗口 | 全败 |
| 6 | B3 已知明文扫 AES key | 窗口扫描 | 320 万窗口 | 全败 |
| 7 | A3 魔数单字节 XOR 编码 | 256 种 | 256 | 全无 |
| 8 | C2 静态 key 常量装载 | movk 常量模式 |
全库 | 0 命中 |
第 3 条有一次自我修正:一开始扫出 42 条 AES 指令,复查发现全落在数据区,笔记里写「之前 42 条全是数据误报」。误报保留在记录里,没有删掉。
这一步执行过 find_key_const.py / find_key_const2.py(常量装载模式)、key_scan_ext.py / deep_crypto_scan.py(数据区窗口)、xxtea_brute.py / md5_candidates.py(候选穷举)、goldpair_decisive.py / xxtea_verify_pair.py(配对验证)、key_test_cands.py(候选集,后被证实是文件名误读)、four_way_check.py / enc_instances_verify.py(交叉校验)。
5.3 剩余假设与转向
资产密文 = 运行时构造密钥的自定义/混淆算法
静态挖 key 路径 = 魔数构造代码 → 解密器 → key
→ TOP6 / TOP7 / TOP8 证明这条路径也没走通
→ 第二部 TOP18 改问「明文必然在哪一瞬间出现过」
排除表本身是有效产出:它把「再试一种编码」这类念头一次性关掉。
5.4 后续补进来的四条排除项
5.2 那张表是攻坚期写的,后面又补了四条,性质不同:前两条是「扫描方法本身会误报」,后两条是「素材本身不值得继续投入」。
新增排除项
├── ① 常量扫描误报
│ ├── OLLVM 平坦化的 dispatcher 用 cmp w8,状态常量 分派
│ ├── movk 出来的大常量是 switch case 值,不是算法常数
│ ├── 公开算法常数在平坦化代码里也会作为状态匹配常量反复出现
│ └── 结论:搜到该常数 ≠ 找到算法实现,须看上下文是否有轮函数
├── ② 流密钥重用排除
│ ├── 23 个 8190 B 密文块两两 XOR
│ ├── 零字节 36–43 个(随机期望约 32),最长零游程 = 1
│ ├── 判据:零游程为 1 说明没有重复密钥流
│ └── 结论:排除固定 XOR / RC4 一类弱实现
├── ③ 残留文件定性
│ ├── 4 个文件长度 %4=2,不满足 4 字节对齐密文特征
│ ├── 多组偏移 × 轮次 × 候选串组合,全部无结构性 magic
│ └── 判定:不完整热更缓存或旧构建残留,不再投入
└── ④ 符号层不含业务数据模型
├── 31,497 条隐藏符号 + 58,253 条动态符号
├── 业务字段名集合命中为 0
└── 结论:该层只做加载与调度,字段语义不在这里
误报来源归类
├── 常量匹配 → 需配合控制流形状(循环、移位组合、轮计数)
├── 名字匹配 → 需配合序言反汇编(TOP3)
├── 头匹配 → 需配合完整结构解析(4.5)
└── 长度匹配 → 需配合对齐与熵特征(本节 ③)
第 ① 条最值得留:它是唯一一条把「工具的输出」而不是「目标的性质」判成死路的。之后常量扫描一律降级为线索,不再单独作为定位证据。
TOP6 XXTEA 变体重构:从汇编到伪代码
6.1 解密链路与地址
0x85261c XXTEA 解密包装器
│ 读密文 buffer + 16B key
└── 0x8526a8 XXTEA 解密核心(sum 递减)
├── 0x852548 字节流 → 32 位字数组
├── MX 变体 移位组合被改过
└── 输出 写回缓冲(长度不变)
0x852804 加密核心(诱饵,见 TOP8)
0x8ab25c decrypt(流式路径)
0x8ab318 encrypt(流式路径)
0x8aaeac 默认 key 构造(网络层,非资产层)
0x8ab094 add 循环(命名反转另一端)
0x8aa378 / 0x8aa4a4 待查:可能是真实加密核心
这一步执行过 pin_xxtea_alg.py、xxtea_disasm.txt 对应的反汇编探针、block_decrypt.txt / enc_dec_args.txt / common_ops.txt 的差分整理。0x852548 读取器的现场:
0x852554: and w0, w1, #3
0x852570: add w22, w22, w1, lsr #2 ; n = len/4 + (len%4 != 0)
0x8525bc: ldrb w3, [x21, x2] ; 逐字节
0x8525c0: ubfiz w5, w2, #3, #2 ; (i%4)*8
0x8525c8: lsl w3, w3, w5 ; 小端装配
0x8525d4: orr w3, w5, w3
0x8525d8: str w3, [x19, x4]
6.2 算法(从汇编精确重构)
rounds = 6 + 52 // n
DELTA = 0x9E3779B9 # 公开算法常数
sum = rounds * DELTA # 解密时递减至 0
每轮: e = (sum >> 2) & 3
p = n-1 .. 1:
ki = (p ^ e) & 3
MX = ((z ^ k[ki]) + (y ^ sum))
^ (((y >> 3) ^ (z << 4)) + ((y << 2) ^ (z >> 5)))
v[p] -= MX; y = v[p]
v[0]: ki = e & 3
MX0 = (((z >> 5) ^ (y << 2)) + ((z << 4) ^ (y >> 3)))
^ ((y ^ sum) + (z ^ k[ki]))
v[0] -= MX0
与标准 XXTEA 的差别:
├── MX 移位组合被改过
├── 加密时 z = v[n-1] 固定;解密时 z = v[p-1](非对称)
├── 0x61c88647 = -DELTA mod 2^32,用于实现 sum 递减
├── 密钥索引 ki = (p^e)&3(主循环),e&3(v[0])
└── 载荷长度 == 明文长度,无 +8 特征
6.3 默认 key 的位置与验证结果
0x8aaeac 附近
├── 存在一份由基串与 16 项偏移表构造的默认 key 常量
│ (值与构造细节略去,不披露)
├── 另有一份校验串
├── count1 = 16
└── setter @0x3dabac
穷举验证覆盖的分支:
key 前缀 6–16 位 ┐
补 0 / 补 ff │
倒序 ├── 偏移 0–35 ── 长度字校验 ── 全部失败
零 key │
文件内嵌 key │
字符串 key ┘
阶段笔记的定性:
默认 key 用 sub / add 两种循环都解不开资产文件
→ 资产 key 由脚本层作为第二参数传入
→ 当时列的后续五步:
1 找脚本层调用绑定函数时传入的 key
2 修复 launcher 主缓冲 0x4fa1 解析错位 → 完整 112 个子函数
3 补全 opcode 映射 → 反编译相关子函数确认调用参数
4 重启设备后取安装包资产
5 拿到 key 后按 add 循环解出 [数据字 + 长度字] 格式
这五步后来没有走通,原因在 TOP7 / TOP8 / 第二部 TOP20。
6.4 黄金对与配对失败
所谓「黄金对」
├── 一份结构 3574 B 的明文(parse_end=3574,文件其余为尾部数据)
├── 一份 3588 B 密文
└── 早期标注「有效」
后续更正:size 配对不可靠,184 个同 size 候选对全假
某 18525 B 密文不在捕获集 → 无确定同脚本明文/密文对
差分攻击的前提是「同一份脚本的明文和密文都在手」,这里没有。
6.5 验证与位级反推的函数体
6.1–6.4 是结论,这里补四个脚本的函数签名与判定式。它们都不依赖运行时,属于第一部的离线复算。
run_early_dd.py 的 check() 是最小验证器:给定一份 16 B 候选 key,跑完整解密循环,只比前 16 B:
def check(key16):
k = struct.unpack('<4I', key16)
v = list(struct.unpack('<%dI' % n, cdata))
rounds = 6 + 52 // n
sumv = (rounds * DELTA) & MASK
while sumv != 0:
e = sumv >> 2
y = v[0]
for p in range(n - 1, 0, -1):
z = v[p - 1]
ki = (p ^ e) & 3
mx = ((((z ^ k[ki]) + (y ^ sumv)) & MASK) ^
((((y >> 3) ^ ((z << 4) & MASK)) +
(((y << 2) & MASK) ^ (z >> 5))) & MASK)) & MASK
v[p] = (v[p] - mx) & MASK
y = v[p]
z = v[n - 1]
ki = e & 3
mx0 = (((((z >> 5) ^ ((y << 2) & MASK)) +
(((z << 4) & MASK) ^ (y >> 3))) & MASK) ^
(((y ^ sumv) + (z ^ k[ki])) & MASK)) & MASK
v[0] = (v[0] - mx0) & MASK
sumv = (sumv - DELTA) & MASK
return struct.pack('<%dI' % n, *v)[:16] == ref[:16]
xxtea_verify_pair.py 把方向也参数化:decrypt_sub(data, k) 与 encrypt_add(data, k) 各有减法版和加法版,再对「所有偏移 × 两个方向」做笛卡尔遍历,判据是结果是否以字节码头开头。md5_candidates.py 的 test_key(key, name) 把候选串统一编码后喂给同一对函数,用 84 B 小文件先做最快验证。
crypto_xxtea_bitcrack.py 的 solve_k(mx, z, s) 是位级 DP,不用求解器,按 32 位逐位推:
def solve_k(mx, z, s):
C1 = ((z >> 3) ^ ((z << 4) & MASK)) & MASK
C2 = ((z << 2) & MASK) ^ (z >> 5)
B = (z ^ s) & MASK
# 状态 (k_bits, c_a, c_b):c_a/c_b 是加法链的两路进位
cands = [(0, 0, 0)]
for i in range(32):
new = []
for kb, ca, cb in cands:
for ki in (0, 1):
A = zbits[i] ^ ki
ai = A ^ Bbits[i] ^ ca
ca2 = (A & Bbits[i]) | (A & ca) | (Bbits[i] & ca)
bi = C1b[i] ^ C2b[i] ^ cb
cb2 = (C1b[i] & C2b[i]) | (C1b[i] & cb) | (C2b[i] & cb)
if (ai ^ bi) == MXb[i]:
new.append((kb | (ki << i), ca2, cb2))
cands = new
if not cands: return None
return cands[0][0]
主循环对 p = n-1..1 逐个求 mx = (v_c[p] - v_p[p]) & MASK,用 ki = (p ^ e) & 3 把结果归入 4 个 key 字;同一 ki 出现两个不同值就记冲突,四个字集齐即停。
四类脚本的职责
├── check() 完整循环 + 前 16 B 比对(黄金对验证)
├── decrypt_sub / encrypt_add 方向 × 偏移遍历(实现自校验)
├── test_key() 候选串批量编码后快速筛(84 B 小样本)
└── solve_k() 逐位 DP 反推单个 key 字(首轮差分)
├── 输入:mx / z / sum
├── 每轮候选数受进位一致性剪枝
└── 输出:一个 32 位字或 None
位级 DP 的状态树
├── 位 i 的输入 z_i, B_i, C1_i, C2_i, MX_i, ca, cb
├── 枚举 k_i ∈ {0,1}
├── A_i = z_i ^ k_i
├── a_i = A_i ^ B_i ^ ca → ca' = majority(A_i, B_i, ca)
├── b_i = C1_i ^ C2_i ^ cb → cb' = majority(C1_i, C2_i, cb)
├── 保留条件:a_i ^ b_i == MX_i
└── 32 位后 cands[0] 即一个候选 key 字
注意:这条路线最终没能产出可用于解密资产的结果;脚本里「把反推结果写成文件」的部分本文不引用,也不披露任何候选值。它能留下的只有方法:把加法进位链拆成逐位状态,用一致性剪枝代替穷举。
TOP7 位级求解与 Z3 路线
7.1 工具递进
这一步执行的是一串递进脚本:crypto_xxtea_bitcrack.py / bitcrack2.py / bitcrack3.py(单方程单未知 32 位精确解)、crypto_xxtea_fwd.py(正向验证)、crypto_xxtea_search.py(组合搜索,阶段笔记特别点名)、crypto_xxtea_verify.py / verify2.py、crypto_xxtea_debug.py、crypto_xxtea_test2.py / test3.py / crypto_xxtea_var.py,以及 xxtea_z3v3.py、xxtea_z3v4_small.py、xxtea_z3v5.py、xxtea_z3v6.py。
单方程单未知
├── 位级求解可行 → 单测 5/5 通过
└── 联立后
├── 25 字 × 8 轮小文件单字约束 → 38 s 超时
├── 全链 / 零字窗口 → 全 unknown
├── 894 字全链 → 无望
├── 非 0 区 p=883 → 出现真实冲突
└── 反推易出「伪自治」 → 尾部 0 弱方程
→ 判定:数学路线死路;验证必须用非 0 明文区
7.2 xxtea_z3v6.py:约束模型
以下是该脚本的模型部分,输入文件路径与具体样本标识已略去:
# z3v6 诊断: 单字约束测模型速度与明文假设
# 结论判定: 1字 SAT(快) → 模型OK; UNSAT(快) → 明文假设错; 超时 → 实例本身难
CIPHER = '<某个密文样本>'
cipher = open(CIPHER, 'rb').read()
cdata = cipher[12:] # 跳过 12 B 容器头
n = len(cdata) // 4
rounds = 6 + 52 // n
v_c = list(struct.unpack('<%dI' % n, cdata))
MASK32 = 0xffffffff
DELTA = 0x9e3779b9 # 公开算法常数
sum0 = (rounds * DELTA) & MASK32
es = [((sum0 - r * DELTA) & MASK32) >> 2 & 3 for r in range(rounds)]
def solve(known_map, tag, timeout=30000):
k = [BitVec(f'k{i}', 32) for i in range(4)]
def pick(ki):
return If(ki == 0, k[0], If(ki == 1, k[1], If(ki == 2, k[2], k[3])))
def MX(z, y, sumv, ki):
t1 = (z ^ pick(ki)) + (y ^ sumv)
t2 = ((y >> 3) ^ LShR(z << 4, 0)) + ((y << 2) ^ LShR(z, 5))
return (t1 ^ t2) & 0xffffffff
def MX0(z, y, sumv, ki):
t1 = (LShR(z, 5) ^ (y << 2)) + ((z << 4) ^ LShR(y, 3))
t2 = (y ^ sumv) + (z ^ pick(ki))
return (t1 ^ t2) & 0xffffffff
v = [BitVecVal(x, 32) for x in v_c]
sumv = sum0
for r in range(rounds):
e = es[r]
y = v[0]
for p in range(n - 1, 0, -1):
z = v[p - 1]
ki = (p ^ e) & 3
v[p] = (v[p] - MX(z, y, sumv, ki)) & 0xffffffff
y = v[p]
z = v[n - 1]
ki = e & 3
v[0] = (v[0] - MX0(z, y, sumv, ki)) & 0xffffffff
sumv = (sumv - DELTA) & MASK32
s = Solver()
s.set(timeout=timeout)
for i, val in known_map.items():
s.add(v[i] == val)
res = s.check()
print(f'{tag}: {res}', flush=True)
if res == sat:
m = s.model()
key = b''.join(struct.pack('<I', m.eval(k[i]).as_long() & 0xffffffff)
for i in range(4))
return key
return None
# 四组诊断假设:尾部零字 / JSON 头 / 版本字段 / 前缀联合
solve({24: 0}, '诊断1: 尾部零字')
solve({0: 0x20200a7b}, '诊断2: JSON 起始')
solve({1: 0x72657622}, '诊断3: 版本字段')
solve({0: 0x20200a7b, 1: 0x72657622, 2: 0x6e6f6973, 3: 0x20203a22},
'诊断4: 前缀联合')
z3 约束模型
├── 未知量 k0..k3(4 × BitVec 32)= 16 B key
├── 已知量 v_c = 密文载荷按 u32 小端解出的字数组
├── 常量 DELTA / MASK32 / rounds / es 轮索引
├── 展开 rounds 轮,每轮 n-1 次 MX + 一次 MX0
├── 假设 known_map:令某个明文字等于猜测值
├── 判定 sat → 取 model;unsat → 假设错;超时 → 实例难
└── 四组诊断
├── 尾部零字(弱方程)
├── JSON 起始 '{' + 换行 + 空格
├── 版本字段 '"ver'
└── 前缀联合
LShR 与 >> 的区分是位级模型里容易出错的地方:>> 是算术右移,LShR 才是逻辑右移。脚本里 MX 与 MX0 的写法不完全对称,对应 TOP6 说的非对称变体。
注意:模型里出现的 DELTA、若干立即数与明文假设都是公开算法常数或格式猜测,不是密钥;真实密钥候选值一律不在本文出现。
7.3 判定死路的依据
判定依据
├── 约束求解器对随机函数反演不可行
├── 38 s 超时发生在「25 字 × 8 轮」的小实例上
├── 894 字全链更无望
├── 零字窗口出现伪自治(尾部 0 弱方程,任意 key 都满足)
└── 非 0 区 p=883 出现真实冲突 → 模型与真实算法/明文假设不一致
→ 不是算力问题,是缺少确定明文 + 算法变体未完全确认
TOP8 userext::Crypto 绑定链与命名反转
8.1 注册表与绑定链
Lua 绑定注册 @0x40cf7c
├── decryptStringWithKeyLua → 0x4095b0
├── encryptStringWithKeyLua → 0x408ddc
├── encryptXTEA → 0x3fc774
├── MD5FileCommon → 0x408fcc
├── encryptStringLua / decryptStringLua
├── encryptXTEALua / decryptXXTEALua
├── decryptXTEA / encodingBase64Lua
└── 函数名字符串区 @0xd08338–0xd083f0
0x4095b0 / 0x408ddc
└── 0x3e7xxx 封装
├── 0x8ab25c decrypt 流式路径
└── 0x8ab318 encrypt 流式路径
└── 默认 key 构造与 setter
这一步执行过 find_crypto_lua_reg.py、opcode_probe.py、decode_udid_fn.py、find_tstring_key.py、launcher_main_crypto.py、launcher_scan_crypto.py。
8.2 命名反转
decryptStringWithKeyLua → 0x4095b0 → 0x8ab25c → 0x8ab094 (add 循环)
encryptStringWithKeyLua → 0x408ddc → 0x8ab318 → 0x8aaeac (sub 循环)
游戏的「加密」做的是标准解密运算
游戏的「解密」做的是标准加密运算
→ 按函数名推语义会全反
8.3 诱饵与死循环
某处循环 target
├── target = (52 // n) * DELTA + 0xB54CDA56
├── 不是 DELTA 的整数倍
├── 按此条件运行会死循环
└── 笔记判定:疑似诱饵 / 反调试
笔记里两处把它写作不同地址(一处在加密核心附近,一处在 add 循环附近),指向同一类「非 DELTA 倍数」的构造。本文按各自原文保留,不合并成一个地址。
8.4 字符串池线索
某一段(launcher 的 Lua state,缓冲 @0x748)
├── 主函数 + 226 常量 + 112 子函数声明
├── 完整字符串池 392 个字符串
├── 缓冲 0x4fa1 后被堆对象打断
└── 关键串(仅列功能性名称)
userext / Crypto / getStringFromFile
容器魔数 / encryptString / string / open / write / close
→ 指向本地标识文件的加解密工具
笔记里留的两条待查:
├── 0x8aa378 / 0x8aa4a4(流式路径调用)可能是真实加密核心(非诱饵)
└── version 类文件的明文格式需从 launcher 反编译代码反推
这两条在现有材料里没有后续结论。
TOP9 魔改 Lua VM 指令格式还原
9.1 位域与取指现场
31 23 14 6 0
+---------+---------+------+------+---+
| C (9b) | B (9b) | A(8b)| op(6)|
+---------+---------+------+------+---+
|<------ Bx (18b) ------>|
|<------ sBx = Bx-131071 |
主循环
├── luaV_execute 入口 0x609098
├── 取指 0x6091d4 ldr w4,[x27]; and w19,w4,#0x3f
├── 取指循环 0x60933c
├── 格式表 0xcd3820 42 B
├── 跳转表 0xcd2c84 idx=op-3,2B 有符号 × 4
└── 跳转表基准 0x6092a0
这一步执行的是 vm_disasm_engine.py、vm_op_stats.py、pin_dispatch.py、scan_unknown_ops.py / scan_unknown_ops2.py,配套差分文本是 dispatch.txt、handlers.txt、common_ops.txt、unknown_ops.txt / unknown_ops2.txt。取指现场:
0x6091d4: ldr w4, [x27] ; 取 32 位指令
0x6091d8: and w19, w4, #0x3f ; op = v & 0x3f
0x6091dc: ubfx x7, x4, #6, #8 ; A = (v >> 6) & 0xff
0x609230: ldrb w6, [x24, x0] ; 格式表 @0xcd3820
0x609238: and w3, w6, #3 ; 低 2 位 = 模式
9.2 格式表与 NAMES 表
vm_disasm_engine.py 直接从主库里切出格式表(路径已略去),并自建 opcode 名表:
SO = open(SO_PATH, 'rb').read()
FMT = SO[0xcd3820:0xcd3820+42]
NAMES = {
0: 'LT?', 1: 'LE?', 2: 'TESTSET', 3: 'LOADBOOL',
4: 'CALL', 5: 'RETURN', 6: 'FORLOOP?', 7: 'MOVE',
8: 'FORPREP?', 9: 'CALLSETUP', 10: 'LOADIMM', 11: 'GETUPVAL?',
12: 'SETGLOBAL', 13: 'CLOSE?', 14: 'TEST', 15: 'TAILCALL?',
16: 'CONCAT2', 17: 'GETTABLE', 18: 'CONCAT?', 19: 'ADD?',
20: 'LOADK', 21: 'JMP', 22: 'EQ', 23: 'FORCOND?',
24: 'SUB?', 25: 'GETTABLE2', 26: 'SETUPVAL?', 27: 'MUL?',
28: 'LOADNIL?', 29: 'NOT?', 30: 'NEWTABLE', 31: 'LOADNIL2?',
32: 'DIV?', 33: 'SELF', 34: 'GETGLOBAL', 35: 'ARITH', 36: 'SETTABLEK',
37: 'VARARG?', 38..41: 'SPECIAL?',
}
for j, v in enumerate(code):
op = v & 0x3F; a = (v >> 6) & 0xFF
b2 = (v >> 14) & 0x1FF; c = (v >> 23) & 0x1FF
NAMES 里带 ? 的都是未确认语义,只按标准位置猜的。脚本头注释写「已确认 opcode: 4=CALL 17=GETTABLE 20=LOADK 30=RETURN 33=SELF 34=GETGLOBAL 36=LOADK2(双常量)」,与阶段笔记的 21/42 口径一致。
FMT[op] 位含义
├── bit0-1 模式 0=ABC / 1=ABx / 2=AsBx
├── bit2-3 f2 操作数校验子标志
├── bit4-5 f4 操作数校验子标志
└── bit6-7 前置分路
9.3 B/C 交换与实证
| op | 语义 | 实证 | 与标准 Lua 的差别 |
|---|---|---|---|
7 MOVE |
R[A] = R[C] |
B 恒 0;f2=0 校验 B==0 | 标准用 B |
17 GETTABLE |
R[A] = R[C][B] |
B=键 256+k 或寄存器,C=表;f2=3 | 标准相反 |
33 SELF |
与 GETTABLE 同族 | — | 同族 |
4 CALL |
fn=R[A], nargs=B+1, nresults=C-1 |
[319] A=35 B=2 C=4 → 3 参数调用;[39] B=0 → 1 参数 |
C=0 → multret |
20 LOADK |
R[A] = k[Bx] |
— | Bx 直接索引,无 -256 |
34 GETGLOBAL |
R[A] = global[k[Bx]] |
— | 同上 |
12 SETGLOBAL |
global[k[Bx]] = R[A] |
新确认(ABx) | 直接索引 |
36 SETTABLEK |
R[A][k[C-256]] <- R[B] |
C=283→'ctor'、284→'init' 方法名递增吻合 | C>=256 时是常量索引 |
0 LT |
R[B] < R[C],A=跳转极性 |
[283] A=0 B=33 C=339 → R33 < 0.0 |
B/C 常量感知 |
22 EQ |
R[B] == R[C],A=1 → 不等跳 |
— | B/C 常量感知 |
16 CONCAT2 |
R[A] = R[C] .. R[B] |
[306] R32=R32..后缀;[313] R32=R32..后缀;[323] 前缀..R32 |
二元拼接 |
14 TEST |
R[A] 真值;B=0 常规 |
— | — |
按差别归类
├── 寄存器来源改用 C MOVE / GETTABLE / SELF / CONCAT2
├── Bx 直接索引 LOADK / GETGLOBAL / SETGLOBAL / SETTABLEK
├── 参数编码改动 CALL 的 nargs/nresults
├── 比较极性在 A LT / EQ / TEST
└── 未定 op10 LOADIMM 疑似 R[A]=k[Bx] 或立即数
9.4 全局槽号方案
common_utils 主函数
├── sizek = 0 / sizep = 0 / debug 空
├── 结构 3574 B 自洽
└── 代码里到处引用「常量」→ 常规判定:解析错位
↓ 换假设
GETGLOBAL 的 Bx 不是常量索引,是全局槽号
└── 全局名字表 = launcher 常量表顺序
require=0 / cjson=1 / math=2 / ...
所有脚本共享
↓ 结果
子函数可读(isSupportAstc 一类逻辑被还原)
结构没解析错,是索引的命名空间理解错了。这一步执行的是 launcher_rev.py(阶段笔记称「黄金验证反编译器」)与 analyze_common_utils.py、rev_common_utils.py。
9.5 未标注 opcode
unknown_ops.txt 记主函数 928 条指令里未知 op 命中 17:
>>[ 25] SETGLOBAL A= 3 Bx= 13
>>[ 56] SETGLOBAL A= 4 Bx= 18
>>[277] LEN A= 32 B= 36 C= 35
>>[283] LT A= 0 B= 33 C=339 C=k2560.0
剩余 ~21 个 opcode
├── 算术细分
├── SETTABLE / SETLIST
├── CLOSURE / VARARG / TAILCALL
├── LT / LE 比较族
└── upval 相关
→ 需要更复杂的业务脚本做差分
9.6 分派现场逐条指令与 helper 分支
9.1 只给了取指那几行。把 dispatch.txt、helper_609030.txt、handlers.txt、common_ops.txt 四份反汇编文本对齐后,主循环的骨架是完整的。
取指与格式表查表(dispatch.txt):
0x6091d4: ldr w4, [x27] ; 取 32 位指令字
0x6091d8: and w19, w4, #0x3f ; op = v & 0x3f
0x6091dc: ubfx x7, x4, #6, #8 ; A = (v >> 6) & 0xff
0x6091e0: cmp w19, #0x25 ; op 上界 37
0x6091e4: b.hi #0x60915c ; 越界 → 统一出口
0x6091e8: cmp w7, w11 ; A 与寄存器上限比较
0x6091ec: b.ge #0x60915c
0x6091f0: add x0, x22, #0x73
0x6091f4: adrp x15, #0xcd3000
0x6091f8: add x24, x15, #0x820 ; 格式表基址 = 0xcd3820
0x609204: adrp x0, #0xcd2000
0x609208: add x0, x0, #0xc84 ; 跳转表 = 0xcd2c84
0x60921c: mov w0, w19 ; 用 op 作格式表下标
0x609230: ldrb w6, [x24, x0] ; FMT[op]
0x609238: and w3, w6, #3 ; 低 2 位 = 模式
0x60923c: cmp w3, #1
0x609244: b.eq #0x609378 ; ABx 分路
0x609248: cbz w3, #0x6095fc ; ABC 分路 → 调 helper
0x60924c: cmp w3, #2
0x609250: b.ne #0x6095f0 ; AsBx 分路
0x609030 是一个被主循环反复调用的操作数校验 helper,helper_609030.txt 里它是纯分支、无栈帧:
0x609030: cmp w3, #2
0x609034: b.eq #0x609074
0x609038: cmp w3, #3
0x60903c: b.eq #0x609058
0x609040: mov w0, #1
0x609044: cbz w3, #0x60904c
0x609048: ret
0x60904c: cmp w2, wzr
0x609050: cset w0, eq
0x609054: ret
0x609058: tbz w2, #8, #0x609084
0x60905c: ldr w0, [x0]
0x609060: and w2, w2, #0xfffffeff
0x609064: cmp w2, w0
0x609068: cset w0, ge
0x60906c: eor w0, w0, #1
0x609070: ret
0x609074: ldrb w0, [x1]
0x609078: cmp w2, w0
0x60907c: cset w0, lt
0x609080: ret
0x609084: ldrb w0, [x1]
0x609088: cmp w2, w0
0x60908c: cset w0, ge
0x609090: eor w0, w0, #1
0x609094: b #0x609070
common_ops.txt 记录了它在 ABC 分路里被连续调用两次,参数正好对应 FMT 的两个校验子字段:
0x609600: lsr w22, w4, #0x17 ; C = (v >> 23) & 0x1ff
0x609608: ubfx x3, x6, #4, #2 ; f4 = FMT[op] 的 bit4-5
0x609618: ubfx x28, x4, #0xe, #9 ; B = (v >> 14) & 0x1ff
0x609620: bl #0x609030 ; 第一次校验
0x609624: cbz w0, #0x60915c ; 不通过 → 统一出口
0x609638: ubfx x3, x6, #2, #2 ; f2 = FMT[op] 的 bit2-3
0x60963c: bl #0x609030 ; 第二次校验
0x60964c: cbnz w0, #0x609270 ; 通过 → 进入 handler
handlers.txt 里每个 handler 开头都是同一套边界检查,出错一律跳 0x60915c:
0x609460: cbz w22, #0x609470
0x609464: add w8, w7, w22
0x609468: cmp w8, w11
0x60946c: b.gt #0x6091b8 ; 目标寄存器越界
0x609470: sub w0, w28, #1
0x609474: cbz w28, #0x609668
0x609478: cbz w0, #0x609488
0x60947c: add w0, w7, w0
0x609480: cmp w0, w11
0x609484: b.gt #0x6091b8
0x609488: cmp w21, w7
0x60948c: b.ge #0x6093e0
0x609490: add w25, w25, #1
0x609494: b #0x60933c ; 回到取指循环
主循环调用链
├── 0x609098 luaV_execute 入口(开 0xb0 栈帧,保存 d8–d14 / x19–x24)
├── 0x6091d4 取指 + 提取 op / A
├── 0x609230 FMT[op] @0xcd3820(42 B)
│ ├── bit0-1 模式 0=ABC / 1=ABx / 2=AsBx
│ ├── bit2-3 f2 校验子
│ ├── bit4-5 f4 校验子
│ └── bit6-7 前置分路
├── 0x609030 helper:按 w3 分四种校验
│ ├── w3=0 判 w2 是否为 0
│ ├── w3=1 未走(由分路直接处理)
│ ├── w3=2 取 [x1] 单字节,比较 w2 < 该值
│ └── w3=3 按 w2 的 bit8 决定清位后比较 / 直接比较
├── 0x609270 分发到具体 handler
├── handler 统一先做寄存器边界检查
├── 0x60933c 取下一条指令
└── 0x60915c / 0x6091b8 两个统一错误出口
从位域到校验子的映射
├── 指令字 v
│ ├── v[5:0] → op → FMT 下标
│ ├── v[13:6] → A → 与寄存器上限 w11 比较
│ ├── v[22:14] → B → helper 的 w2 实参(ubfx #0xe,#9)
│ └── v[31:23] → C → lsr #0x17
└── FMT[op]
├── [1:0] → 三条分路
├── [3:2] → 第二次 helper 的 w3
└── [5:4] → 第一次 helper 的 w3
把 helper 单独认出来之后,9.2 那张「f2 / f4 操作数校验子」表才从猜测变成有指令依据的结论:f2=0 对应「B 必须为 0」,f2=3 对应「B 可作常量索引 256+k」,正是 helper 里 tbz w2,#8 与 and w2,#0xfffffeff 两条路径。
TOP10 反编译器与语义还原
10.1 工具职责分组
按职责分组(脚本名)
├── 反汇编 vm_disasm_engine.py(luac → .asm)
├── 伪代码 vm_pseudo_gen.py(luac → .lua_pseudo)
├── 镜像提取 vm_extract_mega_luac.py
├── opcode 统计 vm_op_stats.py
├── 反编译 v2 vm_rev_decompiler.py(require/class/字段识别)
├── 常量表还原 vm_table_restore.py
├── 黄金验证 launcher_rev.py(输出 18.7 KB 可读文本)
├── launcher 族 launcher_decode.py / launcher_consts.py /
│ launcher_all_fns.py / launcher_fn2*.py /
│ launcher_main_crypto.py / launcher_scan_crypto.py /
│ parse_launcher_raw.py / step_parse_launcher.py /
│ batch_launcher_test.py
├── 通用解析 loose_parser.py / proto_extract.py / proto_probe.py /
│ luac_sizes.py / luadump.py / mass_decrypt.py
└── 批量 batch_rev.py / rev_engine.py / batch_read.py
阶段笔记的「工具」一节列的正是前六项,另特别点名 crypto_xxtea_search.py 为组合搜索工具。
10.2 产出类型(按形态,不按目录)
├── 反汇编文本 每条指令一行,含 op/A/B/C/Bx
├── 伪代码 带寄存器编号的半结构化文本
├── 反编译输出 接近源码的 .rev.lua,识别 require / class / 字段
├── API 报告 模块 requires / class 名 / 字符串字段列表
├── 常量表还原 常量索引到值的对照
└── 字节码样本 从镜像切出的单个 luac
_API_REPORT.txt 的形态:
=== 某模块
requires(6): cjson / common/utils / 模块基类 / framework / downloader / 平台封装
class: ['ModuleManager']
字符串值/字段(11):
ctor, init, initFashionModule, getFileList, parseFileList,
getModuleConfig, parseModuleConfig, saveModuleConfig,
getReadyModuleFiles, getReadyModuleNames, canDownload
伪代码样例:
[ 0] GETGLOBAL R1 <- K0 ; "TJNetMgr"
[ 1] SELF R1 <- R1:method(K257("regMsgHandler"))
[ 2] GETGLOBAL R3 <- K2 ; "NetMsg"
[ 3] GETTABLE R3 <- R3[K259("CS_CMD_DEBUG")]
10.3 数字口径(不能横向相加)
| 数字 | 指的是 |
|---|---|
| 10,699 | 安装包内脚本密文数 |
| 10,950 | 资源分发侧全量拉取的密文脚本数(41.3 MB) |
| 8,055 | 另一容器头的资源数 |
| 1,703 | 设备侧落盘的加密脚本数 |
| 58,253 | 引擎符号表条目 |
| 10,326 | 明文分片数(153.3 MB) |
| 12,350 | 索引里的唯一资源路径数 |
| 73 / 32 | 反编译输出数 / 其中非零且 100% 通过反编译的数 |
| 432 / 374 | 阶段笔记里的「脚本反编译」/「全接口脚本」口径 |
| 21 / 42 | 已确认 / 全部 opcode |
| 928 | launcher 主函数指令数(8,608 B 明文 + 5 × 8,608 B 密文) |
| 1,888 B | 某配置脚本完整提取长度 |
├── 文件数 10,699 / 10,950 / 8,055 / 1,703
├── 落盘分片 10,326 / 12,350 路径 / 153.3 MB
├── 明文成果 73 / 32 非零 / 432 / 374 / 256 / 14 / 15
├── 结构规模 58,253 符号 / 21 of 42 opcode / 928 指令
└── 目录规模 28 文件 27.2 MB / 256 个全非零 / 73 个输出
注意 432/374 是另一条线上的统计口径,与这里的反编译产出不是同一批东西,不能横向相加。
10.4 表构造还原与三种输出形态
vm_table_restore.py 是针对「纯数据脚本」写的:这类脚本的顶层几乎全是 LOADK + NEWTABLE + SETTABLEK + RETURN,逐行反汇编反而看不出是个表,所以直接折叠成表字面量。
NAME = {4:'CALL', 5:'RETURN', 7:'MOVE', 9:'CALLSETUP', 10:'LOADIMM',
14:'TEST', 17:'GETTABLE', 20:'LOADK', 21:'JMP', 22:'EQ',
25:'GETTABLE2', 30:'NEWTABLE', 33:'SELF', 34:'GETGLOBAL',
35:'ARITH', 36:'SETTABLEK', 3:'LOADBOOL', ...}
def fmt_const(c):
if c is None: return 'nil'
if isinstance(c, bool): return 'true' if c else 'false'
if isinstance(c, float):
return repr(int(c)) if c == int(c) else repr(c)
if isinstance(c, str):
return repr(c.rstrip('\x00')) # 引擎字符串填充,剥尾部 \0
def fmt_code(code, consts):
for i, v in enumerate(code):
op = v & 0x3F; a = (v >> 6) & 0xFF
c = (v >> 14) & 0x1FF; b = (v >> 23) & 0x1FF
Bx = (v >> 14) & 0x3FFFF
if op == 20: ... R[a] = K[Bx] 常量值
elif op == 36: ... R[a][K[c]] = R[b]
elif op == 30: ... array=c+1, hash=b+1
elif op == 17: ... R[a] = R[b][R[c]]
gen_table 的做法是先跟踪寄存器,再折叠连续指令:
def gen_table(code, consts):
reg_val = {}
for v in code:
if (v & 0x3F) == 20: # LOADK → 记住寄存器里的常量
a = (v >> 6) & 0xFF
Bx = (v >> 14) & 0x3FFFF
reg_val[a] = consts[Bx] if Bx < len(consts) else None
def rval(b):
if b < 256:
return fmt_const(reg_val[b]) if b in reg_val else '<R%d>' % b
return fmt_const(consts[b - 256]) # b>=256 时是常量索引
# 遇到 NEWTABLE R[a],向后收集同一寄存器的 SETTABLEK,
# 直到遇到新的 NEWTABLE / RETURN / 非本表指令为止
注意这里 b < 256 判寄存器、b >= 256 判常量索引,与 9.3 表里 SETTABLEK 的 C=283 → 常量索引 是同一套编码。main() 对折不掉的指令保留 // [i] OP... A= B= C= 的注释行,不假装还原成功。
luadump.py 是标准对照组,RD 类把读操作封装成 u8 / i32 / u32 / dbl / str,read_func 产出统一的 node 字典:
node = {'src': src, 'line': linedef, 'lastline': lastline,
'nups': nups, 'nparams': numparams, 'maxstack': maxstack,
'k': [], 'insn': [], 'kids': [], 'upnames': []}
vm_pseudo_gen.py 的 walk_proto(p, depth, out) 在这之上按深度缩进,把常量表和指令流拼成伪代码文本。deep_crypto_scan.py 的 walk_proto 同构,只是把输出换成「搜某类调用点」。
三种输出形态
├── 逐行反汇编(vm_disasm_engine.py / luadump.py)
│ ├── 忠实、可复核
│ └── 读不出表结构与控制流意图
├── 表字面量(vm_table_restore.py)
│ ├── 只对纯数据脚本有效
│ ├── 输入:顶层 code + consts
│ └── 输出:{ [key] = value, ... } + 未折叠行的注释
└── 缩进伪代码(vm_pseudo_gen.py / 反编译器产出)
├── 按 Proto 深度递归
├── 常量池按名字排序便于对照
└── 不是可编译源码,笔记里明确标为「伪代码」
表构造折叠的判定链
├── 起点:op=30 NEWTABLE,目标寄存器 R[a]
├── 向后扫:op=36 SETTABLEK 且 A==a
│ ├── 键来自 K[c]
│ ├── 值来自 rval(b):寄存器跟踪值 / 常量 / 未知占位
│ └── 累加到 entries
├── 终点:新 NEWTABLE / RETURN / 其它打断指令
└── 输出:R[a] = { ... } (NEWTABLE),并把 i 跳到 j
10.3 里那些「不能横向相加」的数字,多数就是这三条管线各自跑出来的:同一个 luac 既可能产出一行反汇编,也可能产出一张表,还可能产出一段伪代码,计数口径不同。
TOP11 静态字节改写与可复核性
这一节只讲方法:如何在不运行目标的前提下改一个动态库,以及如何让改动可复核。不涉及改写目标函数清单、具体地址、字节与用途,也不提供任何验证流程。
11.1 改写流程
静态改写流程
├── ① 判定符号表可信度(TOP3)
│ └── 不可信 → 整条线放弃,不硬写
├── ② 逐点比对函数序言前 8 B
│ ├── 一致 → 覆写
│ └── 不一致 → 跳过并打印,绝不盲写
├── ③ 输出改写后副本(原件留底)
├── ④ 计算改写前后 SHA1
└── ⑤ 写 manifest:前后哈希 + 每点偏移 + 描述
第 ② 步是关键。这一步执行的是 patch_openssl.py,其结构(地址表与字节已略去):
# 输入/输出路径略去;PATCHES 为 (偏移, 期望序言, 描述) 三元组列表
PATCHES = [
(<偏移1>, <期望序言1>, <描述1>),
# ... 共 5 项,地址与字节本文不披露
]
PATCH_BYTES = bytes.fromhex('<8 字节,略去>')
def sha1(path):
h = hashlib.sha1()
with open(path, 'rb') as f:
for chunk in iter(lambda: f.read(1 << 20), b''):
h.update(chunk)
return h.hexdigest()
def main():
data = bytearray(open(SRC, 'rb').read())
orig_sha = sha1(SRC)
patched = []
for va, expect_hex, desc in PATCHES:
expect = bytes.fromhex(expect_hex)
if data[va:va+8] != expect:
print(f'[!] MISMATCH @0x{va:x}: ... (符号可能被混淆偏移, 跳过以保安全)')
continue
data[va:va+8] = PATCH_BYTES
patched.append((va, desc))
if not patched:
print('[x] 无有效 patch 点, 终止'); sys.exit(2)
open(DST, 'wb').write(data)
with open(MANIFEST, 'w') as f:
f.write(f'source_sha1: {orig_sha}\n')
f.write(f'patched_sha1: {sha1(DST)}\n')
f.write(f'patch_bytes: {PATCH_BYTES.hex()}\n')
for va, desc in patched:
f.write(f'0x{va:x}: {desc}\n')
manifest 的作用
├── 前后 SHA1 → 能判断改动范围、发现二次改动
├── 逐点偏移 + 描述 → 能定位改了什么
└── 不是「改好了」一句话 → 后来人可自行复核
记录结果:5 点序言比对全部一致,无 MISMATCH。另有 patch_libcocos2dlua.py 与 restore_libcocos2dlua.py 分别负责另一侧尝试与还原,原件留底。
11.2 为什么强调可复核性
静态改写的证据边界
├── 能证明:字节被改了、改在哪、改前是什么
├── 不能证明:改后运行起来会怎样
└── 原始标注:静态完成、动态未验证
_verify_integrity.py、readelf 类的复核手段只覆盖文件层面。运行有效性属于第二部 TOP22 的待办,本文不展开。
TOP12 补环境的边界与失效点
12.1 六条死路归档
阶段笔记有一节标题是「密钥路线终结结论(避免重复踩坑)」:
密钥路线终结
│
├── 数据层 ──────────────────────────────────────────────┐
│ 1 候选 key 其实是密文文件的文件名被误读 │
│ 某脚本里的 5 个 16 B hex 就是密文文件名 │
│ 12 密文 × 5 候选 × 2 模式 = 0 命中 │
│ 3 载荷长度 == 明文,无 +8 标准 XXTEA 特征 │
│ 4 size 配对不可靠,184 个同 size 候选对全假 │
│ 5 无确定同脚本明文/密文对 │
│
├── 运行时层 ────────────────────────────────────────────┤
│ 2 ARM 库静态偏移 hook 死路:冷启动 attach 0 CALL │
│ 代码经二进制翻译层执行,原地址不经过 │
│
└── 产出(转向后)──────────────────────────────────────┤
6 73 脚本明文反编译 + 219 明文 / 4248 密文(带 size 未配对)
key 未破 → 离线全量解密未达成
后续更新需重新抓取
第 2 条有日志原件(xxtea_core.log,值已泛化):
hooked <某核心地址>
hook fail <另一地址>: Error: unable to intercept function at <地址>
hook fail <另一地址>: ...
TOTAL HOOKED 1
xxtea_hook.js 按「基址 + 静态偏移」attach、从参数结构某个成员读 16 B 字段,思路是对的,问题在目标地址不在真实执行路径上。根因见第二部 TOP20。
12.2 失效点归类
补环境失效点
├── ① 运行时构造的数据拿不到 ─────────────────────────────┐
│ 资产 key 由脚本层作为第二参数传入 │
│ key 存运行时对象成员,非静态常量 │
│ → 静态挖 key 无解 │
│ │
├── ② 静态地址不等于执行地址 ─────────────────────────────┤
│ 二进制翻译缓存,静态偏移处原指令不命中 │
│ → 静态反汇编结论正确,但运行时不经过 │
│ │
├── ③ 符号层被系统性污染 ────────────────────────────────┤
│ st_value 偏移、OBJECT 值占位 │
│ → 需逐条反汇编反证(TOP3) │
│ │
├── ④ 静态改写无法自证有效 ──────────────────────────────┤
│ 逐点比对 + manifest 齐全,但未跑流量 │
│ → 标注「静态完成、动态未验证」 │
│ │
└── ⑤ 结构正确不等于语义正确 ────────────────────────────┤
luac 头标准、opcode 重排、全局槽号 ≠ 常量索引 │
→ 需运行时语义实证 │
12.3 客户端的三层静态防护(按观察口径转述)
├── ① 字符串表加密(API 名运行时动态解析)
├── ② 密钥存运行时对象成员,非静态常量
└── ③ 业务代码经翻译层执行(用户态静态地址失效)
→ 阶段笔记口径:静态突破不可行,路径已穷尽
补环境这一部的产出到此为止:格式、地址、排除表、反编译文本、可复核的静态改写。拿不到的东西必须换方法,这是第二部的起点。
12.4 离线加载基线:把「补环境」做成可测的东西
前面 12 节讲的都是「不运行、只解析」。同一次工作里还跑过一条字面意义上的补环境路线:用模拟器把动态库加载起来,缺什么依赖就补什么桩,看它能不能走到初始化。这部分结论全是环境层面的,不依赖设备。
这一步执行的是 unidbg 一侧的加载脚本,结果记成一张基线表:
| 项目 | 观测值 | 读法 |
|---|---|---|
| 主库体积 | 25,990,592 B | 与本地文件一致 |
| 加载 | 成功,base=0x12000000 |
基址由模拟器指定,可复算 |
| 耗时 / 段数 | 831 ms / 21 段内存 | 段数可和 PT_LOAD 对照 |
JNI_OnLoad |
成功 | 最外层入口通了 |
findSymbolByName(...) |
全部未找到 | 磁盘 .dynstr 是密文,解析出乱码名 |
| 真实代码执行验证 | ft_highpow2(1000)=512、(5000)=4096 |
用一个纯函数确认地址没算错 |
| 缺口 | init_array 未跑完 |
见下方缺桩清单 |
补环境加载步骤
├── ① 建 Android 模拟器实例,指定加载基址
├── ② 映射 ELF 的 PT_LOAD → 21 段内存
├── ③ 补 JNI / 系统库桩,触发 JNI_OnLoad
├── ④ 用 findSymbolByName 找导出 → 失败(名字是密文)
│ └── 反证:符号查找不可用,只能按静态偏移定位
├── ⑤ 按静态地址调一个纯函数做行为验证
│ └── 结果符合预期 → 基址 + 偏移的换算成立
└── ⑥ init_array 逐条执行 → 因缺桩中断
缺桩清单(按依赖归组)
├── 图形 GLESv2
├── 音频 FMOD
├── 加密库 openssl 的 COMP_* 系列
├── 数据结构 pqueue_*
└── 资源 AAssetManager
└── 后果:内存与磁盘仍 100% 相同,加载期自解密未触发
从这张表能得出的三条
├── 符号名不可用 ≠ 函数不在:地址仍可按 st_value / 偏移算
├── 缺桩清单本身就是产出:它说明初始化链路依赖哪些宿主能力
└── 「内存与磁盘一致」是可证伪的判据
└── 一旦 init_array 跑完,这个等式就不再成立
这一节和 TOP3 是互补的:TOP3 判断符号表能不能信,这里判断「不靠符号名,光靠地址能不能把库跑起来」。两者都指向同一个方法——先验可信度,再谈地址。
12.5 模拟器自检与翻译层观测
加载之前先做了一次自检,确认模拟器真的在执行目标指令集的指令,而不是空转:用 keystone 现场汇编一小段,交给 Unicorn 跑,检查返回值。
自检链
├── keystone 现场汇编 → 写入模拟内存
├── Unicorn 执行 → x0 = 100,expect = 100 → PASS
├── 加载 ELF:PT_LOAD = 3,base = 0x10000000
├── 执行 DT_INIT
│ ├── 宿主桩捕获到 mprotect 系统调用
│ │ └── nr=226 / addr=0x100E9000 / len=0x167000 / prot=7
│ └── 正常返回后跳到 base+0xB3D9E8
└── 结论:加载期代码确实被执行,页权限变更可被宿主侧观测
三种地址空间的换算
├── 静态偏移 ELF 里的 st_value / 段内偏移
├── 加载基址 模拟器或系统分配(0x10000000 / 0x12000000 / 设备侧基址)
├── 运行时 VA = 基址 + 静态偏移(同一翻译层内成立)
└── 文件偏移 = 段 p_offset + (VA - 段 p_vaddr)
为什么静态地址会"存在但不经过"
├── 目标库为 ARM 指令集,宿主为 x86_64
├── 经二进制翻译层执行,原始地址不是最终执行地址
├── 冷启动时某静态偏移处观测到 0 CALL
└── 结论:静态地址只能作候选,必须经运行时证据确认
这一条同时解释了 0.2 的环境参数、TOP20 的 A1 失败案例,以及 TOP15 里「模块内过滤不可靠」的反例:翻译层会把代码搬出原本的模块区间,base + offset 只在同一个地址空间内有效。
第二部 动调调试
定义
├── 输入是运行中的目标进程
├── 手段是系统接口(进程内存、映射表、文件 IO)与运行时插桩
├── 输出是运行时才存在的东西:明文缓冲、段清单、IO 序列、行为观察
└── 关键约束:注入越重、扫描越广,越容易触发运行时防护
方法分层(按侵入程度从低到高)
├── ① 零注入 读进程内存镜像,不加载任何 agent
├── ② 只读插桩 枚举模块/段、读缓冲、抓帧、记录 IO,不改行为
├── ③ 数据面插桩 挂分配/拷贝等数据函数,只观测不改写
└── ④ 代码面插桩 挂静态地址、改指令 —— 本项目判定为死路,未采用为成果
与第一部的关系
├── 第一部给地址、格式、过滤条件 → 第二部知道「该找什么」
├── 第二部给明文分片、段镜像、IO 日志 → 第一部有输入可算
└── 两边用同一批二进制互相验证
阶段笔记里有一份「动态成功案例标注」,口径写得很明确:只认「有落地产物 + 可复算证据」的案例;动态手段成功但无产物、或产物不可用的,统一进「部分成功 / 失败」并写明根因,不混算成功。证据强度分三级:S=产物可直接反编译/可读且规模可复算;A=通道验证成功但产出局部;B=仅通道自检。本部的 TOP14–TOP19 是 S 级,TOP20 是 A 级。
TOP13 运行环境与 attach 前置
13.1 前置条件
attach 前置
├── 模拟器已连、root shell 可用
├── 目标进程处于运行态
├── 另有一台保底实例,文档明确标注「不要启动 / 不要动」
├── 插桩框架与宿主驱动脚本分别就位
└── 落盘目录已确认可写(TOP16)
环境准备这一步执行过 adb_check.py / adb_pkgs.py / adb_probe.py / adb_disk.py(连接与磁盘检查)、install_game.py / start_game.py / observe_game.py(进程状态)、frida_check.py / frida_mods.py(框架与模块)、diag_attach.py / attach_now.py / fast_attach.py / fast_attach_ns2.py / fast_slot.py / slot_monitor.py(attach 时机)。
13.2 attach 时机纪律
笔记里记死的三条
├── attach 前必须重启插桩服务
├── 新进程首次 attach 必成功;attach 过就坏死,需重启
└── 冷启动(缓存缺失)才触发全量脚本解密
缓存存在时只加载启动必需的小脚本(4096 / 3512 / 896 B 反复出现)
缓存状态与捕获量
├── 缓存存在 → 少量启动脚本 → 抓不全
└── 清空缓存后冷启动 → 700+ 脚本全量解密 → 大量缓冲
└── 副作用:大脚本可达 MB 级,进程可能 OOM 被杀
已落盘文件不受影响
13.3 脚本驱动层
宿主侧有一批 run_*.py 负责把插桩脚本送进进程并回收产物,命名能看出各自的关注点:run_hook_stable.py / stable2.py(稳定性)、run_hook_race.py / race3.py(时序竞争)、run_hook_reload.py / reload2.py(重载)、run_hook_spawn.py / spawn2.py(启动时)、run_hook_fast.py / quick.py(快速)、run_hook_scan.py / scan2.py(扫描)、run_hook_ui.py / tap.py(界面触发)、run_early_dd.py / run_dd_moment.py / run_dd_trigger.py(抓取时机)。二十多个变体说明「时机」是这一部的主要变量。
13.4 驱动层与基址定位的函数级展开
13.3 列了二十多个 run_*.py,这里补它们共用的三个动作和参数。基址定位这一类脚本(slot_monitor.py 是代表)结构最清楚,路径与进程名均已略去:
def get_pid():
p = sh(['shell', 'su -c pidof <目标进程>']).strip()
for tok in p.split():
if tok.isdigit(): return tok
return None
def get_cocos_base(pid):
m = sh(['shell', 'su -c cat /proc/%s/maps' % pid])
for line in m.splitlines():
if '<主库>' in line and 'r--p' in line:
return line.split('-')[0] # 取该映射的起始地址
return None
def read_mem(pid, addr_hex, n):
# dd if=/proc/<pid>/mem bs=1 skip=$((0x<addr>)) count=<n> | xxd -p
r = sh(['shell', 'su -c "dd ... | xxd -p"'], t=30)
return r.replace('\n', '').strip()
主循环是轮询式的:每轮取 pid,发现新 pid 记一次,读到主库映射后记为「已加载」,再等一个固定窗口才继续。seen_pids 字典同时承担去重和计时两个作用。
run_early_dd.py 的 grab(pid, s, e, name, t=60) 把「按区间读」也封装了,按页取整后 dd,ROUNDS = 4 表示同一窗口重试四轮:
def grab(pid, s, e, name, t=60):
page, cnt = s >> 12, (e - s + 4095) >> 12
# dd if=/proc/<pid>/mem bs=4096 skip=page count=cnt → 设备临时文件 → pull
驱动层通用参数对照
├── 连接方式 设备序列号 / 端口 / root shell 开关
├── attach 方式 当前进程 attach / 启动期 spawn / 纯 dd 零注入
├── 超时 sh(args, t=120) 一类,逐命令可覆盖
├── 轮次 ROUNDS / for _ in range(60) / while 时间窗
├── 等待窗口 主库加载后 6 s / 60 s / 90 s 三档
├── 落盘 设备临时文件 → pull → 宿主输出目录
└── 日志 print + 同步写文件,每轮 flush
一次 attach 的调用链
├── 环境检查(连接 / 磁盘 / 模块列表)
├── 取 pid → 读 maps → 取模块基址
├── 判断时机(已加载?解密窗口?缓存状态?)
├── 送脚本进进程 / 或走 dd 读内存
├── 设备侧落盘 → 宿主回收
└── 计数与日志(新 pid / 命中数 / 失败数)
注意 13.2 那三条纪律里「新进程首次 attach 必成功」正对应这里的 seen_pids:第二次 attach 同一个 pid 不是新方法,而是已知会失败的路径,所以驱动层干脆用新 pid 作为一轮的起点。
TOP14 零注入内存取证
14.1 为什么先走零注入
侵入程度对照
├── 零注入读进程内存 → 不加载 agent → 未触发运行时防护
├── 进程内 agent + 定向观测 → 稳定
└── 进程内 agent + 全内存扫描 → 触发 watchdog(TOP21)
阶段笔记把「零注入」标成「先于插桩的取证主路径」,另一份 VM 状态笔记末尾也记了一行「内存抓取链路(已实测安全)」:读进程内存 → 镜像 + 段映射 → 提取字节码 → 反汇编。
14.2 dd_capture.py:按映射表挑段
这一步执行的是 dd_capture.py。路径与设备细节已略去,核心逻辑如下:
# 流程: 读 /proc/<PID>/maps → 挑候选 rw- 段 → 逐段 dd → pull → 本地扫字节码头
def sh(*a):
r = subprocess.run([ADB] + list(a), capture_output=True, text=True, timeout=120)
return r.stdout
# 1. maps
maps = sh('shell', 'su', '-c', f'cat /proc/{PID}/maps')
ranges = []
for line in maps.splitlines():
m = re.match(r'([0-9a-f]+)-([0-9a-f]+)\s+(rw-\S)\s+[0-9a-f]+\s+\S+\s+\d+\s+(.*)', line)
if not m:
continue
start = int(m.group(1), 16); end = int(m.group(2), 16)
size = end - start
path = m.group(4)
# 字节码缓冲的宿主: 空路径匿名段 + 分配器池;其它映射是噪声
if path == '' or path.startswith('[anon:'):
if 1 * 1024 * 1024 <= size <= 32 * 1024 * 1024:
ranges.append((start, end, size, path))
ranges.sort(key=lambda r: -r[2])
# 2. 逐段 dd
for i, (s, e, sz, p) in enumerate(ranges[:40]):
skip = s // 4096
count = (sz + 4095) // 4096
sh('shell', 'su', '-c',
f'dd if=/proc/{PID}/mem bs=4096 skip={skip} count={count} of=<设备临时文件> 2>/dev/null')
sh('pull', '<设备临时文件>', '<宿主输出>')
段筛选规则
├── 权限 rw-
├── 路径为空(匿名)或以分配器池标记开头
├── 大小 1 MB – 32 MB(整数幂附近,符合宿主特征)
├── 排除 jit / gralloc / 文件映射等噪声
├── 按大小降序,取前 40 段
└── 每页 4096 B,skip = start >> 12,count = ceil(size / 4096)
同族还执行过 dump_all_segs.py(全量抓剩余段,排除已抓名单)、win_dump.py、dump_mem.py、batch_read_mem.py、min_capture.py、round_capture.py、sweep_capture.py、extract_chunks.py、audit_chunks.py、chunk_xref.py。
dump_all_segs.py 里有一段等待逻辑,说明「时机」怎么控制(路径已略去):
pid = sh(['shell', 'pidof <目标进程>'])
if not pid.isdigit():
print('未运行, 启动...')
sh(['shell', 'monkey -p <目标进程> 1'])
for _ in range(60):
time.sleep(1)
pid = sh(['shell', 'pidof <目标进程>'])
if pid.isdigit(): break
# 等主库加载
for _ in range(60):
so = sh(['shell', f'cat /proc/{pid}/maps 2>/dev/null | grep -c <主库>'])
if so.isdigit() and int(so) > 0: break
time.sleep(1)
print('主库加载, 等 60s 脚本加载...')
time.sleep(60)
14.3 probe_segs.py:先探再抓
这一步执行的是 probe_segs.py,每段只取前 64 KB 探特征,命中才值得整段抓:
out = sh(['shell', f'su -c "cat /proc/{pid}/maps"'])
segs = []
for l in out.splitlines():
p = l.split()
if len(p) < 2: continue
s, e = p[0].split('-'); s, e = int(s, 16), int(e, 16)
if 'rw' not in p[1]: continue
if e - s < 0x10000: continue
segs.append((s, e, p[1]))
marks = []
if b'<容器魔数>' in chunk: marks.append('CIPHER')
if b'\x1bLuaQ' in chunk: marks.append('LUAC')
# 说明: 原脚本另有默认 key 常量的命中检测,该值本文不披露,故略去此行
探测规则
├── 只探 rw- 段,段长 ≥ 64 KB
├── 每段取前 16 页,管道输出 base64 后宿主侧解码
├── 标记:容器魔数 / 字节码头 /(默认 key 常量项,略)
├── 命中段写入 seg_hits_<pid>.txt
└── 结果:676 段映射 + 多轮 199 KB chunk
14.4 零注入的产物规模
S6 零注入进程内存 dump
├── 手段 不加载 agent,按映射表分 676 段读
├── 字符串 369,977 行 / 14.7 MB
├── 路径 21,462 行 / 1.2 MB
├── 段映射 676 段
├── 判据 路径清单与安装包内资源文件名比对,覆盖率可统计
└── 价值 全程零注入,不触发运行时防护
注意:笔记里另有一条更正——某些冷启动后 /proc/<pid>/mem 会整体返回 I/O error,此时纯 dd 路径不可用,需退回插桩读内存。这是「零注入」方法的边界,不是失败。
14.5 从 maps 行到落盘文件的字段流
把 14.2–14.4 串起来,是一次「读内存 → 落盘 → 建索引」的完整字段流。每一步的字段都能单独复核。
maps 行的四个捕获组(dd_capture.py)
├── group(1) 起始地址 → int(..., 16)
├── group(2) 结束地址 → size = end - start
├── group(3) 权限 rw- → 只要可写段
└── group(4) 映射路径 → 空串 / 分配器池标记才保留
├── 过滤:1 MB <= size <= 32 MB
├── 排序:按 size 降序,取前 40
└── 排除:jit / gralloc / 文件映射
页换算(整数运算,不依赖对齐假设)
├── skip = start >> 12
├── count = (size + 4095) >> 12
├── dd if=/proc/<pid>/mem bs=4096 skip=<skip> count=<count>
└── 设备临时文件 → adb pull → 宿主分片文件
probe_segs.py 在整段 dd 之前先探,每段只取前 16 页,经 base64 回传后宿主侧解码,命中三类标记之一才写入 seg_hits_<pid>.txt。harvest_all.py 则反过来在已落盘的 dump 里批量扫:
# 遍历所有 dump 文件,逐个 find 字节码头
i = 0
while True:
j = b.find(b'\x1bLua\x51', i)
if j < 0: break
try:
end = parse_proto_size(b, j + 12) # 结构自洽才算命中
except Exception:
i = j + 1; continue
src = read_source(b, j + 16)
write_chunk(outdir, src, b[j:end])
i = end
字段流全链
├── /proc/<pid>/maps 一行
│ └── (start, end, perm, path)
├── 段筛选 → (start, end, size)
├── 页换算 → (skip, count)
├── dd → 设备临时文件
├── pull → 宿主分片 .bin
├── 头搜索 / 结构校验 → (source, off, end)
├── 索引四元组 (文件名, 字节数, OK, source)
└── 反编译 → 伪代码 / 表字面量 → 归档(TOP19.5)
探测与全抓的分工
├── probe_segs.py 16 页 / 段,只判「有没有特征」
├── dd_capture.py 命中后按整段抓,前 40 段按大小排序
├── dump_all_segs.py 补抓剩余段,排除已抓名单
└── harvest_*.py 在宿主侧对已落盘文件做二次扫描
产物侧还有一次独立的完整性复验:全量清单记 11,301 个文件、6,610,145,662 B,全量 SHA256 复验 PASS;清单行数与文件数差 1,是清单文件自身。同一份笔记也指出清单里混入了版本控制目录的内部文件——作为交付材料需要清理,这属于工程治理,不影响技术结论。
TOP15 模块与段枚举
15.1 枚举内容
这一步执行的是 tb_tom_probe.js 一类的模块探测脚本,以及 list_mods.js / list_game_mods.js / list_data_mods.js / hook_maps.js / hook_maps2.js / probe_apis.py / scan_engines.py。
S5 模块 / 内存段枚举
├── 手段 Process.enumerateModules() + enumerateRanges('r--'|'rw-'|'r-x')
├── 结果 350 个模块
│ ├── 3541 个 r-- 段(约 5 GB)
│ ├── 1946 个 rw- 段
│ └── 358 个 r-x 段(其中 21 个 rwx)
├── 附带 全模块名 + 基址清单、按类型分类计数
└── 判据 与 /proc/<pid>/maps 交叉比对一致,基址可复算
15.2 为什么要交叉比对
交叉验证
├── 插桩框架读到的模块基址
├── 系统映射表读到的段区间
└── 两者一致 → 后续所有「基址 + 偏移」计算才有意义
阶段笔记里记了一个反例:某次 a.detail 显示 2042/3541 段(约 2.5 GB)集中在模块外,说明「模块内」这个过滤条件在翻译层环境下不可靠。这条观察后来直接影响 TOP20 里对静态偏移 hook 的判定。
15.3 模块基址与偏移的复算公式
15.2 说要交叉比对,这里把公式写全,并给出那个反例的完整读法。
三种地址
├── 静态偏移 off ELF: st_value / 段内偏移 / 格式表偏移
├── 段起始 base 设备 maps 或模拟器分配
├── 运行时 VA = base + off
├── 文件偏移 foff = 段 p_offset + (VA - 段 p_vaddr)
└── 反向 off = VA - base;落在哪个 PT_LOAD 由区间比较定
基址可信度检查
├── ① 插桩框架 enumerateModules() 给出模块基址
├── ② /proc/<pid>/maps 给出同名映射区间
├── ③ 两者一致 → 后续 base+off 可用
├── ④ 反汇编该地址看序言 → 与已知函数形状比对(TOP3)
└── ⑤ 任一环不一致 → 地址降级为「候选」,不能直接下结论
反例展开:某次按 a.detail 统计,2042 / 3541 个 r-- 段(约 2.5 GB)落在「模块外」。
"模块外"意味着什么
├── 翻译层把代码搬离原模块映射区
├── 以模块名为过滤条件的扫描会漏掉大部分可执行内容
├── enumerateRanges() 与 enumerateModules() 的口径不一致
└── 结论:过滤条件本身要按环境重写,不能沿用真机习惯
地址类失败的根因归类
├── 基址取错(不同实例 / 不同加载方式)
├── 偏移来自被污染的符号表
├── 静态地址不在真实执行路径(翻译层)
├── 冷启动与热启动地址不同
└── 把文件偏移当成虚拟地址用
前四条都能靠「先取基址、再验序言、最后交叉」这三步挡住,第五条是纯实现错误,所以在 vaddr_to_offset() 里专门写了区间比较而不是直接相减。
TOP16 落盘通道自检
在正式抓数据之前,先验证「agent 能写、宿主能收」这条路通不通。这一步执行的是 hook_onetime.js、hook_silent.js、dump_json.js / dump_json2.js 一类最小脚本,日志各自只有几十字节。
S9 短链通道自检(6/6 通过)
├── read 导出挂载生效
├── agent → 落盘通道可用
├── 静默模式(无 stdout)仍可落盘
├── 落盘目录定案(后续统一写该目录)
├── IO 挂载成功且不改行为(no-op 验证)
└── 30 秒观察窗口内无崩溃 / 无掉线
落盘纪律(笔记固化)
├── 所有 hook 一律先写确认过可写的私有目录
├── 单点 hook 耗时控制在首扫 30 s 内
├── 深扫区间设上限
└── 禁止全内存扫描(原因见 TOP21)
反例也留着:scan_magics2.log 有 535,569 条命中、SCAN-DONE 1 次,但 Not a directory 30 次——目录不可写,扫描全命中而分片全部落盘失败,ERR 计数为 0。扫描本身没错,是通道没验。
16.1 通道自检的六项判据
S9 那张「6/6 通过」的表,每一项对应一个最小脚本和一行固定输出。把判据展开:
六项判据
├── ① read 导出挂载生效
│ └── 判据:调用后能拿到返回值,且进程未崩
├── ② agent → 落盘通道可用
│ └── 判据:设备侧生成预期文件,宿主能 pull 到
├── ③ 静默模式仍可落盘
│ └── 输出:OK-SILENT(无 stdout,靠文件内容判定)
├── ④ 落盘目录定案
│ └── 判据:连续两轮写同一目录成功
├── ⑤ IO 挂载不改行为(no-op 验证)
│ └── 输出:OK-TEST,返回值与未挂载时一致
└── ⑥ 30 s 观察窗口内无崩溃 / 无掉线
└── 判据:进程存活 + 心跳未断
自检脚本的分工
├── hook_onetime.js 单次触发,验证「能挂上」
├── hook_silent.js 无 stdout,验证「静默也能写」
├── dump_json.js 结构化输出,验证「格式能落地」
└── frida_check.py 宿主侧检查连接与模块列表
16.2 失败日志的字段级读法
scan_magics2.log 是通道没验就开扫的反例,字段要分开看:
日志字段
├── ranges=243 扫描区间数
├── SCAN-DONE found=0 扫描自报的命中计数
├── ★MATCH <4B特征> @0x... range#1 单条命中(地址 + 区间号)
├── dump fail: Error: Not a directory 落盘失败
└── ERR 计数 = 0 框架层未报错
"命中数 ≠ 落盘数"的判读
├── 命中 535,569 条、SCAN-DONE 1 次 → 扫描逻辑本身跑完
├── Not a directory 30 次 → 目录不可写,分片全部落盘失败
├── ERR = 0 → 错误发生在写文件,不在扫描
└── 结论:先验证通道,再跑全量;否则算力全花在无法回收的结果上
16 节末尾那条「落盘纪律」就是从这个日志里固化出来的:所有 hook 先写确认过可写的私有目录、单点 hook 耗时控制在首扫 30 s 内、深扫设上限、禁止全内存扫描。
TOP17 IO 链路观测
17.1 观测内容
这一步执行的是挂 openat / read / pread64 的脚本,记录 fd、路径、偏移、长度,产物是一份 33,711 行 / 3.4 MB 的 IO 日志。
S4 IO 链路观测
├── 手段 挂文件打开与读取类系统调用,只记录不改行为
├── 产物 33,711 行 / 3.4 MB
├── 判据 完整还原某类资源的加载链,读到容器魔数
└── 价值 确定该资源的容器头与解压入口位置
资源加载链(抽象)
├── 临时文件(*.tmp 形态)
├── 打开 → 读取 → 定位偏移
├── 读到另一套容器魔数
└── 据此把「资源」与「脚本」两种格式彻底分开(对应 TOP4.1)
17.2 用户态明文命中
S3 readByteArray 同步读
├── 远端缓冲内命中一段中文业务串(环境标识,本文不披露具体内容)
├── 命中配置 JSON 的字段名与真实长度
└── 意义:证明解密后的配置缓冲内确有明文
反例 A4:recheck.log 全为 ERR / 零长度。拷贝源块在调用返回后即被释放,二次读取拿不到内容,必须在 onEnter 里同步读。这是时序问题,不是通道问题。
17.3 抓帧
S8 屏幕抓帧(7 张,1.1 ~ 2.6 MB)
├── 手段 挂图形交换缓冲回调
└── 用途 确认当时界面层级,判断抓取时机是否落在正确阶段
17.4 IO 日志的字段级解析
17.1–17.3 说的是观测内容,这里补日志本身长什么样。一份典型的系统调用跟踪,每行固定几个字段(路径与包名已略去):
字段
├── tid 线程号,用于把同一次读取的多行串起来
├── syscall read / openat / pread 等
├── fd 文件描述符(openat 的返回值在行尾)
├── buf 预览 前若干字节,转义显示,尾部带 ...
├── 请求长度 如 8192 / 16384
└── = 返回值 实际读到的字节数;0 表示读完
一次资源读取的调用序列
├── openat(<资源目录>/..., O_RDONLY) = <fd>
├── read(<fd>, "<4B容器头> u32=1 数据...", 8192) = 5695
├── read(<fd>, "", 2497) = 0
└── close / 下一次 openat
同一份日志里能读出的三件事
├── 资源容器头:4 B 标记 + u32 1,后接高熵数据
├── 分块方式:固定 8192 B 请求,尾部一次性读空
└── 路径形态:资源按类型分目录,文件名是哈希样式
└── 与 1.2 的「按版本清单逐文件取回」互为印证
用户态明文命中那一节(17.2)里,判据同样简单:read 返回的缓冲前几字节是字节码头,或者出现容器魔数字符串。日志的价值不在内容,在于它把「什么时候读、读了多少、读了几次」变成可数的量,内存里那些缓冲才有时间坐标。
TOP18 数据面 hook:memcpy → malloc
这一节是第二部的核心,也是第一部「静态走死」之后的转向。
18.1 问题重述
原问题:密钥是什么?
└── 静态侧已穷尽(TOP5 排除表 / TOP12 六条死路)
改问:脚本要执行,解密后的字节码缓冲必然在内存里存在过
└── 明文在哪一瞬间、哪一个缓冲里可读?
方案决策
├── ① 零注入读段 稳,未触发防护;抓到碎片,抓不全
├── ② memcpy hook 高频函数
│ → onLeave 时目标缓冲仍是密文;必崩 agent ── 弃
├── ③ ARM 库静态偏移 hook
│ → 冷启动 0 CALL(翻译层)── 弃
└── ④ malloc hook 低频,onLeave 得缓冲首址
→ 延时后读,解密已完成 ── 采用
18.2 Step 1:memcpy 侧密文捕获(S2)
这一步执行的是 hook_memcpy.js。原始代码(无敏感内容):
// Hook memcpy/memmove: 抓大块内存拷贝
var memcpy = Module.findGlobalExportByName('memcpy');
var memmove = Module.findGlobalExportByName('memmove');
var c = 0;
function hookMem(fn, name) {
if (!fn) { console.log('[mem] no ' + name); return; }
Interceptor.attach(fn, {
onEnter: function (args) {
this.dst = args[0];
this.src = args[1];
this.n = args[2].toInt32();
this.t = Date.now();
},
onLeave: function (ret) {
if (this.n > 500 && c++ < 200) {
console.log('[' + name + '] n=' + this.n + ' src=' + this.src +
' dst=' + this.dst + ' t=' + this.t);
try {
var b = this.src.readByteArray(Math.min(32, this.n));
if (b) {
var bytes = Array.prototype.slice.call(new Uint8Array(b));
var hex = bytes.map(function (x) {
return ('0' + x.toString(16)).slice(-2);
}).join('');
console.log(' src32: ' + hex);
}
} catch (e) {}
}
}
});
}
hookMem(memcpy, 'memcpy');
hookMem(memmove, 'memmove');
S2 密文捕获
├── 手段 挂拷贝函数,抓源指针指向的加密块,按长度过滤落盘
├── 产物 14+ 块,644 B ~ 39,808 B
├── 判据 与分配侧同名明文按 size + 尾部 padding 规律一一对应
└── 结论 加密层为 XXTEA 类,key 长度 16 B
关键观察(阶段笔记原文口径):
DST 在 memcpy onLeave 时仍是容器魔数(密文搬移,解密延迟 / 独立调用)
延时若干秒后:部分缓冲已出现明文结构,部分仍是容器魔数
★ 解密非原地:密文拷贝到目标后,解密输出在别处
这一条直接否掉了「继续盯拷贝目标缓冲」的思路,把落点转到「谁分配了输出缓冲」。
18.3 Step 2:改用分配点
这一步执行的是 hook_mallocsrc.js(最终版)与 hook_plain.js、hook_final_dump.js、hook_malloc2.js、hook_mallocf.js、hook_mallocfix.js、hook_malloc_pair.js、hook_alloc.js、hook_free.js、hook_capture.js / capture2.js 等一长串演进版本。最终版代码(私有目录已泛化):
// malloc hook + 8s dump + source 路径解析 + 上限 2500
var mallocPtr = Module.findGlobalExportByName('malloc');
var n = 0;
var dir = '<应用私有目录>';
var savedCount = 0;
function getSource(buf, sz) {
// Lua 5.1 main proto: 头12B + source string (size_t=8)
try {
if (sz < 20) return '';
var arr = new Uint8Array(buf);
if (arr[0] !== 0x1b || arr[1] !== 0x4c) return '';
var dv = new DataView(buf, 12, 8);
var len = Number(dv.getBigUint64(0, true));
if (len < 1 || len > 200) return '';
var s = '';
for (var i = 0; i < len && 20 + i < sz; i++) {
var c = arr[20 + i];
s += (c > 31 && c < 127) ? String.fromCharCode(c) : '?';
}
return s;
} catch (e) { return ''; }
}
Interceptor.attach(mallocPtr, {
onEnter: function (args) {
this.sz = args[0].toInt32();
},
onLeave: function (ret) {
var sz = this.sz;
if (sz > 500 && n < 2500) {
var p = ret, idx = n++;
setTimeout(function () {
try {
var head = p.readByteArray(8);
if (head) {
var b = Array.prototype.slice.call(new Uint8Array(head));
if (b[0] === 0x1b && b[1] === 0x4c) {
var src = getSource(p.readByteArray(Math.min(sz, 200)),
Math.min(sz, 200));
var full = p.readByteArray(sz);
if (full) {
var f = new File(dir + '/L_' + idx + '_' + sz + '.bin', 'w');
f.write(full);
f.close();
savedCount++;
console.log('★SAVED L_' + idx + '_' + sz + ' src=' + src);
}
}
}
} catch (e) {}
}, 8000);
}
}
});
判定条件链
├── malloc 返回
├── sz > 500 过滤小对象
├── n < 2500 限流
├── setTimeout 8000 ms 等解密完成
├── 读前 8 B,判 1b 4c 字节码头
├── getSource 解析 source 头 12 B + u64 长度 + 字符串
└── 整块写盘 L_<id>_<size>.bin
18.4 定时器位置(工程坑)
| 写法 | 结果 |
|---|---|
顶层 setInterval 轮询 |
失效 |
onLeave 内 setTimeout(5000) |
可用(capture2 验证) |
onLeave 内 setTimeout(8000) |
可靠(最终采用) |
| 长轮询 | 超时 |
原因归类
├── 顶层定时器与插桩回调的执行上下文不同
├── 长轮询超过观察窗口
└── 延时太短则解密未完成,缓冲里还是密文或半明文
18.5 方案对比
| 方案 | 频率 | 是否原地解密 | 稳定性 | 结论 |
|---|---|---|---|---|
| 零注入读段 | 一次性 | — | 稳,无注入 | 抓碎片,抓不全 |
memcpy hook |
极高 | 否 | 必崩 agent | 弃 |
| ARM 库静态偏移 hook | — | — | 0 CALL(翻译层) | 弃 |
malloc hook |
低 | 延时后读 | 稳 | 采用 |
18.6 分配点判定链的代码级展开
18.3 讲了为什么从 memcpy 换到 malloc,这里把换过去之后那段脚本逐层拆开。执行的是 hook_mallocsrc.js。
第一层是 source 名解析,利用的是「主 Proto 紧跟在 12 B 头后面」这个事实:
function getSource(buf, sz) {
if (sz < 20) return '';
var arr = new Uint8Array(buf);
if (arr[0] !== 0x1b || arr[1] !== 0x4c) return '';
var dv = new DataView(buf, 12, 8);
var len = Number(dv.getBigUint64(0, true)); // size_t = 8
if (len < 1 || len > 200) return '';
var s = '';
for (var i = 0; i < len && 20 + i < sz; i++) {
var c = arr[20 + i];
s += (c > 31 && c < 127) ? String.fromCharCode(c) : '?';
}
return s;
}
第二层是判定与落盘,注意所有条件都在 onLeave 里,且读内存被推迟到定时器里:
var mallocPtr = Module.findGlobalExportByName('malloc');
var n = 0, savedCount = 0;
Interceptor.attach(mallocPtr, {
onEnter: function (args) { this.sz = args[0].toInt32(); },
onLeave: function (ret) {
var sz = this.sz;
if (sz > 500 && n < 2500) {
var p = ret, idx = n++;
setTimeout(function () {
var head = p.readByteArray(8);
if (!head) return;
var b = new Uint8Array(head);
if (b[0] === 0x1b && b[1] === 0x4c) {
var src = getSource(p.readByteArray(Math.min(sz, 200)), Math.min(sz, 200));
var full = p.readByteArray(sz);
// 写 <目标私有目录>/L_<idx>_<sz>.bin
savedCount++;
}
}, 8000);
}
}
});
判定链(五道门)
├── ① size > 500 过滤小分配
├── ② n < 2500 总量上限,防洪水
├── ③ setTimeout 8000 ms 等解密写入完成再读
├── ④ 前 8 B 头 == 字节码头 只认明文字节码
├── ⑤ getSource 取 source 名 长度 1..200、可打印字符
└── 落盘:整块 readByteArray(sz) + 文件名带 idx 与 size
hook_final_dump.js 是同族的另一版,多两道限流:n > 4000(只处理大拷贝)、now - lastT > 200(每 200 ms 最多一个)、n < 300,延时后二次判头——先确认原位置已不再是密文态,才落盘。这解决的是 18.4 那个工程坑:解密写入可能晚于 onLeave 返回。
hook_memcpy.js 则是最朴素的对照实现:
function hookMem(fn, name) {
Interceptor.attach(fn, {
onEnter: function (args) {
this.dst = args[0]; this.src = args[1];
this.n = args[2].toInt32(); this.t = Date.now();
},
onLeave: function (ret) {
if (this.n > 500 && c++ < 200) {
// 打印 n / src / dst / t,再 dump 前 32 B 的 hex + ascii
}
}
});
}
hookMem(memcpy, 'memcpy');
hookMem(memmove, 'memmove');
三代脚本的条件差异
├── hook_memcpy.js n>500, c<200, 只打前 32 B
├── hook_plain.js 命中容器魔数后按 100 ms 轮询目标缓冲, 最多 20 次
├── hook_final_dump.js n>4000, 200 ms 限流, n<300, 8 s 后二次判头
└── hook_mallocsrc.js size>500, n<2500, 8 s 延时, 头 + source 双判据
└── 唯一能直接产出「带脚本名 + 全量字节」分片的版本
为什么 malloc 比 memcpy 稳
├── memcpy 是高频调用,逐次 readByteArray 会拖垮 agent
├── malloc 的返回指针天然是缓冲起点,不用判 dst / src 谁变明文
├── 分配大小直接给 sz,落盘长度不用另猜
└── 代价:必须延时读,取指与写入之间存在时间窗
注意:以上只描述「怎么判定一段内存是不是明文字节码」,容器魔数、私有目录与具体字节值一律用占位符表示,不给出可直接复用的完整脚本。
TOP19 明文落盘、回收与回灌
19.1 S1 的规模
S1 malloc hook → 明文脚本全量落盘
├── 手法 attach 分配函数,按 size 白名单在 onLeave 抓 buffer
│ 写入应用私有目录,宿主侧回收
├── 落地产物
│ ├── 10,326 个分片 / 153.3 MB
│ ├── 索引 JSON 133 KB
│ └── 唯一资源路径清单 12,350 条
├── 反编译产物
│ └── 73 个 .rev.lua / 8.0 MB(其中 41 个 0 字节 = 栈上零散拷贝)
├── 成功判据
│ ├── 分片用标准字节码反汇编全量通过
│ ├── 32 个非零条目反编译率 100%(32/32)
│ └── 三批同 size 分组命中同一脚本
└── 阶段笔记另一口径:73 / 73 luac 反编译成功
19.2 捕获到的脚本类型
@src/ 下的子树(按功能性归类)
├── data/ 配置、地图、音乐表
├── systems/ 各类系统模块(排行、商城、成长、结算等)
├── network/ 协议相关
├── sdk/ 平台封装
├── utils/ 通用工具
├── uiExtend/ UI 扩展
└── box2d/ 物理相关
阶段笔记里点过名的一个样例:某排行榜脚本解出 class('ClanRank', RankBase) 加 15 个方法;另有角色配置、字符串配置、协议定义、模块系统、队列结构等。
19.3 回灌第一部
分片 → 宿主侧
├── luac_sizes.py 按 size 分组、筛选
├── rev_engine.py / batch_rev.py 批量反编译
├── index_plains.py 建 JSON 索引
├── scan_all_luac.py 全量校验
└── vm_rev_decompiler.py / launcher_rev.py 按 TOP9 的 opcode 语义还原
↓
.rev.lua / _API_REPORT.txt / 常量表还原
↓
反过来验证 TOP9 的 opcode 结论(全局槽号、B/C 交换)
这就是两部的闭合:第一部给出「字节码头是 1b 4c」「source 在 +16」「全局槽号」这些判据,第二部才知道该抓什么、该怎么判;第二部的产物回来又证明这些判据是对的。
19.4 S7:内存中字节码结构现场
S7 结构还原
├── 某主脚本解出 928 条指令(8,608 B 明文 + 5 × 8,608 B 密文)
├── 某配置脚本 1,888 B 完整提取
├── 某角色配置反编译输出 215,830 B 可读
└── 产出存量:反编译输出 15 个全非零、批量输出 256 个全非零、常量表 14 个
19.5 回灌管线的三个函数体与分片口径
19.4 是两部交点,这里补宿主侧把它接住的三个脚本。
index_plains.py 先给每个分片判好坏,只解析 Proto 头的两个字段:
def parse_proto_head(b, pos=12):
src_len = struct.unpack_from('<I', b, pos)[0]
if src_len > 0x100000 or pos + 4 + src_len > len(b): return None
src = b[pos+4:pos+4+src_len]
pos += 4 + src_len
pos += 12
sc = struct.unpack_from('<I', b, pos)[0]
if sc > 0x1000000: return None
return src, sc
# main(): len(data) < 28 或头不符 → BROKEN
# 否则 → (相对名, 字节数, 'OK', source)
# json.dump 到 _src_index.json,最后打印 total / ok / broken
organize.py 从反编译文本里正则抠出 fn#0 '...' 里的源路径,去掉 @src/ 前缀后按目录层级重命名归档,同时生成索引:
m = re.search(r"fn#0 '([^']*)'", txt)
src = m.group(1) if m else ''
if src.startswith('@src/'):
rel = src[5:]
shutil.copy(f, os.path.join(DST, rel))
index.append((rel, os.path.getsize(f)))
else:
no_src.append((os.path.basename(f), src, len(txt)))
repack.py 是打包工具,unpack 用 zipfile.extractall,repack 遍历目录时把路径分隔符统一成正斜杠再 z.write,避免跨平台包名带反斜杠。
回灌管线
├── 动调落盘分片(L_<idx>_<sz>.bin / p_<idx>_<sz>.bin)
├── index_plains.py 头校验 → 四元组索引(含 BROKEN 标记)
├── 反编译器 逐行反汇编 / 表字面量 / 伪代码(TOP10.4)
├── organize.py 按 source 路径重命名 + 生成索引
├── repack.py 打包归档(路径正斜杠归一)
└── 第一部 离线格式分析、差分、语义还原
分片口径要按批次分开看,不同批不是同一批数据的不同副本:
捕获分片的分类(按落盘批次)
├── batch1 / batch2 / ls 73 / 51 / 73 个,均为完整字节码
├── f3 / f4 各 381 个,同一批抓取的两份结果
├── fc 3996+ 中仅 5 个是字节码,其余为加密数据或内存块
├── map 全部非字节码
└── 累计 1,218 个字节码 → 238 个唯一脚本
└── 重复来源:多次捕获、同一脚本多次加载
资源侧另有一组独立口径:解密后得到 1,082 张 PNG,索引 1,082 行,与实物逐一对应。它和上面的脚本分片不是同一条产线,不能相加。1.3 里那句「同一路径会重复出现多次」说的就是 f3/f4 与多次冷启动造成的重复。
TOP20 失败案例与根因
失败案例在「动态成功案例标注」里被单独列一节,标 A 级,写明根因,不当作成果。
20.1 A1:静态偏移直接 hook
A1 ARM 库静态偏移 hook
├── 手法 主库基址 + 0x8526a8 直接 attach
├── 日志 打印 ATTACHED 后 0 次调用
├── 根因 该库为 ARM 32 位,在 x86_64 模拟器上经二进制翻译层执行
│ 真实执行流走翻译缓存,静态偏移处原指令未被命中
│ 其余地址报 unable to intercept(翻译区非指令边界)
├── 附带 约 25 MB 的主库区未全部上膛;大量段集中在模块外
└── 修正方向(笔记原文,本文不展开)
① hook 导出符号而非静态偏移
② hook 翻译层分发点
③ 找翻译后的代码地址
④ 改走数据面(memcpy / malloc,已验证可行)
这条同时解释了第一部 TOP12 的第 ③ 类失效点:静态反汇编结论没错,但运行时不经过那个地址。
20.2 A2:全内存扫描
A2 全范围内存扫描
├── 手法 扫可执行段 + 逐页比对
├── 结果 首次存活约 30 s,深扫后被检测;第二次同样触发
├── 二次伤害 第二次扫描日志未回收到宿主(扫描线程被杀,文件未 flush)
└── 结论 存在运行时看门狗,全内存扫描属高危路径
→ 固化为纪律(TOP21)
20.3 A3 / A4 / A5
A3 扫描落盘通道故障
├── 535,569 条命中、SCAN-DONE 1 次
├── 目录不可写 30 次 → 全命中但分片落盘失败
└── ERR 计数 0(扫描本身无异常)
A4 缓冲已释放后复读
├── 二次读取全 ERR / 零长度
└── 必须 onEnter 同步读(TOP17.2 的 S3 即此写法)
A5 静态改写未动态验证
├── 逐点序言比对全部一致,manifest 齐全,原件留底
└── 标注「静态完成、动态未验证」
20.4 失败案例的分类
按根因分组
├── 环境层 翻译层导致静态地址失效(A1)
├── 防护层 看门狗导致扫描中断(A2)
├── 通道层 目录不可写(A3)
├── 时序层 缓冲生命周期(A4)
└── 证据层 静态改写未跑流量(A5)
五种根因互不相同。把它们分开记,比记一句「失败」有用:下次遇到同类现象能直接定位到层。
20.5 失败日志的字段级证据
20.1–20.4 是归纳,这里把归纳所依据的日志原样拆开。四份日志对应四类完全不同的失败。
xxtea_core.log / xxtea_core2.log(拦截层失败)
├── hooked <目标偏移> 成功 1 处
├── hook fail <偏移>: unable to intercept function at 0x4000216xxxxx
│ └── 同样格式 3 行,地址前缀一致(翻译层映射区)
└── TOTAL HOOKED 1
└── 读法:不是目标不存在,是这些地址不能被拦截
recheck.log(地址失效)
├── 0x72b5cf9e15f8:ERR 读不到
├── 0x72b5cf9e1abc:ERR
├── 0x72b5d04c30c0: 0000...0000(32 B 全零) 读到了但内容无效
└── 读法:指针有效性与内容有效性是两件事
silent.log / verify.log(通道可用)
├── OK-SILENT
└── OK-TEST
└── 读法:这两份只有一行,作用是证明上一类失败不是通道问题
unknown_ops.txt(语义未定)
├── >> 前缀标记未知 opcode 命中
├── 每条带指令序号、推测名、A / Bx / C 字段
└── 读法:结构解析成功,语义标注未完成
五类根因 → 对应日志字段
├── 拦截失败 unable to intercept / TOTAL HOOKED
├── 地址失效 :ERR / 全零内容
├── 通道不可写 Not a directory / WRITE-FAIL
├── 解析失败 BROKEN / 抛异常 / 残留字节
└── 语义误判 无引用 / 常量误报 / 候选 key 冲突
一次失败记录的必备字段
├── 目标(偏移 / 区间 / 文件名)
├── 手段(哪类 hook / 哪个脚本)
├── 观测值(返回码 / 前 N 字节 / 计数)
├── 判据(凭什么算失败)
└── 排除项(已经排掉的其他解释)
第五项是 20.4 那张分类表能成立的原因:没有「排除了什么」,一条失败日志无法区分「方法不对」和「目标不存在」。
TOP21 运行时防护观察与扫描纪律
本节只记防护的存在性与由此形成的研究纪律,不列检测项清单、不涉及任何规避方法。
21.1 观察结论
运行时防护(观察口径)
├── 存在进程级看门狗,对全内存扫描有反应
├── 反应形式:进程终止;不弹窗、不即时提示
├── 行为上报为累积式,判定可能延迟
└── 全量扫描与轻量定向观测的风险显著不同
内存面观察(三次,仅记结论)
├── 小词表扫描 1,741 段 / 7 关键词 → 0 命中
├── 扩词表扫描 1,816 段 / 17 关键词 → 0 命中
├── 大范围字符串 15 MB / 37 万行 → 仅配置与框架类字符串
└── 结论 未发现玩家数据的明文驻留
21.2 由观察固化的纪律
研究纪律
├── ① 以离线分析为主,动调只做定向观测
├── ② 单次观测控制在首扫时间窗内,深扫区间设上限
├── ③ 禁止全内存扫描
├── ④ 落盘前先验通道(TOP16)
├── ⑤ 使用独立的测试环境与消耗性账号,主账号不动
├── ⑥ 保底实例不启动
└── ⑦ 结论按「能证实 / 不能证实」分开写,不越线推断
第 ⑤⑥ 条是笔记里用实际代价换来的,本文只记录纪律本身,不讨论任何绕过方式。
21.3 三层静态防护(与第一部呼应)
TOP12.3 已在补环境侧列过,动调侧得到同一结论
├── 字符串表加密,API 名运行时动态解析
├── 密钥存运行时对象成员,非静态常量
└── 业务代码经翻译层执行
→ 两部独立地指向同一个判断:静态面已穷尽
TOP22 动态复测待办
以下都是原始报告自己列的待办,本文原样转述口径,不代为确认,也不展开执行步骤。
未完成的动态验证
├── ① 静态改写线
│ ├── 校验改写后哈希与 manifest 一致
│ ├── 确认 ELF 头未破坏
│ └── 运行有效性确认 —— 未标记完成
├── ② opcode 语义
│ └── 剩余约 21 个需更复杂业务脚本做差分
├── ③ 大脚本捕获
│ └── 需要更高内存配额,否则进程 OOM 被杀
├── ④ 特定系统脚本
│ └── 需进入特定业务流程才会加载
├── ⑤ 协议面
│ └── 需在特定活动时段观测
└── ⑥ 证据不足的现象
└── 单独归档,不推断、不下结论
证据边界(统一口径)
├── 静态论证完成 ≠ 动态实证完成
├── 通道打通 ≠ 产物可用
├── 现象存在 ≠ 影响可证实
└── 三者都要在结论里分开写
22.1 待办项的验收条件
TOP22 列的复测待办,如果只写「待做」,下次接手还是不知道做到什么算完。按项补上前置、观测点、判据和不做的部分:
| 待办 | 前置条件 | 观测点 | 判据 | 明确不做 |
|---|---|---|---|---|
| 静态改写的动态复测 | 改写前后文件与校验清单齐全 | 加载是否完成、序言是否与预期一致 | 前后哈希、文件大小、差异字节数三者可复核 | 不推导运行效果,不扩展改写范围 |
| 未标注 opcode 的差分 | 更复杂的业务脚本样本 | 同一 opcode 在不同上下文的取值分布 | 每个候选语义至少两处独立命中 | 不靠名称猜测直接定案 |
| 大脚本捕获的内存配额 | 冷启动全量解密窗口 | 分配大小与进程存活 | 落盘完整率与 OOM 次数可统计 | 不以牺牲进程稳定性换覆盖率 |
| 翻译层分发点定位 | 基址与段映射可复算 | 静态地址与实际执行路径的对应关系 | 至少一条地址换算是双向可验的 | 不改运行时代码 |
| 残留文件再判定 | 出现新的同批素材 | 对齐特征、结构性 magic | 有可复现的结构证据才重启 | 不再投入候选串穷举 |
待办的两类
├── 可离线闭环(差分、格式、校验清单)
│ └── 输入是文件,随时可复算
└── 依赖运行时状态(加载、配额、分发点)
├── 输入是某一次进程
└── 结论必须绑定该次环境参数
22.2 为什么把「未验证」写进结论
三层口径
├── 论证完成、实证未做 → 只写推理链,不写效果
├── 通道打通、产物不可用 → 只写通道判据,不写内容结论
└── 现象存在、影响未证实 → 只写观测值,不写定级
这样做的两个成本
├── 短期:结论看起来不够"漂亮"
└── 长期:接手的人知道哪些可以立刻用、哪些要先补一步
笔记里把静态改写的动态复测一直留在待办,没有用「理论上应当生效」把它划掉,就是这套口径的实际例子。
收尾
TOP23 未解决清单与方法
23.1 未解决
未解决
├── 加密 / VM ──────────────────────────────────────────┐
│ ├── 资产层密钥本体(静态无解,数学路线已判死, │
│ │ 动态路径经翻译层阻断) │
│ ├── 21 / 42 opcode 完整语义标注 │
│ ├── 伪代码 → 可编译脚本源码的完整反编译器 │
│ ├── 全量脚本离线解密 │
│ ├── 大文件常量表与字节码的关联 │
│ └── 需特定业务流程才加载的系统脚本 │
│ │
├── 二进制 ─────────────────────────────────────────────┤
│ └── 静态改写的动态复测(待办,未做) │
│ │
└── 运行时 ─────────────────────────────────────────────┤
├── 翻译层分发点的定位(笔记列为修正方向,未实施) │
└── 大脚本捕获的内存配额问题 │
23.2 三条方法
一、把「走不通」写成一等产出
├── 250 万窗口、320 万窗口
├── 38 s 超时、0 CALL、伪自洽
├── 文件名误读、184 个假配对
├── 五类失败根因分别归档
└── 排除表与成果表放在同等位置
二、先验可信度,再谈地址
├── 同一客户端两份静态 TLS 实现
│ ├── 一份符号明文可信
│ └── 一份 st_value 系统性偏移
├── 拿到符号先反汇编看序言,不匹配就跳过
└── 用 GOT / PLT / 字符串 xref 交叉证明「这个栈真的在用」
三、把「没做」「做不到」「证据不足」写进记录
├── 静态完成 / 动态未验证
├── 通道打通 / 产物不可用
├── 现象存在 / 影响未证实
└── 成本高于收益 → 主动放弃
第一条的起点是换问题:密钥拿不到时,不继续加算力,改问「明文必然在哪一瞬间出现过」。第二、三条的价值在于知道什么时候停。
23.3 数字口径逐项对照
全文出现过的数字分属四条产线,横向相加没有意义。按产线列全:
① 素材与完整性
├── 10,950 / 10,950 个脚本、41.3 MB 资源分发全量拉取
├── 8,055 个 res_high_new 另一类容器头的文件数
├── 11,300 行清单 / 约 6.61 GB 完整性清单
├── 11,301 文件 / 6,610,145,662 B 后续全量复验
└── 25,990,592 B 主库单文件体积
② 静态解析产出
├── 42 B 格式表 / 21 已确认 opcode 指令格式
├── 928 条指令 / 17 处未知 op 单脚本主函数
├── 39 个原型 / 24,703 B / 97 KB 反汇编 修正序列化后的样本
├── 31,497 隐藏符号 / 58,253 动态符号 符号层统计
├── 369,977 行字符串 / 21,462 行路径 零注入 dump 的文本提取
└── 1,218 个字节码 → 238 个唯一脚本 动调分片回灌结果
③ 运行时观测
├── 350 个模块 / 3541 r-- / 1946 rw- / 358 r-x 模块与段枚举
├── 676 段 / 多轮 199 KB chunk 零注入探测
├── 1,082 张 PNG / 1,082 行索引 资源明文产出
└── 6/6 通道自检通过 最小脚本
④ 排除成本
├── 250 万 / 320 万窗口 密钥搜索空间
├── 38 s 超时 约束求解
├── 0 CALL 冷启动静态偏移
├── 184 个假配对 / 556k 候选串 候选筛除
└── 23 个 8190 B 块 / 最长零游程 1 流密钥重用排除
口径冲突的三个常见来源
├── 同一批数据被抓两次(f3 / f4、多次冷启动)
├── 同一文件被三种管线各计一次(反汇编 / 表 / 伪代码)
└── 「文件数」与「唯一脚本数」混用
读任何一处数字时,先问它属于哪条产线、分母是什么,再看能不能和别处比较。
TOP24 函数与地址速查
以下地址均为原始笔记里的静态偏移或结构位置,转述用;不代表运行时虚拟地址,也不构成任何可执行流程。
24.1 主库(混淆壳版)
| 分类 | 函数 / 结构 | 地址 |
|---|---|---|
| 字节码加载 | luaU_undump |
0x676b80 |
| 字节码加载 | LoadFunction |
0x67657c |
| 字节码加载 | LoadInt / LoadBlock / LoadString |
0x676504 / 0x676428 / 0x676468 |
| VM | luaV_execute 入口 |
0x609098 |
| VM | 取指 | 0x6091d4 |
| VM | 取指循环 | 0x60933c |
| VM | 跳转表基准 | 0x6092a0 |
| VM | 格式表(42 B) | 0xcd3820 |
| VM | 跳转表(op3–37) | 0xcd2c84 |
| 加解密 | 解密包装器 | 0x85261c |
| 加解密 | 解密核心 | 0x8526a8 |
| 加解密 | 字节流读取器 | 0x852548 |
| 加解密 | 加密核心(诱饵) | 0x852804 |
| 加解密 | 流式 decrypt / encrypt | 0x8ab25c / 0x8ab318 |
| 加解密 | 默认 key 构造 | 0x8aaeac |
| 加解密 | add 循环 | 0x8ab094 |
| 加解密 | 待查流式调用 | 0x8aa378 / 0x8aa4a4 |
| 绑定 | Lua 注册入口 | 0x40cf7c |
| 绑定 | decryptStringWithKeyLua / encryptStringWithKeyLua |
0x4095b0 / 0x408ddc |
| 绑定 | encryptXTEA / MD5FileCommon |
0x3fc774 / 0x408fcc |
| 绑定 | key setter | 0x3dabac |
| 数据 | Crypto 函数名字符串区 | 0xd08338–0xd083f0 |
| 数据 | launcher 主缓冲(段内) | @0x748,0x4fa1 后被堆对象打断 |
| TLS(旧版) | 版本串 | 0xdc1960 |
| TLS(旧版) | 错误串 | 0xdebaa8 / 0xdc6508 / 0xdc64c0 / 0xdc6660 |
| TLS(旧版) | 错误串 xref 到达的桩区 | 0xbc9fb0–0xbca098 |
| TLS(旧版) | SSL_accept 表内地址(实为 case 尾部) |
0xc8d6cc |
| TLS(旧版) | BN_rand / RAND_poll 表内地址 |
0xbfd3ec / 0xc1ce5c |
| TLS(旧版) | ssl_ctrl 跳转表 / 公共 epilogue |
0xdeb068 / 0xc8d610 |
| TLS(旧版) | OBJECT 占位 | 0x157ee90 |
24.2 公开算法常数(非密钥)
| 名称 | 值 | 说明 |
|---|---|---|
DELTA |
0x9E3779B9 |
XXTEA 公开常数 |
-DELTA mod 2^32 |
0x61C88647 |
用于实现 sum 递减 |
| 循环诱饵常量 | 0xB54CDA56 |
出现在 target 表达式里 |
| 字节码头 | 1b 4c 75 61 51 00 |
Lua 5.1 标识 |
| 指令位域掩码 | 0x3f / 0xff / 0x1ff / 0x3ffff |
op / A / B,C / Bx |
本文不披露任何真实密钥、令牌、设备标识、业务密钥常量或具体网络端点。
24.3 结构体与字段速查
luac Proto
├── +0 source 长度 u32(含 \0)
├── +4 source 内容
├── +12 头内固定 12 B(版本/格式字段)
├── sizecode / code[]
├── sizek / TValue[]
├── sizep / 子 Proto[]
└── debug 段
指令字
├── bits 0–5 op
├── bits 6–13 A
├── bits 14–22 B(或 Bx 低 9 位)
├── bits 23–31 C(或 Bx 高 9 位)
└── Bx = v >> 14(18 位),sBx = Bx - 131071
容器头
├── +0 8 B 魔数
├── +8 4 B 文件专属字段
└── +12 密文载荷,n = ceil(len/4)
ELF64 Header
├── 0x28 e_shoff
├── 0x3a e_shentsize
├── 0x3c e_shnum
└── 0x3e e_shstrndx
24.4 汇编现场与定位指针补充
24.1 是主库函数表,这里补的是「反汇编现场里反复出现、但不构成函数调用目标」的位置,以及离线加载时用到的基址。
| 类别 | 位置 | 作用 |
|---|---|---|
| VM | 0x609030 |
操作数校验 helper,无栈帧、四种 w3 分支 |
| VM | 0x609460 |
handler 起始处的寄存器边界检查 |
| VM | 0x6095c4 / 0x6095fc |
ABC 分路,两次调用 helper |
| VM | 0x60915c / 0x6091b8 |
两个统一错误出口 |
| VM | 0xcd3000 + 0x820 |
adrp + add 形成的格式表基址 |
| VM | 0xcd2000 + 0xc84 |
跳转表基址 |
| ELF | 0x266000 |
GOT 区(另一份动态库) |
| ELF | 0x6be50 / 0x6c5d0 |
PLT stub,adrp + ldr + br |
| ELF | 0xd1000–0xd10e0 |
.data 函数指针表,槽位间隔 0x28 |
| 定位 | 0x65eb8c / 0x65e4d8 |
Lua C API 函数地址(定位方法见下) |
| 补环境 | 0x12000000 |
unidbg 加载基址,21 段内存 |
| 补环境 | 0x10000000 |
Unicorn 自检加载基址,PT_LOAD=3 |
| 补环境 | base + 0xB3D9E8 |
DT_INIT 返回后的跳转目标 |
函数定位的三重交叉(通用方法)
├── ① 明文串表还原 → 得到候选地址
├── ② 纯函数行为验证 → 地址对了才有预期返回值
└── ③ 打桩后语义变化 → 同一函数的行为随之改变
└── 三者一致才把地址标为「可用」,否则只算候选
ELF 结构指针的读法
├── R_AARCH64_GLOB_DAT (type 257) → 条目指向 .dynsym 索引
├── .data 连续函数指针,间隔 0x28 → vtable 形态
├── adrp + ldr + br 三件套 → PLT stub,不是本地函数
└── 文件偏移 = p_offset + (VA - p_vaddr)
以上地址均为原始笔记里的静态偏移或结构位置,转述用;不代表某一时刻的运行时虚拟地址,也不构成任何可执行流程。本文不披露任何真实密钥、令牌、设备标识、业务常量或网络端点。
TOP25 基础知识可补
按两部各补一块,再补一组容易踩的实现坑。
第一部 · 补环境
├── Lua 5.1 源码
│ ├── lundump.c Proto 序列化顺序、debug 三段
│ ├── lvm.c luaV_execute 取指 / 分派 / handler 形状
│ ├── lobject.h TValue / TString 布局、tt 编码
│ └── lopcodes.h 标准 opcode 顺序与 OpMode 格式表
├── ELF
│ ├── Program Header vs Section Header:加载器只认前者
│ ├── PT_DYNAMIC → DT_SYMTAB / DT_STRTAB / DT_HASH / DT_GNU_HASH
│ ├── Elf64_Sym 24 B 字段、st_value 的可信度
│ ├── GOT / PLT / 重定位类型(GLOB_DAT、JUMP_SLOT)
│ └── vaddr_to_offset 的区间换算
├── 指令集
│ ├── AArch64:adrp + ldr + br、ubfx、cset、tbz
│ ├── ARM32 与 x86_64 宿主之间的二进制翻译层
│ └── OLLVM 平坦化的 dispatcher 形状(cmp 状态常量 + movk)
├── 密码学实现
│ ├── XXTEA 原始实现与常见变体的 MX 移位组合
│ ├── 加法进位链的逐位 DP 建模
│ └── 约束求解器里算术右移与逻辑右移的区别
└── 可复核性
├── 前后哈希 / manifest / 差异字节数
└── 「静态完成」与「动态验证」的口径分离
第二部 · 动调
├── 进程内存
│ ├── /proc/<pid>/maps 的权限、路径、匿名段
│ ├── /proc/<pid>/mem 的页对齐读取
│ ├── 分配器池与 jit / gralloc 噪声的区分
│ └── 冷启动才触发全量解密的缓存行为
├── attach 时机
│ ├── 新进程首次 attach 与重复 attach 的差异
│ ├── spawn / attach / 纯 dd 三种侵入程度
│ └── 解密写入晚于函数返回 → 延时读的必要性
├── 观测与限流
│ ├── 高频函数逐次读内存的代价
│ ├── 大小阈值 / 计数上限 / 时间间隔三层限流
│ └── 先探后抓:16 页采样 → 命中才整段
└── 落盘与回收
├── 通道自检先于全量扫描
├── 命中数 ≠ 落盘数
└── 索引、去重与归档
常见实现坑 → 对应章节
├── 把 st_value 当运行时地址 → TOP3 / TOP15.3
├── 把文件偏移当虚拟地址 → TOP2.4
├── 节头表被填假仍照单全收 → TOP2.4
├── 常量搜到就认定是算法实现 → TOP5.4
├── lineinfo 按 u8 步进 → TOP4.6
├── 标准 OPS 表直接套魔改字节码 → TOP4.3 / TOP9.2
├── "无 xref" 其实是扫描阈值过严 → TOP2.5
├── onLeave 里立刻读目标缓冲 → TOP18.4 / 18.6
├── 没验目录就开全量扫描 → TOP16.2
└── 把不同批次的数字相加 → TOP23.3
建议的阅读顺序
├── 只想看格式:TOP2 → TOP4 → TOP9 → TOP10
├── 只想看调试方法:TOP13 → TOP14 → TOP16 → TOP18 → TOP19
├── 只想看排除法:TOP5 → TOP7 → TOP12 → TOP20 → TOP23
└── 查具体地址:TOP24 → 对应章节的函数体
再次说明范围:本文只记录格式分析与调试方法,不含漏洞内容、接口清单、请求参数、定级结论或修复建议;不披露任何密钥与真实端点;不提供针对在线游戏的规避、注入、修改或反作弊对抗流程。所有涉及商业客户端的名称、包名、域名、路径与业务标识均已脱敏,相关研究应在授权范围内进行。文中内容未经验证或复现,以原始笔记为准;会话记录仅取格式与调试方法层面的内容,其余部分未纳入。
d5eK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6y4j5h3y4Z5j5h3)9I4y4o6M7J5y4e0S2Q4x3X3c8E0j5i4S2Q4x3V1k6E0K9r3I4K6
f89K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6y4j5h3y4Z5j5h3)9I4y4o6M7J5y4e0S2Q4x3X3c8E0j5i4S2Q4x3V1k6E0K9r3I4K6x3b7`.`.
c85K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6y4j5h3y4Z5j5h3)9I4y4o6M7J5y4e0S2Q4x3X3c8E0j5i4S2Q4x3V1k6E0K9r3I4K6x3H3`.`.
d78K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6y4j5h3y4Z5j5h3)9I4y4o6M7J5y4e0S2Q4x3X3c8E0j5i4S2Q4x3V1k6E0K9r3I4K6x3R3`.`.
[招生]科锐逆向工程师培训(2026年11月13日实地,远程教学同时开班, 第57期)