首页
社区
课程
招聘
[原创]网易某某老鼠逆向记录 —— 补环境调试与动调调试
发表于: 4天前 726

[原创]网易某某老鼠逆向记录 —— 补环境调试与动调调试

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期)

收藏
点赞 ・1
打赏
分享
最新回复 (0)
游客
登录 | 注册 方可回帖
返回