//*梦-Blog

2026腾讯游戏安全技术竞赛-安卓客户端安全-初赛 Writeup

2026-04-16T04:32:00.000Z

前言

拿到题目也是懵逼了，腾子你怎么换引擎了今年，那我复现的往年那么多 UE4 算什么(T_T)

只能硬着头皮做了。

担惊受怕两天也是如愿所偿，进决赛了/(ㄒoㄒ)/~~，希望决赛能好好发挥，佬们轻点打！！

`*.gdc` 文件解密分析

寻找核心加密代码

上来直接解压看到 lib/ 中有libgodot_android.so ,确定是 Godot 引擎。

同时在 assets/ 中看到有 .gdc 的 GDScript 字节码，查看他的文件头发现不是标准的 GDSC 开头

既然如此，那就直接开始在 libgodot_android.so 里找怎么解密这些 .gdc 文件

网上找了很多，也试了很多常见的字符串搜索，如 open_encrypted 是加密文件打开的方法名、open_encrypted_with_pass 是带密码的加密打开的方法名，但向上对他们进行交叉引用只招到了一些 Godot 方法注册

最后搜索的是 PackedSourcePCK ，这个是 PCK 包读取器的 RTTI 名，定位到

前面的15是指字符串 PackedSourcePCK 的长度，往上找交叉引用，

在这里我们找到了 PackedSourcePCK 类的虚函数表，当进入函数 sub_3804C2C 时，完全可以确定就是这里了

这里明显都是在做 PCK 文件头校验，这里代码太多太乱了，交给 ai，以下两个函数分析来自 GPT5.4 结合 idapro mcp进行的分析

`sub_3804C2C` 函数分析

在 `sub_3804C2C` 中，`0x3804F08` 处有一个关键条件判断

1
2
3

v36 = (*(__int64 (__fastcall **)(_QWORD *))(*a17 + 360LL))(a17);
if ( (v31 & 1) == 0 )
    goto LABEL_71;  // 不加密，直接读文件列表

当 v31 & 1 为 1 时，代码不会跳转，而是继续往下执行加密处理路径。这里的 v31 来自 PCK 文件头中的 flags 字段，bit 0 标志”是否加密”。

加密分支的关键代码段 (0x3804F10 ~ 0x3804F78)

当进入加密分支后，汇编如下：

; --- 0x3804F10: 保存上下文，准备分配密钥缓冲 ---
3804F10  STR   X26, [SP, #0x10]
3804F14  STUR  XZR, [X29, #-0x28]        ; 初始化 FileAccessEncrypted 指针为 NULL
3804F18  BL    sub_37DAC48               ; 创建 FileAccessEncrypted 对象

; --- 0x3804F28: 分配 32 字节缓冲区 ---
3804F28  MOV   W1, #0x20                 ; 0x20 = 32，要求 32 字节
3804F34  BL    sub_107CBA4               ; 内存分配/扩容函数

; --- 0x3804F40 ~ 0x3804F74: 逐字节复制密钥！ ---
3804F40  ADRP  X26, #0x4004000           ; 加载页地址
3804F44  MOV   X27, XZR                  ; 循环计数器 i = 0
3804F48  LDR   X26, [X26, #0x488]        ; 从 GOT 加载实际地址 → X26 = 0x400EDF0

; 循环开始：
3804F4C  LDUR  X1, [X8, #-8]             ; 读取缓冲区当前大小
3804F50  CMP   X1, X27                   ; if (i >= size) break
3804F54  B.LE  loc_3804F78               ;

3804F58  LDRB  W28, [X26, X27]           ; ★ W28 = byte_400EDF0[i] ← 读取密钥字节！
3804F5C  ADD   X0, X25, #8
3804F60  BL    sub_107CBA4               ; 确保缓冲区大小足够
3804F64  LDUR  X8, [X29, #-0x10]
3804F68  STRB  W28, [X8, X27]            ; ★ key_buf[i] = 密钥字节
3804F6C  ADD   X27, X27, #1              ; i++
3804F70  LDUR  X8, [X29, #-0x10]
3804F74  CBNZ  X8, loc_3804F4C           ; 继续循环

关键发现：密钥地址 0x400EDF0

上面的汇编可以清晰看到：

ADRP X26, #0x4004000 + LDR X26, [X26, #0x488]：通过 GOT 间接加载，实际读取的是地址 0x4004488 处存储的指针。
GOT 表 0x4004488 处存储的值：
1
0x4004488: F0 ED 00 04 00 00 00 00
即 0x000000000400EDF0，确认 X26 最终指向 0x400EDF0。
LDRB W28, [X26, X27]：从 0x400EDF0 + i 读一个字节。
STRB W28, [X8, X27]：写入密钥缓冲区 key_buf[i]。
循环 32 次（因为前面分配了 32 字节）。

在 IDA 中直接提取密钥，导出十六进制：

1 2	CE 4D F8 75 3B 59 A5 A3 9A DE 58 AC 07 EF 94 7A 3D A3 9F 2A F7 5E 32 84 D5 12 17 C0 4D 49 A0 61

即密钥十六进制表示：

1	ce4df8753b59a5a39ade58ac07ef947a3da39f2af75e3284d51217c04d49a061

为什么可以确认这是 AES 密钥而不是其他数据

证据链：

(1) 上下文：这段代码在 sub_3804C2C（PCK 包打开函数）中，且只在”加密标志为 1”时才执行。

(2) 长度：恰好 32 字节 = 256 bit，这是 AES-256 的标准密钥长度。

(3) 去向：复制完成后，密钥缓冲传给了 sub_3801410（见下一节），而 sub_3801410 会验证密钥长度 必须是 32：

// sub_3801410 @ 0x3801450:
v16 = *(_QWORD *)(a3 + 8);
if ( !v16 || *(_QWORD *)(v16 - 8) != 32LL )
    goto LABEL_41;  // 报错返回

(4) 复用：同一个 byte_400EDF0 在另一条路径 sub_3805EDC（0x38061B0）中也被使用，用途相同——传给 sub_3801410 做加密文件初始化。

(5) 最终：sub_3801410 内部会将这 32 字节传给 AES key schedule 函数 sub_197C210，而 sub_197C210 在 a3 == 256 时设置 *a1 = 14（AES-256 的 14 轮），进一步确认这是 AES-256 密钥。

`0x3801410` 函数分析

在 sub_3804C2C 的 0x3804FB0 处：

1	v42 = sub_3801410(v41, &a15, &a18, 0LL, 0LL, &a13);

其中：

v41 = FileAccessEncrypted 对象
&a15 = 底层文件访问对象指针（用于读取原始加密文件）
&a18 = 密钥缓冲区

sub_3801410 就是 FileAccessEncrypted 的初始化/打开函数。

反编译 sub_3801410 的关键段

在 sub_3801410 中，当 a4 == 0（打开模式 = 读取）时，执行以下步骤：

步骤 1：验证密钥长度

// @ 0x3801450
v16 = *(_QWORD *)(a3 + 8);                    // 取密钥缓冲区指针
if ( !v16 || *(_QWORD *)(v16 - 8) != 32LL )   // 检查长度是否为 32
    goto LABEL_41;                              // 不是 32 则报错

步骤 2：（可选）检查 `GDEC` magic

1
2
3

// @ 0x380170C
if ( *(_BYTE *)(a1 + 417) &&                   // 如果设置了加密标志
     (vf_360)(a2) != 1128612935 )               // 读取 4 字节 magic

1128612935 = 0x43454447，字节序转换为 ASCII = "GDEC"。

注意：这个 GDEC magic 检查只在某些模式下触发。在本题样本中，加密文件直接以 MD5 开头，没有 GDEC 前缀——也就是说我们分析的文件走的是不带 GDEC magic 的那条路径。

步骤 3：读取文件头字段

// @ 0x3801724
(vf_408)(a2, &a14, 16);                        // ★ 读取 16 字节 → MD5 摘要
v42 = (vf_368)(a2);                             // ★ 读取 8 字节 → 明文长度（uint64 小端）
*(_QWORD *)(a1 + 384) = v42;                   // 保存到对象的 plain_len 字段

// 紧接着读 IV：
// 读取 16 字节到 a1+336 所指的缓冲区
(vf_408)(v44, *(_QWORD *)(a1 + 336), 16);      // ★ 读取 16 字节 → IV

步骤 4：读取密文

// @ 0x38017C0 ~ 0x38017D4
v47 = *(_QWORD *)(a1 + 384);                   // plain_len
v49 = v47 + 15;
v50 = v49 & 0xFFFFFFFFFFFFFFF0LL;              // ★ align_up(plain_len, 16)
// ...
(vf_408)(v53, *(_QWORD *)(a1 + 400), v50);     // 读取 v50 字节密文

步骤 5：设置 AES 上下文 & 解密

sub_376EDA0(&a12);                              // AES 上下文结构体初始化（分配 0x120 字节）
sub_376EDFC(&a12, key, 256);                    // AES key schedule 设置（256 = AES-256）
// ...
sub_376EF68(&a12, v50, iv, ciphertext, output); // ★ 解密！（调用 sub_197DE18 with a2=0）
sub_376EDD0(&a12);                              // AES 上下文清理/释放

其中 sub_376EDFC 内部调用了 sub_197C210（key expansion），sub_376EF68 内部调用了 sub_197DE18（核心解密循环），参数 W1 = 0 表示解密模式。

步骤 6：MD5 校验

// @ 0x3801A2C ~ 0x3801A54
sub_3CB453C(&a11, &a12);                        // 计算解密后明文的 MD5
sub_3CB453C(&a10, &a14);                        // 包装文件头中的 MD5
v68 = sub_3CADE58(&a11, &a10);                  // 比较两个 MD5
if ( (v68 & 1) != 0 )                           // 不匹配
    return 16LL;                                // 返回错误码 16

还原出的文件头结构

综合以上分析，加密资源文件的格式为：

偏移    大小    字段            说明
0x00    16      md5[16]        明文的 MD5 摘要
0x10    8       plain_len      明文长度（uint64，小端序）
0x18    16      iv[16]         AES-CFB 变种的初始化向量
0x28    N       ciphertext     密文（N = align_up(plain_len, 16)）

用 token.gdc 验证格式

文件: preliminary/assets/token.gdc
大小: 680 字节

头部解析:
  md5       = 9590a928a742f1f0536581d451f252b5
  plain_len = 0x0000000000000271 = 625
  iv        = c5b1680b09a2f12db436fcb1ddb69c0f

密文长度 = align_up(625, 16) = 640
文件总长 = 40(头部) + 640(密文) = 680 ✓ 完全吻合

这两个函数分析完，我获取了密文，密钥，iv，以及原文件md5值，这些所有内容，但是当我尝试通过 gdre_tools 对 .gdc 文件进行解密和反编译时，发现始终无法成功。

这里了卡了我很久，我一开始以为是文件格式还有我不会使用工具的原因，后来我在网络上找到一些帖子，才考虑到是不是加密算法被魔改了。

以下对算法的深入分析同样来自 GPT5.4 结合 idapro mcp 给出

为什么”标准 AES-CFB”解不出正确结果

最直觉的假设

到这一步，我们已经知道：

密钥：32 字节（AES-256）
IV：16 字节
文件头有 MD5 校验

这样做出来的 MD5 不匹配。

深入 0x197DE18：找到真正的逐字节解密逻辑

调用链追踪

从 sub_3801410 中的解密调用出发：

sub_376EF68(ctx, length, iv_buf, ciphertext, output)
    ↓
    LDR X0, [X0]           ; 取 AES 上下文指针
    MOV W1, WZR            ; ★ W1 = 0 → 解密模式
    BL sub_197DE18          ; 核心处理函数

对比另一个封装函数 sub_376EE9C（加密方向）：

1
2
3

sub_376EE9C:
    MOV W1, #1              ; ★ W1 = 1 → 加密模式
    BL sub_197DE18

所以 sub_197DE18 是 统一的 CFB 处理函数，参数 a2 决定方向：

a2 == 0：解密
a2 == 1：加密

反编译 sub_197DE18

完整伪代码（IDA F5）如下：

__int64 sub_197DE18(
    __int64 aes_ctx,     // a1: AES 上下文（含 key schedule）
    unsigned int mode,    // a2: 0=解密, 1=加密
    __int64 length,       // a3: 数据长度
    __int64 *offset_ptr,  // a4: 当前块内偏移的指针
    __int64 state_buf,    // a5: 16字节状态块（初始值 = IV）
    char *input,          // a6: 输入数据
    _BYTE *output,        // a7: 输出数据
    ...
)

函数首先检查 mode > 1 则返回错误，然后检查 *offset_ptr > 15 也返回错误。

解密分支的汇编（`mode == 0`，即 `a2 == 0`）

从 0x197DF04 开始的解密循环：

; 循环入口：检查是否需要刷新 keystream
197DF54  CBNZ  X25, loc_197DF2C           ; if (offset != 0) 跳过 AES-ECB

; offset == 0，需要重新加密状态块生成 keystream
197DF70  MOV   X0, X24                     ; aes_ctx
197DF74  MOV   X1, X22                     ; state_buf (输入)
197DF78  MOV   X2, X22                     ; state_buf (输出, in-place)
197DF7C  BL    sub_197CDB8                 ; ★ AES_ECB_Encrypt(state_buf) → state_buf

; 逐字节处理：
197DF2C  LDRB  W8, [X21], #1              ; W8 = *input++  （读取一个密文字节）
197DF30  LDRB  W9, [X22, X25]             ; W9 = state[offset]  （读取 keystream 字节）
197DF34  ADD   W10, W25, #1               ; W10 = offset + 1
197DF38  SUB   X23, X23, #1               ; length--

197DF3C  EOR   W8, W8, W25               ; ★★ W8 = ciphertext_byte ^ offset
197DF40  EOR   W9, W9, W8                ; ★★ W9 = state[offset] ^ (ciphertext_byte ^ offset) = 明文
197DF44  STRB  W9, [X20], #1             ; *output++ = plaintext_byte
197DF48  STRB  W8, [X22, X25]            ; ★★ state[offset] = ciphertext_byte ^ offset  （反馈）

197DF4C  AND   X25, X10, #0xF            ; offset = (offset + 1) & 0xF
197DF50  CBZ   X23, loc_197DF84           ; if (length == 0) 跳出

逐指令翻译为伪代码

state = bytearray(iv)    # 16 字节状态块，初始值为 IV
offset = 0

for cipher_byte in ciphertext:
    if offset == 0:
        state[:] = AES_ECB_Encrypt(key, state)   # 每处理完 16 字节，刷新 keystream

    mixed = cipher_byte ^ offset                  # ★ 关键：密文字节与块内偏移异或
    plain = state[offset] ^ mixed                 # 用 keystream 解密
    state[offset] = mixed                         # ★ 关键：反馈的是 mixed，不是原始密文

    output.append(plain)
    offset = (offset + 1) & 0x0F

与标准 AES-CFB 的对比

步骤	标准 AES-CFB128	Godot 变种
读入密文字节 `c`	`c`	`c`
混合操作	无	`mixed = c ^ offset`
生成明文	`p = keystream[offset] ^ c`	`p = keystream[offset] ^ mixed`
反馈到状态块	`state[offset] = c`	`state[offset] = mixed`

差异只有一个地方：Godot 在每个字节处理时额外混入了 offset（块内位置 0~15）。

加密分支的反向验证

对比加密分支（mode == 1，在 0x197DEAC 开始的循环）：

197DEAC  LDRB  W8, [X21], #1              ; W8 = *input++  （明文字节）
197DEB8  EOR   W9, W9, W8                 ; W9 = state[offset] ^ plaintext
197DEC0  STRB  W9, [X22, X25]             ; state[offset] = state[offset] ^ plaintext
197DEC4  EOR   W8, W9, W25               ; W8 = (state[offset] ^ plaintext) ^ offset
197DECC  STRB  W8, [X20], #1             ; *output++ = 密文字节

加密伪代码：

1
2
3

mixed = state[offset] ^ plain_byte         # 先与 keystream 异或
state[offset] = mixed                       # 反馈 mixed
cipher_byte = mixed ^ offset                # 再与 offset 异或生成密文输出

可以验证：解密是加密的精确逆过程 ✓

确认 sub_197CDB8 是 AES-ECB

sub_197CDB8 的反编译结果中可以看到：

它读取 a1 指向的结构体来获取轮数和 round keys。
使用了 dword_4046118、dword_4046918 等查找表——这些是标准 AES 实现中的 T-table（Te0~Te3 的变体）。
使用了 byte_4044F18——这是 AES 的 S-Box。
函数接受 16 字节输入（a2），输出 16 字节（a3），是典型的 AES 单块加密。
key schedule 函数 sub_197C210 中，当传入 a3 = 256 时设置 *a1 = 14（14 轮 = AES-256）。

因此 sub_197CDB8 就是 AES-256-ECB 单块加密函数。

既然如此，在ai的配合下就很容易的写出解密代码如下

from Crypto.Cipher import AES
import hashlib, struct

KEY_HEX = "ce4df8753b59a5a39ade58ac07ef947a3da39f2af75e3284d51217c04d49a061"

def godot_cfb_xor_decrypt(key: bytes, iv: bytes, ciphertext: bytes) -> bytes:
    """
    Godot 变种 CFB 解密。
    与标准 CFB 的唯一区别：每个密文字节在参与 keystream 异或和状态反馈前，
    先与块内偏移 offset (0~15) 做一次异或。
    """
    ecb = AES.new(key, AES.MODE_ECB)
    state = bytearray(iv)
    out = bytearray()
    offset = 0

    for enc_byte in ciphertext:
        if offset == 0:
            # 每处理完 16 字节，用 AES-ECB 加密当前状态块生成新的 keystream
            state[:] = ecb.encrypt(bytes(state))

        mixed = enc_byte ^ offset           # Godot 变种的关键一步
        plain = state[offset] ^ mixed       # 用 keystream 解密
        state[offset] = mixed               # 反馈到状态块

        out.append(plain)
        offset = (offset + 1) & 0x0F

    return bytes(out)


def decrypt_file(filepath: str, key: bytes) -> bytes:
    data = open(filepath, "rb").read()

    digest = data[0:16]                                    # MD5 摘要
    plain_len = struct.unpack(", data[16:24])[0]        # 明文长度
    iv = data[24:40]                                       # IV
    ciphertext = data[40:]                                 # 密文

    plaintext = godot_cfb_xor_decrypt(key, iv, ciphertext)[:plain_len]

    # 验证 MD5
    if hashlib.md5(plaintext).digest() != digest:
        raise ValueError("MD5 mismatch! 密钥或算法有误")
    else:
        print("Right!")
    return plaintext

key = bytes.fromhex(KEY_HEX)
pt = decrypt_file("assets/token.gdc", key)

由于没有多少个文件，我就直接解密了，不写批量解密代码了

此时查看解密后的 .gdc 文件，可以看到已经将文件头恢复成功了

此时使用 gdre_tools 就可以正常反编译了

flag游戏内验证

`*.gd` 文件分析

首先是 token.gd

这里是 token 的生成逻辑，可以看到是随机生成的

最关键的代码在 trigger.gd

extends Area3D

signal collided_with(name)
var flag1Triggered: = false
var flag2Triggered: = false
var t: = 0.0
var cnt: = 0

const FLAG_PREFIX: = "sec2026_PART1_"
const ROUNDS: = 8
const TOKEN_BYTES: = 4
var obj

func _ready() -> void :
    obj = GameExtension.new()

func xor_enc(plain: String) -> PackedByteArray:

    var out_buf = plain.to_utf8_buffer()
    if out_buf.size() < 8:
        out_buf.resize(8)

    var result = out_buf.slice(0, 8)
    for i in range(7):
        result[i] = result[i] ^ result[i + 1]
    result[7] = result[7] ^ result[0]
    return result


func _process(delta):
    t += delta * 2.0
    if $MeshInstance3D != null and monitoring:

        $MeshInstance3D.rotation.y += delta * 1.0

        var height = sin(t) * 0.2
        $MeshInstance3D.position.y = height

        var pulse = 1.0 + sin(t * 3.0) * 0.1
        $MeshInstance3D.scale = Vector3(pulse, pulse, pulse)

        var body = get_overlapping_bodies()
        if body.size() > 0:
            if str(get_path()) == "/root/TownScene/Trigger1":
                var label = get_node("/root/TownScene/Label2")
                label.text = "flag{sec2026_PART0_example}"

            elif str(get_path()) == "/root/TownScene/Trigger2":
                var label = get_node("/root/TownScene/Label2")
                var label1 = get_node("/root/TownScene/Label")

                var flag1 = obj.Process(xor_enc(str(label1.text).substr(7)))
                label.text = "flag{" + FLAG_PREFIX + flag1 + "}  "

结合 ai 给出分析如下

这个脚本继承自 Area3D，也就是一个 3D 区域检测节点，常用于碰撞检测、触发器。

如果碰到 Trigger1，直接显示测试 flag

如果碰到 Trigger2 则绑定了 flag 生成逻辑：

获取 Label 文本，截取 substr(7) 去掉 "Token: " 前缀，得到 8 位 hex token。
对 token 调用 xor_enc() 做一轮链式异或变换（7 次相邻异或 + 尾首异或），得到 8 字节 PackedByteArray。
将结果传给 GameExtension.Process()——这是 native 扩展 libsec2026.so 提供的方法。
native 层返回的字符串拼接为最终 flag：flag{sec2026_PART1_}。

说明接下来我们该去分析 libsec2026.so 了

获得flag

因为 Godot 4 引擎的 String 内部以 char32_t (UTF-32LE) 存储, 分配在堆上。而 GDScript 编译后的常量池中, 字符串字面量作为 String 对象存在。

因此可以直接修改堆上的 char32_t 数据:

将 elif 条件中的 “/Trigger2” → “/Trigger1” (使其匹配 Trigger1 节点)，同时将 if 条件中的 “/Trigger1” → “/TriggerX” (使其不再匹配任何节点)，这样当我们在游戏内碰触 Trigger1 时, 代码走 elif 分支, 执行真实 flag 计算。

如下图，我碰到了下面的黄色方块，但得到了另一个 flag

Frida 代码如下

function patchTriggersUTF32() {

    var p1 = '54 00 00 00 72 00 00 00 69 00 00 00 67 00 00 00 ' +
             '67 00 00 00 65 00 00 00 72 00 00 00 31 00 00 00';
    var p2 = '54 00 00 00 72 00 00 00 69 00 00 00 67 00 00 00 ' +
             '67 00 00 00 65 00 00 00 72 00 00 00 32 00 00 00';

    var addrs1 = []; // "/Trigger1" 的 'T' 位置
    var addrs2 = []; // "/Trigger2" 的 'T' 位置

    Process.enumerateRanges('rw-').forEach(function(range) {
        if (range.size < 256 || range.size > 0x80000000) return;
        try {
            Memory.scanSync(range.base, range.size, p1).forEach(function(m) {
                try {
                    // 检查前一个 char32 是否为 '/' (0x0000002F)
                    if (m.address.sub(4).readU32() === 0x2F)
                        addrs1.push(m.address);
                } catch (e) {}
            });
            Memory.scanSync(range.base, range.size, p2).forEach(function(m) {
                try {
                    if (m.address.sub(4).readU32() === 0x2F)
                        addrs2.push(m.address);
                } catch (e) {}
            });
        } catch (e) {}
    });

    console.log('    [UTF-32] "/Trigger1": ' + addrs1.length + ' 处');
    console.log('    [UTF-32] "/Trigger2": ' + addrs2.length + ' 处');

    if (addrs1.length === 0 && addrs2.length === 0) return false;

    // 关键: 先收集再修改, 避免 Trigger2→1 后被误识为原始 Trigger1

    // Step 1: 将 elif 中的 "Trigger2" → "Trigger1"
    //         使其匹配 Trigger1 节点的实际路径
    addrs2.forEach(function(addr) {
        // '2' 在 "Trigger2" 的第 8 个字符 (index 7), 偏移 = 7 * 4 = 28
        addr.add(28).writeU32(0x31); // '2' (0x32) → '1' (0x31)
        console.log('    [+] "/Trigger2" → "/Trigger1" @ ' + addr);
    });

    // Step 2: 将 if 中的 "Trigger1" → "TriggerX"
    //         使其不再匹配任何节点, 跳过示例 flag
    addrs1.forEach(function(addr) {
        addr.add(28).writeU32(0x58); // '1' (0x31) → 'X' (0x58)
        console.log('    [+] "/Trigger1" → "/TriggerX" @ ' + addr);
    });

    return true;
}

function doPatch() {
    console.log('[*] 开始搜索并补丁 GDScript 字符串...');
    if (patchTriggersUTF32()) {
        console.log('[*] UTF-32LE 补丁成功!');
        return true;
    }
    return false;
}

var patchDone = false;

function runOnce() {
    // 1. 补丁
    patchDone = doPatch();
    if (patchDone) {
        console.log('\n[*] ✓ 补丁已生效!');
        console.log('[*]   在游戏中碰触 Trigger1 (黄色旋转物体) 即可看到真实 flag\n');
    } else {
        console.log('\n[!] 补丁失败, 场景可能尚未加载, 将自动重试...\n');
    }

    return patchDone;
}

// 启动: 延迟 5 秒等待 Godot 引擎 + 场景加载
console.log('[*] 等待游戏加载 (5秒)...');
setTimeout(function() {
    if (runOnce()) return;

    // 自动重试, 每 3 秒一次, 最多 10 次
    var attempt = 0;
    var timer = setInterval(function() {
        attempt++;
        if (attempt > 10) {
            clearInterval(timer);
            console.log('[!] 达到最大重试次数 (10)。请确认游戏已进入主场景。');
            console.log('[!] 可手动调用 rpc.exports.patch() 重试');
            return;
        }
        console.log('[*] 重试 #' + attempt + '...');
        if (doPatch()) {
            patchDone = true;
            clearInterval(timer);
            console.log('[*] ✓ 补丁成功! 碰触 Trigger1 查看 flag');
            var toks = discoverToken();
            toks.forEach(function(tok) {
                console.log('[*] Token=' + tok + ' → ' + computeFlag(tok));
            });
        }
    }, 3000);
}, 5000);

运行效果如下图所示

flag生成逻辑分析

libsec2026.so 分析

首先打开看到 start 函数

函数通过 openat + read 读取 /proc/self/auxv，获取 AT_PAGESZ（页大小）

sub_69984 是一个解压函数，将代码段的压缩数据解压，之后通过 memfd_create + write + mmap 将解压后的代码映射到内存，通过 BR X14 跳转到映射的代码中执行。

现在需要想办法得到已经被解压之后的代码，这里通过frida动态dump的方式获取，这里我直接hook dlopen 函数，只要 dlopen 返回，说明进程中已经存在了完整脱壳的 so 文件。

同时已知的一些字符串特征可以用来辅助dump

var TARGET_LIB  = "libsec2026.so";
var RAW_NAME    = "libsec2026_dump.bin";
var RELOC_NAME  = "libsec2026_dump_reloc.bin";

// 自动检测可写目录
var DUMP_DIR = (function() {
    // 通过 /proc/self/cmdline 获取包名，拼出应用数据目录
    var candidates = [];
    try {
        var cmdline = new File("/proc/self/cmdline", "r").readLine();
        // cmdline 以 '\0' 结尾，取第一个字段即包名
        var pkgName = cmdline.split("\0")[0].trim();
        if (pkgName.indexOf(".") !== -1) {
            candidates.push("/data/data/" + pkgName + "/");
        }
    } catch(e) {}
    candidates.push("/data/local/tmp/");
    candidates.push("/sdcard/Download/");
    candidates.push("/sdcard/");

    for (var i = 0; i < candidates.length; i++) {
        try {
            var testPath = candidates[i] + ".frida_write_test";
            var f = new File(testPath, "wb");
            f.write(new ArrayBuffer(1));
            f.flush();
            f.close();
            console.log("[*] 可写目录: " + candidates[i]);
            return candidates[i];
        } catch(e) {}
    }
    console.log("[!] 警告: 未找到可写目录，默认使用 /data/local/tmp/");
    return "/data/local/tmp/";
})();
// 脱壳后的 ELF 虚拟地址范围约 0x0 ~ 0xF4000（999KB），用于筛选候选区域
var MIN_ELF_SIZE = 0x80000;   // 最少 512KB 才认为是目标

// 已知特征：修改后的 ChaCha20 常量，用于二次验证
var CHACHA_MAGIC = [0x66, 0x78, 0x70, 0x61, 0x6f, 0x64, 0x20, 0x33,
                    0x31, 0x2d, 0x62, 0x79, 0x73, 0x65, 0x20, 0x6b];
// "fxpaod 31-byse k"

// ========================== 辅助函数 ============================

/**
 * 在内存中搜索已知字节序列
 */
function containsMagic(base, size, pattern) {
    try {
        var result = Memory.scanSync(base, size, patternToHex(pattern));
        return result.length > 0;
    } catch (e) {
        return false;
    }
}

function patternToHex(arr) {
    return arr.map(function(b) { return ('0' + b.toString(16)).slice(-2); }).join(' ');
}

/**
 * 将 ArrayBuffer 写入文件
 */
function writeFile(path, buf) {
    try {
        var f = new File(path, "wb");
        f.write(buf);
        f.flush();
        f.close();
    } catch(e) {
        // 如果目标路径写失败，回退到 /sdcard/
        var fallback = "/sdcard/" + path.split("/").pop();
        console.log("[!] 写入 " + path + " 失败: " + e);
        console.log("[*] 回退写入 " + fallback);
        var f2 = new File(fallback, "wb");
        f2.write(buf);
        f2.flush();
        f2.close();
    }
}

/**
 * 从 ELF header 解析所有 PT_LOAD 段，计算虚拟地址范围
 * 返回: { totalSize: number, loads: [{vaddr, memsz, filesz, offset, flags}] }
 */
function parseElfLoads(base) {
    // Elf64_Ehdr
    var e_phoff     = parseInt(base.add(32).readU64().toString());
    var e_phentsize = base.add(54).readU16();
    var e_phnum     = base.add(56).readU16();

    var loads = [];
    var maxEnd = 0;

    for (var i = 0; i < e_phnum; i++) {
        var phdr = base.add(e_phoff + i * e_phentsize);
        var p_type  = phdr.readU32();

        if (p_type === 1) {  // PT_LOAD
            var p_offset = parseInt(phdr.add(8).readU64().toString());
            var p_vaddr  = parseInt(phdr.add(16).readU64().toString());
            var p_filesz = parseInt(phdr.add(32).readU64().toString());
            var p_memsz  = parseInt(phdr.add(40).readU64().toString());
            var p_flags  = phdr.add(4).readU32();

            loads.push({
                vaddr:  p_vaddr,
                memsz:  p_memsz,
                filesz: p_filesz,
                offset: p_offset,
                flags:  p_flags
            });

            var end = p_vaddr + p_memsz;
            if (end > maxEnd) maxEnd = end;
        }
    }

    return { totalSize: maxEnd, loads: loads };
}

/**
 * 解析 PT_DYNAMIC 段，获取 DT_RELA / DT_RELASZ
 */
function findRelaDynamic(base) {
    var e_phoff     = parseInt(base.add(32).readU64().toString());
    var e_phentsize = base.add(54).readU16();
    var e_phnum     = base.add(56).readU16();

    for (var i = 0; i < e_phnum; i++) {
        var phdr = base.add(e_phoff + i * e_phentsize);
        if (phdr.readU32() !== 2) continue;  // PT_DYNAMIC

        var p_vaddr = parseInt(phdr.add(16).readU64().toString());
        var p_memsz = parseInt(phdr.add(40).readU64().toString());

        var relaAddr = 0, relaSize = 0, relaEnt = 24;

        for (var j = 0; j + 16 <= p_memsz; j += 16) {
            var d_tag = parseInt(base.add(p_vaddr + j).readS64().toString());
            var d_val = parseInt(base.add(p_vaddr + j + 8).readU64().toString());

            if (d_tag === 0) break;          // DT_NULL
            if (d_tag === 7) relaAddr = d_val; // DT_RELA
            if (d_tag === 8) relaSize = d_val; // DT_RELASZ
            if (d_tag === 9) relaEnt  = d_val; // DT_RELAENT
        }

        return { relaAddr: relaAddr, relaSize: relaSize, relaEnt: relaEnt };
    }

    return null;
}

// ====================== 核心 dump 逻辑 ==========================

/**
 * 扫描进程内存，查找脱壳后的 ELF 镜像
 *
 * 判断标准：
 *   1. 内存区域 ≥ MIN_ELF_SIZE
 *   2. 起始地址为 ELF64 magic (7f 45 4c 46 02)
 *   3. 不属于原始 libsec2026.so 的模块范围
 *   4. 不属于系统库
 *   5. （可选）包含 "fxpaod 31-byse k" 特征串
 */
function findUnpackedElf() {
    console.log("[*] 扫描内存，查找脱壳后的 ELF 镜像...");

    var origMod  = Process.findModuleByName(TARGET_LIB);
    var origBase = origMod ? origMod.base : ptr(0);
    var origEnd  = origMod ? origMod.base.add(origMod.size) : ptr(0);

    var candidates = [];

    // 遍历所有可读区域（ELF header 所在页至少是 r--）
    var allRanges = Process.enumerateRangesSync('r--');
    for (var ri = 0; ri < allRanges.length; ri++) {
        var range = allRanges[ri];
        if (range.size < MIN_ELF_SIZE) continue;

        // 排除原始 SO 模块
        if (origMod &&
            range.base.compare(origBase) >= 0 &&
            range.base.compare(origEnd) < 0) continue;

        // 排除系统路径
        if (range.file && range.file.path) {
            var p = range.file.path;
            if (p.indexOf('/system/')  !== -1) continue;
            if (p.indexOf('/vendor/')  !== -1) continue;
            if (p.indexOf('/apex/')    !== -1) continue;
            if (p.indexOf('/dev/')     !== -1) continue;
            if (p.indexOf('dalvik')    !== -1) continue;
            if (p.indexOf('base.apk')  !== -1) continue;
            if (p.indexOf('libgodot_android') !== -1) continue;
            if (p.indexOf('libc++_shared')    !== -1) continue;
            if (p.indexOf('libc.so')          !== -1) continue;
            if (p.indexOf('gralloc')   !== -1) continue;
        }

        // 检查 ELF64 magic
        try {
            var magic = range.base.readU32();
            if (magic !== 0x464c457f) continue;         // \x7fELF
            if (range.base.add(4).readU8() !== 2) continue;  // ELFCLASS64
        } catch (e) {
            continue;
        }

        var path = (range.file && range.file.path) ? range.file.path : "(anonymous/memfd)";
        console.log("[+] 候选 ELF64:");
        console.log("      基址: " + range.base);
        console.log("      区域大小: 0x" + range.size.toString(16));
        console.log("      权限: " + range.protection);
        console.log("      来源: " + path);

        candidates.push(range);
    }

    return candidates;
}

/**
 * 逐区域读取，组装完整 ELF 镜像
 * 对于不可读的空洞区域自动填零
 */
function readElfImage(base, totalSize) {
    // 先尝试直接一次性读取
    try {
        return base.readByteArray(totalSize);
    } catch (e) {
        console.log("[*] 单次读取失败，改用分区域拼接...");
    }

    // 收集 base ~ base+totalSize 范围内所有可读区域（r--, r-x, rw-, rwx 等）
    var buf  = new ArrayBuffer(totalSize);
    var dest = new Uint8Array(buf);
    var end  = base.add(totalSize);

    // 'r--' 在 Frida 中匹配所有 readable 区域（包括 r-x, rw-, rwx）
    // 但为确保兼容，分别搜集多种权限
    var perms = ['r--', 'r-x', 'rw-', 'rwx'];
    var seen  = {};  // 避免重复区域

    var ranges = Process.enumerateRangesSync('r--');
    // 补充其他权限的区域（避免遗漏纯 r-x 段）
    var extraPerms = ['r-x', 'rw-'];
    for (var pi = 0; pi < extraPerms.length; pi++) {
        var extra = Process.enumerateRangesSync(extraPerms[pi]);
        for (var ei = 0; ei < extra.length; ei++) {
            ranges.push(extra[ei]);
        }
    }
    // 去重（按基址）
    var seen = {};
    var uniqueRanges = [];
    for (var ui = 0; ui < ranges.length; ui++) {
        var key = ranges[ui].base.toString();
        if (!seen[key]) {
            seen[key] = true;
            uniqueRanges.push(ranges[ui]);
        }
    }
    ranges = uniqueRanges;

    for (var ri = 0; ri < ranges.length; ri++) {
        var r = ranges[ri];
        var rStart = r.base;
        var rEnd   = rStart.add(r.size);

        // 区域是否与目标范围重叠？
        if (rEnd.compare(base) <= 0 || rStart.compare(end) >= 0) continue;

        // 计算重叠部分
        var copyStart  = rStart.compare(base) > 0 ? rStart : base;
        var copyEnd    = rEnd.compare(end) < 0 ? rEnd : end;
        var offsetInBuf = parseInt(copyStart.sub(base).toString());
        var copySize    = parseInt(copyEnd.sub(copyStart).toString());

        if (copySize <= 0) continue;

        try {
            var rawBytes = copyStart.readByteArray(copySize);
            if (rawBytes) {
                var chunk = new Uint8Array(rawBytes);
                dest.set(chunk, offsetInBuf);
            }
        } catch (e) {
            console.log("    [!] 读取失败 @ " + copyStart + " (size 0x" +
                        copySize.toString(16) + "): " + e);
        }
    }

    return buf;
}

/**
 * 对 dump 出的 ArrayBuffer 应用 R_AARCH64_RELATIVE 重定位
 * 重定位后 RTTI / vtable / GOT 区域将填充正确的指针值
 */
function applyRelocations(buf, base) {
    var rela = findRelaDynamic(base);
    if (!rela || rela.relaAddr === 0 || rela.relaSize === 0) {
        console.log("[!] 未找到 RELA 段，跳过重定位");
        return;
    }

    var nEntries = Math.floor(rela.relaSize / rela.relaEnt);
    console.log("[*] 应用重定位: DT_RELA @ 0x" + rela.relaAddr.toString(16) +
                ", " + nEntries + " 条目");

    var view    = new DataView(buf);
    var applied = 0;

    for (var i = 0; i < nEntries; i++) {
        var entryBase = base.add(rela.relaAddr + i * rela.relaEnt);

        var r_offset = parseInt(entryBase.readU64().toString());
        var r_info   = parseInt(entryBase.add(8).readU64().toString());
        var r_addend = parseInt(entryBase.add(16).readS64().toString());

        var r_type = r_info & 0xFFFFFFFF;

        if (r_type !== 0x403) continue;  // 只处理 R_AARCH64_RELATIVE

        if (r_offset + 7 >= buf.byteLength) continue;

        // *r_offset = base_addr(0) + r_addend
        var lo = r_addend & 0xFFFFFFFF;
        var hi = 0;
        if (r_addend >= 0) {
            hi = Math.floor(r_addend / 0x100000000);
        } else {
            // 负 addend（极少见，但安全处理）
            var unsigned = r_addend + 0x10000000000000000;
            lo = unsigned & 0xFFFFFFFF;
            hi = Math.floor(unsigned / 0x100000000) & 0xFFFFFFFF;
        }

        view.setUint32(r_offset,     lo, true);
        view.setUint32(r_offset + 4, hi, true);
        applied++;
    }

    console.log("[+] 已应用 " + applied + " 条 R_AARCH64_RELATIVE 重定位");
}

// ========================= 主入口 ===============================

function doDump() {
    // ========== 策略 1：直接从模块基址 dump ==========
    // init_array 执行后，.text 已被原地解密（mprotect RW → 解密 → mprotect RX）
    // 模块基址就是解密后的 ELF，无需扫描匿名区域
    var origMod = Process.findModuleByName(TARGET_LIB);
    if (origMod) {
        var base = origMod.base;
        console.log("[*] 模块基址: " + base + " (size 0x" + origMod.size.toString(16) + ")");

        // 确认是 ELF64
        try {
            if (base.readU32() !== 0x464c457f || base.add(4).readU8() !== 2) {
                console.log("[!] 模块基址不是 ELF64 header，跳过策略 1");
                doDumpScan();
                return;
            }
        } catch (e) {
            console.log("[!] 无法读取模块基址: " + e);
            doDumpScan();
            return;
        }

        // 解析 LOAD 段
        var elfInfo;
        try {
            elfInfo = parseElfLoads(base);
        } catch (e) {
            console.log("[!] 解析 ELF header 失败: " + e + ", 用模块大小替代");
            elfInfo = { totalSize: origMod.size, loads: [] };
        }

        var totalSize = elfInfo.totalSize;
        console.log("[*] ELF 虚拟范围: 0x0 ~ 0x" + totalSize.toString(16) +
                    " (" + totalSize + " bytes)");

        elfInfo.loads.forEach(function (seg, i) {
            var flagStr = ((seg.flags & 4) ? "R" : "-") +
                          ((seg.flags & 2) ? "W" : "-") +
                          ((seg.flags & 1) ? "X" : "-");
            console.log("    LOAD[" + i + "] vaddr=0x" + seg.vaddr.toString(16) +
                        " memsz=0x" + seg.memsz.toString(16) +
                        " filesz=0x" + seg.filesz.toString(16) +
                        " " + flagStr);
        });

        // 验证特征
        var verified = false;
        try {
            verified = containsMagic(base, Math.min(origMod.size, totalSize), CHACHA_MAGIC);
        } catch(e) {}
        // 也搜索后续 LOAD 段
        if (!verified) {
            for (var si = 0; si < elfInfo.loads.length && !verified; si++) {
                var seg = elfInfo.loads[si];
                try {
                    verified = containsMagic(base.add(seg.vaddr),
                                             Math.min(seg.memsz, seg.filesz),
                                             CHACHA_MAGIC);
                } catch(e) {}
            }
        }

        if (verified) {
            console.log("[+] 特征验证: 找到 \"fxpaod 31-byse k\" ✓");
        } else {
            console.log("[*] 特征验证: 未找到 ChaCha 特征串（可能在运行时生成）");
        }

        // 检查 extension_init 区域是否已解密（应该是有效 ARM64 指令）
        try {
            // extension_init 在 vaddr 0x56D50
            var extInit = base.add(0x56D50);
            var insn0 = extInit.readU32();
            var insn1 = extInit.add(4).readU32();
            console.log("[*] extension_init @ " + extInit + ":");
            console.log("      insn[0] = 0x" + ("00000000" + insn0.toString(16)).slice(-8));
            console.log("      insn[1] = 0x" + ("00000000" + insn1.toString(16)).slice(-8));
            // NOP = 0xd503201f, STP/SUB 常见开头
            if (insn0 === 0xd503201f || (insn0 >>> 22) === 0x2d2 ||
                (insn0 >>> 23) === 0x1a9 || (insn0 >>> 24) === 0xd1) {
                console.log("      → 有效 ARM64 指令 ✓ (.text 已解密)");
            } else {
                console.log("      → 疑似仍为加密数据（但继续 dump）");
            }
        } catch (e) {
            console.log("[*] 无法读取 extension_init 区域: " + e);
        }

        doDumpFromBase(base, totalSize, elfInfo);
        return;
    }

    // ========== 策略 2：扫描匿名区域  ==========
    console.log("[!] 未找到模块 " + TARGET_LIB + "，改用扫描模式...");
    doDumpScan();
}

/**
 * 从已知基址 dump
 */
function doDumpFromBase(base, totalSize, elfInfo) {
    console.log("[*] 读取 ELF 镜像...");
    var rawBuf = readElfImage(base, totalSize);

    // 写入原始 dump
    var rawPath = DUMP_DIR + RAW_NAME;
    writeFile(rawPath, rawBuf);
    console.log("[+] 原始 dump: " + rawPath + " (" + totalSize + " bytes)");

    // 应用重定位
    try {
        var relocBuf = rawBuf.slice(0);
        applyRelocations(relocBuf, base);
        var relocPath = DUMP_DIR + RELOC_NAME;
        writeFile(relocPath, relocBuf);
        console.log("[+] 重定位 dump: " + relocPath);
    } catch (e) {
        console.log("[!] 重定位处理失败: " + e);
    }

    printDone();
}

/**
 * 扫描模式（fallback）
 */
function doDumpScan() {
    var candidates = findUnpackedElf();

    // 先以特征串筛选
    var verified = [];
    for (var ci = 0; ci < candidates.length; ci++) {
        var c = candidates[ci];
        try {
            if (containsMagic(c.base, c.size, CHACHA_MAGIC)) {
                verified.push(c);
            }
        } catch(e) {}
    }

    if (verified.length > 0) {
        candidates = verified;
        console.log("[+] 通过特征验证的候选: " + verified.length);
    }

    if (candidates.length === 0) {
        console.log("[-] 未找到任何候选 ELF。");
        console.log("[*] dump 所有大型匿名可执行区域作为参考...");
        var idx = 0;
        var rxRanges = Process.enumerateRangesSync('r-x');
        for (var ri = 0; ri < rxRanges.length; ri++) {
            var r = rxRanges[ri];
            if (r.size >= 0x10000 &&
                (!r.file || !r.file.path || r.file.path === "")) {
                var outPath = DUMP_DIR + "anon_rx_" + idx + ".bin";
                console.log("  dump " + r.base + " size=0x" + r.size.toString(16));
                try {
                    writeFile(outPath, r.base.readByteArray(r.size));
                    console.log("  → " + outPath);
                } catch (e) {
                    console.log("  失败: " + e);
                }
                idx++;
            }
        }
        return;
    }

    candidates.sort(function (a, b) { return b.size - a.size; });
    var target = candidates[0];
    var base = target.base;
    console.log("\n[*] 选中目标: " + base);

    var elfInfo;
    try {
        elfInfo = parseElfLoads(base);
    } catch (e) {
        elfInfo = { totalSize: target.size, loads: [] };
    }

    doDumpFromBase(base, elfInfo.totalSize, elfInfo);
}

function printDone() {
    console.log("\n======================================");
    console.log("  DUMP 完成!");
    console.log("======================================");
}

// ====================== 时机控制 ================================

console.log("╔═══════════════════════════════════════╗");
console.log("║  libsec2026.so 内存 Dump 工具         ║");
console.log("╚═══════════════════════════════════════╝");

// 检查目标是否已加载（attach 模式）
var mod = Process.findModuleByName(TARGET_LIB);
if (mod) {
    console.log("[*] " + TARGET_LIB + " 已加载 @ " + mod.base +
                " (size 0x" + mod.size.toString(16) + ")");
    console.log("[*] init_array 已执行完毕，直接开始 dump...\n");
    doDump();
} else {
    // spawn 模式：hook dlopen，等待目标 SO 加载
    console.log("[*] " + TARGET_LIB + " 尚未加载，hook dlopen 等待...\n");

    var dlopenNames = ["android_dlopen_ext", "dlopen"];
    var hooked = false;

    dlopenNames.forEach(function (name) {
        var addr = Module.findExportByName(null, name);
        if (!addr || hooked) return;

        Interceptor.attach(addr, {
            onEnter: function (args) {
                if (args[0].isNull()) {
                    this.libpath = null;
                    return;
                }
                try {
                    this.libpath = args[0].readUtf8String();
                } catch (e) {
                    this.libpath = null;
                }
            },
            onReturn: function (retval) {
                if (!this.libpath) return;
                if (this.libpath.indexOf("libsec2026") === -1) return;

                console.log("[*] " + name + "(\"" + this.libpath + "\") 返回");
                console.log("[*] .init_array 已执行 → 脱壳完成\n");

                // 延迟一小段时间确保所有初始化完成
                setTimeout(doDump, 100);
            }
        });

        console.log("[*] 已 hook " + name + " @ " + addr);
        hooked = true;
    });

    if (!hooked) {
        console.log("[!] 未找到 dlopen，尝试轮询检测...");
        var pollId = setInterval(function () {
            var m = Process.findModuleByName(TARGET_LIB);
            if (m) {
                clearInterval(pollId);
                console.log("[*] 检测到 " + TARGET_LIB + " 已加载\n");
                setTimeout(doDump, 200);
            }
        }, 500);
    }
}

`dump.so` 分析

由于代码太过于混乱，实在不好分析，只好交给ai

障碍：跳板混淆

所有函数调用都通过间接跳板 (trampoline) 实现。每个跳板是一段固定模式的代码：

ADR   X8, loc_XXXX        ; 加载一个地址
MVN   W9, W8              ; 计算 ~X8
AND   X10, X8, #0x20      ; X8 & 0x20
ORR   X9, X9, #~0x20      ; X9 |= 0xFFFFFFFFFFFFFFDF
ADD   X10, X8, X10         ; X10 = X8 + (X8 & 0x20)
ADD   X9, X10, X9          ; X9 = X10 + X9
ADD   X9, X9, #0x21        ; X9 += 0x21
...
BR    X9                   ; 跳转到计算出的地址

规律：无论中间计算如何，最终跳转目标始终为 ADR 操作数 + 0x20。

例如：

ADR X8, 0x5B7F8 → 实际跳转到 0x5B818（ChaCha20 init）
ADR X8, 0x5BB34 → 实际跳转到 0x5BB54（quarter_round）
ADR X8, 0x5B930 → 实际跳转到 0x5B950（encrypt）

应对方法：在逆向时，每次遇到 ADR X8, addr; ... BR 模式，直接去看 addr + 0x20 处的代码。

字符串搜索 — 找到突破口

在 IDA 中 Shift+F12 打开 Strings 窗口搜索：

地址	字符串	意义
0x19ED8	`fxpaod 31-byse k`	★ 魔改的 ChaCha20 常量
0x19EC8	`GameExtension`	RTTI 类名
0xD48	`extension_init`	GDExtension 初始化函数

疑点 ④："fxpaod 31-byse k" 与标准 ChaCha20 常量 "expand 32-byte k" 高度相似，仅若干字符不同。这是识别算法的关键线索。

常量对比 — 确认 ChaCha20

将两个 16 字节常量按小端序 u32 解析：

标准: "expand 32-byte k"
       0x61707865  0x3320646e  0x79622d32  0x6b206574

魔改: "fxpaod 31-byse k"
       0x61707866  0x3320646f  0x79622d31  0x6b206573

差异模式：末尾字节分别为 5→6, e→f, 2→1, 4→3。这不影响算法结构，只影响初始状态。

从常量出发交叉引用

对 byte_19ED8 按 X 查找交叉引用 → 被 sub_5B818 引用。

; sub_5B818 — ChaCha20 初始化函数
ADR   X2, byte_19ED8       ; 常量 "fxpaod 31-byse k"
MOV   X1, #-1
MOV   W3, #0x10            ; 16 字节
ADR   X8, sub_5B7C4        ; → 跳转到 memcpy 型函数
BLR   X8                   ; 将常量复制到 state[0..3]

然后连续 8 次调用 off_EBEF8（实际为 LDR W0, [X0]——即小端读 u32）将密钥写入 state[4..11]：

BLR   X23                  ; read_le_u32(key+0)
STR   W0, [X19, #0x10]     ; state[4] = key_word[0]
...                         ; 重复 8 次
STP   W0, W21, [X19,#0x2C] ; state[11]=key[7], state[12]=counter

接着 3 次读 Nonce 写入 state[13..15]：

1
2
3

STR   W0, [X19, #0x34]     ; state[13] = nonce_word[0]
STR   W0, [X19, #0x38]     ; state[14] = nonce_word[1]
STR   W0, [X19, #0x3C]     ; state[15] = nonce_word[2]

最后设置 [X19, #0x80] = 0x40（内部缓冲区用完标记，强制首次调用时生成新 keystream block）。

标准 ChaCha20 状态矩阵得到确认：

state[ 0.. 3] = 常量 ("fxpaod 31-byse k")
state[ 4..11] = 密钥 (32 字节, 8 个 u32 LE)
state[12]     = 计数器 (初始 0)
state[13..15] = Nonce  (12 字节, 3 个 u32 LE)

quarter_round (sub_5BB54)

; 参数: X0=&state[a], X1=&state[b], X2=&state[c], X3=&state[d]

; a += b; d ^= a; d = rotl(d, 16)
LDR   W8, [X1]             ; W8 = b
LDR   W9, [X0]             ; W9 = a
ADD   W8, W9, W8           ; a = a + b
STR   W8, [X0]
LDR   W9, [X3]
EOR   W0, W9, W8           ; d = d ^ a
STR   W0, [X3]
BLR   X23  ; rotl(W0, 16)  ; 调用 rotl32 函数
STR   W0, [X3]             ; d = rotl(d, 16)

; c += d; b ^= c; b = rotl(b, 12)
...MOV W1, #0xC...          ; 旋转量 12

; a += b; d ^= a; d = rotl(d, 8)
...MOV W1, #8...            ; 旋转量 8

; c += d; b ^= c; b = rotl(b, 7)
...MOV W1, #7...            ; 旋转量 7

旋转量为 16, 12, 8, 7 — 完全标准。

rotl32 (sub_5B648 → 0x5B764)

; W0 = value, W1 = shift_amount
NEG   W8, W1               ; W8 = -shift = (32 - shift) mod 32
NEG   W9, W1, LSL#1        ; W9 = -(shift*2)
EOR   W8, W8, #0x20        ; W8 ^= 32
AND   W9, W9, #0x40        ; W9 &= 64
ADD   W8, W9, W8           ; W8 = right_shift_amount
LSL   W9, W0, W1           ; W9 = value << shift
LSR   W8, W0, W8           ; W8 = value >> right_shift
ORR   W0, W8, W9           ; result = (value >> rs) | (value << shift)
RET

这是一个带混淆的 rotl32 实现，数学上等价于 (x << n) | (x >> (32-n))。

column_round / diagonal_round

column_round (sub_5BF6C)：

调用	参数偏移 (×4=索引)	实际索引
第 1 次	+0x00, +0x10, +0x20, +0x30	QR(0, 4, 8, 12)
第 2 次	+0x04, +0x14, +0x24, +0x34	QR(1, 5, 9, 13)
第 3 次	+0x08, +0x18, +0x28, +0x38	QR(2, 6, 10, 14)
第 4 次	+0x0C, +0x1C, +0x2C, +0x3C	QR(3, 7, 11, 15)

diagonal_round (sub_5BC48)：

调用	参数偏移	实际索引
第 1 次	+0x00, +0x14, +0x28, +0x3C	QR(0, 5, 10, 15)
第 2 次	+0x04, +0x18, +0x2C, +0x30	QR(1, 6, 11, 12)
第 3 次	+0x08, +0x1C, +0x20, +0x34	QR(2, 7, 8, 13)
第 4 次	+0x0C, +0x10, +0x24, +0x38	QR(3, 4, 9, 14)

完全标准的 ChaCha20 column + diagonal round 索引。

block 函数 (sub_5BCF0)

; 1. 复制 state → working (栈上 64 字节)
MOV   X0, SP               ; dst = working (栈)
MOV   W1, #0x40             ; 64 字节
MOV   X2, X19               ; src = state
MOV   W3, #0x40
BLR   sub_5B7C4             ; memcpy(working, state, 64)

; 2. 执行 10 次 double-round
BLR   X21  ; column_round    ─┐
BLR   X22  ; diagonal_round  │ × 10 次
;          (重复 10 对)      ─┘

; 3. NEON 向量加法: output = working + state
LDP   Q0, Q1, [X19]         ; state[0..7]
LDP   Q2, Q3, [SP]          ; working[0..7]
ADD   V0.4S, V2.4S, V0.4S   ; output[0..3] = working[0..3] + state[0..3]
ADD   V1.4S, V3.4S, V1.4S   ; output[4..7] = working[4..7] + state[4..7]
; ... 对 state[8..15] 同理

; 4. 将 16 个 u32 以小端序写回输出 (off_EBF00 = STR W1,[X0])
STR   → [X19+0x40]          ; output[0]
STR   → [X19+0x44]          ; output[1]
...                          ; 共 16 个

; 5. 递增计数器
LDR   W8, [X19, #0x30]      ; counter
ADD   W8, W8, #1
STR   W8, [X19, #0x30]

标准 ChaCha20 block function：copy → 20 rounds → add → write → counter++

encrypt 函数 (sub_5B950)

; 参数: X0=ctx, X1=input, X2=output, X3=length
; 核心 XOR 循环:
LDRB  W13, [X12], #1       ; 读 input 字节
LDRB  W14, [X8], #1        ; 读 keystream 字节
EOR   W13, W14, W13         ; 异或
STRB  W13, [X11], #1       ; 写 output 字节

对于 ≥32 字节的数据，使用 NEON 向量化 XOR 加速：

LDP   Q0, Q1, [X13, #-0x10]  ; 读 32 字节 input
LDP   Q2, Q3, [X12, #-0x10]  ; 读 32 字节 keystream
EOR   V0.16B, V2.16B, V0.16B ; 向量异或
EOR   V1.16B, V3.16B, V1.16B
STP   Q0, Q1, [X11, #-0x10]  ; 写 32 字节 output

Process 函数 (sub_4E548)

这是 GameExtension.Process() 的 native 实现：

; 1. 获取互斥锁
ADR   X0, unk_ED7C0
BLR   [off_EBD68]           ; lock

; 2. 分配 ChaCha20 上下文 (0x88 字节)
BLR   [off_EBD78]           ; alloc_state() → X21

; 3. 初始化 ChaCha20
ADR   X1, unk_ED5D2          ; KEY   (32 字节)
ADR   X2, unk_ED5F3          ; NONCE (12 字节)
MOV   W3, WZR                ; counter = 0
BLR   [off_EBD80]           ; chacha20_init(ctx, key, nonce, 0)

; 4. 获取 PackedByteArray 数据指针
MOV   X0, X20                ; PackedByteArray 参数
BLR   [off_EBD88]           ; get_data_ptr → X22 (数据指针)

; 5. 初始化空字符串
ADR   X1, byte_11DC6         ; "" (空字符串)
BLR   [off_EBCD0]           ; String::init(result, "")

; 6. 分配输出缓冲区
BL    0x88C80                ; PackedByteArray::size() → 8
; ... chacha20_encrypt(ctx, input, output, 8) ...

; 7. 循环格式化为十六进制
loop:
  LDR   X8, [qword_ED7E8]   ; 输出缓冲区指针
  LDRB  W4, [X21, X8]       ; 读一个密文字节
  ; 调用 sprintf(buf, "%02X", byte)
  ADR   X4, unk_ED600       ; 格式串 "%02X"
  BL    sub_4C6D4            ; snprintf
  BL    sub_64DFC            ; String::append
  ADD   X21, X21, #1
  B     loop

; 8. 返回十六进制字符串

关键确认：

密钥地址：0xED5D2
Nonce 地址：0xED5F3
格式化：sprintf(buf, "%02X", byte) — 大写十六进制

密钥为Th1s ls n0t a rea1 key!!@sec2026

Nonce为 012345678901

疑惑的点

到这里其实已经分析完了，但这里有一个疑惑的点，我dump出的so文件在地址 0xED5D2 可以看到这里的值是正常的

而在ida中看到的值却是不正常的

这里卡了我很久，直到我在010中查看的时候才发现密钥是不一样的

同时在 libsec2026.so 中，可以看到这里的值是乱码，猜测是在解压的代码中有覆盖操作

我抱着求证的心态尝试去hook chacha20_init


// chacha20_init(ChaCha20State *state, uint8_t *key, uint8_t *nonce, uint32_t counter)
// 位于 libsec2026.so 偏移 0x5B818
// ARM64 ABI: X0=state, X1=key(32B), X2=nonce(12B), W3=counter

var CHACHA20_INIT_OFFSET = 0x5B818;

function hookChacha20Init() {
    var mod = Process.findModuleByName("libsec2026.so");
    if (!mod) {
        console.log("[-] libsec2026.so 未加载");
        return;
    }

    var funcAddr = mod.base.add(CHACHA20_INIT_OFFSET);
    console.log("[*] chacha20_init @ " + funcAddr);

    Interceptor.attach(funcAddr, {
        onEnter: function(args) {
            var state   = args[0];
            var key     = args[1];
            var nonce   = args[2];
            var counter = args[3].toInt32();

            console.log("\n════════ chacha20_init 被调用 ════════");
            console.log("  state   = " + state);
            console.log("  key     = " + key);
            console.log("  nonce   = " + nonce);
            console.log("  counter = " + counter);

            // Dump key (32 bytes)
            console.log("\n  [Key - 32 bytes]");
            console.log(hexdump(key, { length: 32, ansi: true }));

            try {
                var keyBytes = key.readByteArray(32);
                var ka = new Uint8Array(keyBytes);
                var keyPrintable = true;
                var keyStr = "";
                for (var i = 0; i < ka.length; i++) {
                    if (ka[i] < 0x20 || ka[i] >= 0x7f) keyPrintable = false;
                    keyStr += String.fromCharCode(ka[i]);
                }
                if (keyPrintable) {
                    console.log("  Key ASCII: " + keyStr);
                }
            } catch(e) {}

            // Dump nonce (12 bytes)
            console.log("\n  [Nonce - 12 bytes]");
            console.log(hexdump(nonce, { length: 12, ansi: true }));

            try {
                var nonceBytes = nonce.readByteArray(12);
                var na = new Uint8Array(nonceBytes);
                var noncePrintable = true;
                var nonceStr = "";
                for (var i = 0; i < na.length; i++) {
                    if (na[i] < 0x20 || na[i] >= 0x7f) noncePrintable = false;
                    nonceStr += String.fromCharCode(na[i]);
                }
                if (noncePrintable) {
                    console.log("  Nonce ASCII: " + nonceStr);
                }
            } catch(e) {}

            // 打印调用栈
            console.log("\n  [Backtrace]");
            console.log("  " + Thread.backtrace(this.context, Backtracer.FUZZY)
                .map(function(addr) {
                    var m = Process.findModuleByAddress(addr);
                    if (m) {
                        return m.name + "!0x" + addr.sub(m.base).toString(16);
                    }
                    return addr.toString();
                }).join("\n  "));

            console.log("══════════════════════════════════════\n");
        }
    });

    console.log("[+] chacha20_init hook 已安装");
}

var mod = Process.findModuleByName("libsec2026.so");
if (mod) {
    hookChacha20Init();
} else {
    var names = ["android_dlopen_ext", "dlopen"];
    var hooked = false;
    names.forEach(function(name) {
        var addr = Module.findExportByName(null, name);
        if (!addr || hooked) return;
        Interceptor.attach(addr, {
            onEnter: function(args) {
                try { this.lib = args[0].readUtf8String(); } catch(e) { this.lib = null; }
            },
            onReturn: function() {
                if (this.lib && this.lib.indexOf("libsec2026") !== -1) {
                    setTimeout(hookChacha20Init, 200);
                }
            }
        });
        hooked = true;
    });
    console.log("[*] 等待 libsec2026.so 加载...");
}

注意这个脚本需要在先跑起上获得flag的js代码后再 attach 上去，然后操控小车撞上黄色方块即可

果然传入的是这个 key 和 nonce

算法实现

flag生成算法与生成逆算法python实现如下

import struct
import sys

# Modified constants: "fxpaod 31-byse k" (instead of "expand 32-byte k")
CONSTANTS = [0x61707866, 0x3320646f, 0x79622d31, 0x6b206573]

# Key: 32 bytes at runtime vaddr 0xed5d2 (overwritten by outer SO packer)
# Original .data had 1a367ed4... but at runtime it's "Th1s ls n0t a rea1 key!!@sec2026"
KEY_BYTES = b"Th1s ls n0t a rea1 key!!@sec2026"

# Nonce: 12 bytes at runtime vaddr 0xed5f3 (overwritten by outer SO packer)
# Original .data had e485e46a... but at runtime it's "012345678901"
NONCE_BYTES = b"012345678901"

def u32(x):
    return x & 0xFFFFFFFF

def rotl32(x, n):
    return u32((x << n) | (x >> (32 - n)))

def quarter_round(state, a, b, c, d):
    """Standard ChaCha20 quarter round with rotations 16, 12, 8, 7"""
    state[a] = u32(state[a] + state[b]); state[d] ^= state[a]; state[d] = rotl32(state[d], 16)
    state[c] = u32(state[c] + state[d]); state[b] ^= state[c]; state[b] = rotl32(state[b], 12)
    state[a] = u32(state[a] + state[b]); state[d] ^= state[a]; state[d] = rotl32(state[d], 8)
    state[c] = u32(state[c] + state[d]); state[b] ^= state[c]; state[b] = rotl32(state[b], 7)

def chacha20_block(state):
    """Generate one 64-byte keystream block"""
    working = list(state)
    for _ in range(10):  # 20 rounds = 10 double-rounds
        # Column rounds
        quarter_round(working, 0, 4, 8, 12)
        quarter_round(working, 1, 5, 9, 13)
        quarter_round(working, 2, 6, 10, 14)
        quarter_round(working, 3, 7, 11, 15)
        # Diagonal rounds
        quarter_round(working, 0, 5, 10, 15)
        quarter_round(working, 1, 6, 11, 12)
        quarter_round(working, 2, 7, 8, 13)
        quarter_round(working, 3, 4, 9, 14)
    # Add original state
    output = [u32(working[i] + state[i]) for i in range(16)]
    return output

def chacha20_init(key, nonce, counter=0):
    """Initialize ChaCha20 state"""
    state = list(CONSTANTS)
    # Key: 8 x u32 LE
    state.extend(struct.unpack('<8I', key))
    # Counter
    state.append(counter)
    # Nonce: 3 x u32 LE
    state.extend(struct.unpack('<3I', nonce))
    return state

def chacha20_encrypt(key, nonce, plaintext, counter=0):
    """Encrypt/decrypt with modified ChaCha20"""
    state = chacha20_init(key, nonce, counter)
    result = bytearray()
    offset = 0
    
    while offset < len(plaintext):
        block = chacha20_block(state)
        keystream = b''.join(struct.pack(', w) for w in block)
        
        # XOR plaintext with keystream
        chunk_size = min(64, len(plaintext) - offset)
        for i in range(chunk_size):
            result.append(plaintext[offset + i] ^ keystream[i])
        
        offset += chunk_size
        state[12] = u32(state[12] + 1)  # Increment counter
    
    return bytes(result)

def xor_enc(plain: str) -> bytes:
    """GDScript xor_enc: chain XOR on 8-byte UTF-8 buffer (trigger.gd)
    
    for i in range(7): result[i] ^= result[i+1]
    result[7] ^= result[0]   # uses already-modified result[0]
    """
    buf = bytearray(plain.encode('utf-8'))
    if len(buf) < 8:
        buf.extend(b'\x00' * (8 - len(buf)))
    result = bytearray(buf[:8])
    for i in range(7):
        result[i] ^= result[i + 1]
    result[7] ^= result[0]
    return bytes(result)

def xor_dec(enc_bytes: bytes) -> str:
    """Inverse of xor_enc: recover original 8-char token from XOR'd bytes"""
    result = bytearray(enc_bytes[:8])
    # Reverse: undo result[7] ^= result[0], then undo i=6..0
    result[7] ^= result[0]
    for i in range(6, -1, -1):
        result[i] ^= result[i + 1]
    return result.decode('utf-8', errors='replace')

def token_to_flag(token: str) -> str:
    """Convert 8-char token to flag (16 hex chars)
    
    Matches game flow: xor_enc(token) -> chacha20_encrypt -> hex_upper
    """
    preprocessed = xor_enc(token)
    encrypted = chacha20_encrypt(KEY_BYTES, NONCE_BYTES, preprocessed)
    return ''.join(f'{b:02X}' for b in encrypted)

def flag_to_token(flag: str) -> str:
    """Convert flag (16 hex chars) back to token"""
    flag_bytes = bytes.fromhex(flag)
    decrypted = chacha20_encrypt(KEY_BYTES, NONCE_BYTES, flag_bytes)
    return xor_dec(decrypted)

# Test
if __name__ == '__main__':
    print("=== Modified ChaCha20 Flag Generator ===")
    print(f"Constants: {' '.join(f'0x{c:08x}' for c in CONSTANTS)}")
    print(f"Key: {KEY_BYTES.hex()}")
    print(f"Nonce: {NONCE_BYTES.hex()}")
    print()
    
    # Show initial state
    state = chacha20_init(KEY_BYTES, NONCE_BYTES, 0)
    print("Initial state:")
    for i in range(4):
        print(f"  [{i*4:2d}-{i*4+3:2d}]: {' '.join(f'{state[i*4+j]:08x}' for j in range(4))}")
    print()
    
    # Generate one keystream block for verification
    block = chacha20_block(state)
    print("First keystream block:")
    for i in range(4):
        print(f"  [{i*4:2d}-{i*4+3:2d}]: {' '.join(f'{block[i*4+j]:08x}' for j in range(4))}")
    
    keystream = b''.join(struct.pack(', w) for w in block)
    print(f"\nKeystream bytes: {keystream[:16].hex()}")
    print()
    
    # Test with sample tokens
    test_tokens = ["4b37a5c4", "f54b25f4", "testtest", "aabbccdd"]//在这里改输入的token
    for token in test_tokens:
        enc = xor_enc(token)
        flag = token_to_flag(token)
        recovered = flag_to_token(flag)
        print(f"Token: {token} -> xor_enc: {enc.hex()} -> Flag: {flag} -> Recovered: {recovered}")
    
    print()
    
    # Interactive mode
    if len(sys.argv) > 1:
        if sys.argv[1] == '-t' and len(sys.argv) > 2:
            # Token to flag
            token = sys.argv[2]
            print(f"Flag: {token_to_flag(token)}")
        elif sys.argv[1] == '-f' and len(sys.argv) > 2:
            # Flag to token
            flag = sys.argv[2]
            print(f"Token: {flag_to_token(flag)}")
        else:
            print(f"Usage: {sys.argv[0]} -t   or  -f ")

C语言实现如下

#include 
#include 
#include 
#include 

#define CHACHA_BLOCK_SIZE 64

static const uint32_t CONSTANTS[4] = {
    0x61707866, 0x3320646f, 0x79622d31, 0x6b206573
};

static const uint8_t KEY_BYTES[32] = {
    'T','h','1','s',' ','l','s',' ','n','0','t',' ','a',' ','r','e',
    'a','1',' ','k','e','y','!','!','@','s','e','c','2','0','2','6'
};

static const uint8_t NONCE_BYTES[12] = {
    '0','1','2','3','4','5','6','7','8','9','0','1'
};

static uint32_t rotl32(uint32_t x, int n) {
    return (x << n) | (x >> (32 - n));
}

static uint32_t load32_le(const uint8_t *p) {
    return ((uint32_t)p[0]) |
           ((uint32_t)p[1] << 8) |
           ((uint32_t)p[2] << 16) |
           ((uint32_t)p[3] << 24);
}

static void store32_le(uint8_t *p, uint32_t v) {
    p[0] = (uint8_t)(v & 0xff);
    p[1] = (uint8_t)((v >> 8) & 0xff);
    p[2] = (uint8_t)((v >> 16) & 0xff);
    p[3] = (uint8_t)((v >> 24) & 0xff);
}

static void quarter_round(uint32_t state[16], int a, int b, int c, int d) {
    state[a] += state[b]; state[d] ^= state[a]; state[d] = rotl32(state[d], 16);
    state[c] += state[d]; state[b] ^= state[c]; state[b] = rotl32(state[b], 12);
    state[a] += state[b]; state[d] ^= state[a]; state[d] = rotl32(state[d], 8);
    state[c] += state[d]; state[b] ^= state[c]; state[b] = rotl32(state[b], 7);
}

static void chacha20_init(uint32_t state[16], const uint8_t key[32], const uint8_t nonce[12], uint32_t counter) {
    state[0] = CONSTANTS[0];
    state[1] = CONSTANTS[1];
    state[2] = CONSTANTS[2];
    state[3] = CONSTANTS[3];

    for (int i = 0; i < 8; i++) {
        state[4 + i] = load32_le(key + i * 4);
    }

    state[12] = counter;
    state[13] = load32_le(nonce + 0);
    state[14] = load32_le(nonce + 4);
    state[15] = load32_le(nonce + 8);
}

static void chacha20_block(const uint32_t input[16], uint32_t output[16]) {
    uint32_t working[16];
    memcpy(working, input, sizeof(working));

    for (int i = 0; i < 10; i++) {
        quarter_round(working, 0, 4, 8, 12);
        quarter_round(working, 1, 5, 9, 13);
        quarter_round(working, 2, 6, 10, 14);
        quarter_round(working, 3, 7, 11, 15);

        quarter_round(working, 0, 5, 10, 15);
        quarter_round(working, 1, 6, 11, 12);
        quarter_round(working, 2, 7, 8, 13);
        quarter_round(working, 3, 4, 9, 14);
    }

    for (int i = 0; i < 16; i++) {
        output[i] = working[i] + input[i];
    }
}

static void chacha20_encrypt(
    const uint8_t key[32],
    const uint8_t nonce[12],
    const uint8_t *plaintext,
    size_t plaintext_len,
    uint8_t *ciphertext,
    uint32_t counter
) {
    uint32_t state[16];
    chacha20_init(state, key, nonce, counter);

    size_t offset = 0;
    while (offset < plaintext_len) {
        uint32_t block_words[16];
        uint8_t keystream[CHACHA_BLOCK_SIZE];

        chacha20_block(state, block_words);
        for (int i = 0; i < 16; i++) {
            store32_le(keystream + i * 4, block_words[i]);
        }

        size_t chunk_size = (plaintext_len - offset < CHACHA_BLOCK_SIZE)
            ? (plaintext_len - offset)
            : CHACHA_BLOCK_SIZE;

        for (size_t i = 0; i < chunk_size; i++) {
            ciphertext[offset + i] = plaintext[offset + i] ^ keystream[i];
        }

        offset += chunk_size;
        state[12] += 1;
    }
}

static void xor_enc(const char *plain, uint8_t out[8]) {
    size_t len = strlen(plain);
    memset(out, 0, 8);

    if (len > 8) len = 8;
    memcpy(out, plain, len);

    for (int i = 0; i < 7; i++) {
        out[i] ^= out[i + 1];
    }
    out[7] ^= out[0];
}

static void xor_dec(const uint8_t enc[8], char out[9]) {
    uint8_t buf[8];
    memcpy(buf, enc, 8);

    buf[7] ^= buf[0];
    for (int i = 6; i >= 0; i--) {
        buf[i] ^= buf[i + 1];
    }

    memcpy(out, buf, 8);
    out[8] = '\0';
}

static void bytes_to_hex_upper(const uint8_t *in, size_t len, char *out) {
    static const char HEX[] = "0123456789ABCDEF";
    for (size_t i = 0; i < len; i++) {
        out[i * 2]     = HEX[(in[i] >> 4) & 0xF];
        out[i * 2 + 1] = HEX[in[i] & 0xF];
    }
    out[len * 2] = '\0';
}

static int hex_value(char c) {
    if ('0' <= c && c <= '9') return c - '0';
    if ('a' <= c && c <= 'f') return c - 'a' + 10;
    if ('A' <= c && c <= 'F') return c - 'A' + 10;
    return -1;
}

static int hex_to_bytes(const char *hex, uint8_t *out, size_t out_len) {
    size_t hex_len = strlen(hex);
    if (hex_len != out_len * 2) return -1;

    for (size_t i = 0; i < out_len; i++) {
        int hi = hex_value(hex[i * 2]);
        int lo = hex_value(hex[i * 2 + 1]);
        if (hi < 0 || lo < 0) return -1;
        out[i] = (uint8_t)((hi << 4) | lo);
    }
    return 0;
}

static void token_to_flag(const char *token, char flag_hex[17]) {
    uint8_t preprocessed[8];
    uint8_t encrypted[8];

    xor_enc(token, preprocessed);
    chacha20_encrypt(KEY_BYTES, NONCE_BYTES, preprocessed, 8, encrypted, 0);
    bytes_to_hex_upper(encrypted, 8, flag_hex);
}

static int flag_to_token(const char *flag_hex, char token[9]) {
    uint8_t flag_bytes[8];
    uint8_t decrypted[8];

    if (hex_to_bytes(flag_hex, flag_bytes, 8) != 0) {
        return -1;
    }

    chacha20_encrypt(KEY_BYTES, NONCE_BYTES, flag_bytes, 8, decrypted, 0);
    xor_dec(decrypted, token);
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s -t  | -f \n", argv[0]);
        return 1;
    }

    if (strcmp(argv[1], "-t") == 0) {
        char flag[17];
        token_to_flag(argv[2], flag);
        printf("%s\n", flag);
        return 0;
    }

    if (strcmp(argv[1], "-f") == 0) {
        char token[9];
        if (flag_to_token(argv[2], token) != 0) {
            fprintf(stderr, "Invalid flag hex.\n");
            return 1;
        }
        printf("%s\n", token);
        return 0;
    }

    fprintf(stderr, "Usage: %s -t  | -f \n", argv[0]);
    return 1;
}

使用如图所示

总结

学到很多新知识，感谢腾讯给的学习机会，不过考了太多加解密知识，让我有点措手不及，幸好今年初赛题目似乎比往年简单，或许是换了引擎的原因吧。希望能进决赛，继续加油吧！

第三届数信杯数据安全大赛初赛reverse wp

2026-02-28T07:28:00.000Z

起因

看到决赛通知我才想起来，初赛当时还有道题没做完，当时时间太紧了，压根没时间认真做啊🤣

题目如下：

工程师小王认识到前面开发的程序并不能保证对数据的安全存储，现在对处理程序进行了改进，这次能行吗?分析程序功能，解密文件获取原始数据，提交第8行第2列数据。

花指令去除

一开始跟进 main 函数就能发现 ida 没识别成功

在 0x4016F1 处能看到第一处

这样即可

第二处在 0x4012A5 处

同上处理

第三处在 0x4014E6 处

许久不见 call-ret 型的花指令了，这里真正的代码是从 0x4014F6 开始的，还原后如下

重新识别函数之后就能开心的读代码了

加密分析

三个加密逻辑都在函数 sub_40127A 中

循环左移 rol1

dest 数组就是从文件中读进来的明文数据

shellcode 自解密

注意他从明文的 0x339 开始取了两字节的数据作为 key

shellcode 数据

xor加密

shellcode 解密

很显然题目的重点就在第二重加密了，既然 shellcode 是要执行的，那就先把 shellcode 全部转为代码看看吧

入口部分

可以看到前几字节是正常的：

1
2
3

41 54                push r12
41 53                push r11
e8 45 00 00 00       call next

作用

1
2
3

push r12
push r11
call +0x45

这个 call 会：

把下一条指令地址压栈
跳到后面 0x45 字节处

数据区

前三条指令都是比较正常的，但后面就变的杂乱无章了，说明他们压根就不是正确的代码，他们很可能是需要解密的数据

call 落点

call 跳到这里：

1
2
3

41 5b              pop r11
4d 31 e4           xor r12, r12
45 31 c0           xor r8d, r8d

pop r11 拿到 call 返回地址。

也就是数据区首地址，所以 r11 = &encrypted_data

主循环

取一个加密字节

1	movzx eax, byte ptr [r11 + r12]

取 key

1	mov bl, [rsi + r8]

因为 r8 只能是 0 或 1 ，所以显然这里是取两字节的 key

异或解密

1	xor al, bl

所以最后的逻辑还原大概是这样

1
2
3

for (i = 0; i < 0x42; i++) {
    data[i] ^= key[i % 2];
}

爆破密钥

由于这段 shellcode 需要的 key 是从明文里来的，也就是说这个程序只能用来加密那个对应的文件（小王这么写是要准备提桶跑路吗🤣），所以只能进行爆破

要注意的一点是，数据区只有 0x42 的长度，在 0x4040EC 还有一段shellcode执行完之后的代码，注意到有两个 pop r11 的操作，但上面只有一个 push r11 的操作，所以解密之后的数据肯定有压栈的操作，这样可以缩小范围（虽然我是做出来之后看到了才想到的）

爆破代码如下：

from capstone import *

# 原始 Shellcode 数据
cipher_text = bytes([
    0x33, 0x3A, 0x33, 0x3D, 0x3A, 0x91, 0xBD, 0x26, 0x8D, 0xA1,
    0x3A, 0x91, 0xBD, 0x27, 0xFB, 0x92, 0x3B, 0xEF, 0x96, 0x91,
    0x72, 0x6E, 0x72, 0x27, 0xF1, 0x8A, 0x7D, 0x27, 0xFB, 0x95,
    0x3B, 0xEF, 0x91, 0x91, 0x72, 0x6E, 0x72, 0x27, 0xB3, 0x95,
    0x76, 0x27, 0xF1, 0x8D, 0x7D, 0x27, 0xB3, 0x8A, 0x76, 0x23,
    0x7B, 0x8D, 0x3E, 0xE7, 0xAA, 0x5A, 0x61, 0x6A, 0x76, 0x90,
    0xB2, 0x90, 0xB2, 0x2F, 0x29, 0x2F, 0x2E
])

def xor_decrypt(data, k1, k2):
    """双字节循环异或解密"""
    dec = bytearray()
    for i in range(len(data)):
        if i % 2 == 0:
            dec.append(data[i] ^ k1)
        else:
            dec.append(data[i] ^ k2)
    return bytes(dec)

def brute_force():
    # 初始化 Capstone x86-64 模式
    md = Cs(CS_ARCH_X86, CS_MODE_64)
    # 开启详细模式以过滤无效指令
    md.detail = True

    results = []

    print("[*] Starting brute force... this may take a minute.")

    for k1 in range(256):
        for k2 in range(256):
            decrypted = xor_decrypt(cipher_text, k1, k2)
            
            # 尝试反汇编
            insns = list(md.disasm(decrypted, 0x1000))
            
            if not insns:
                continue

            # 评估解密结果的质量
            score = 0
            bad_insn = False
            asm_code = []
            
            total_bytes_disassembled = 0
            
            for i in insns:
                mnemonic = i.mnemonic.lower()
                total_bytes_disassembled += len(i.bytes)
                
                # 排除不符合要求的指令（jmp, call, ret等控制流指令）
                if mnemonic.startswith('j') or mnemonic in ['call', 'ret', 'int', 'syscall']:
                    bad_insn = True
                    break
                
                # 数据处理指令加分
                if mnemonic in ['mov', 'xor', 'add', 'sub', 'lea', 'inc', 'dec', 'shl', 'shr', 'rol', 'ror', 'and', 'or']:
                    score += 1
                
                asm_code.append(f"{i.address:#x}:\t{i.mnemonic}\t{i.op_str}")

            # 如果反汇编覆盖率太低（说明中间有很多无法解析的机器码），则忽略
            if total_bytes_disassembled < len(cipher_text) * 0.8:
                continue

            if not bad_insn and score > 2: # 设定一个基本的指令密度阈值
                results.append({
                    'key': (k1, k2),
                    'score': score,
                    'asm': asm_code
                })

    # 按分数排序，输出最可能的解
    results.sort(key=lambda x: x['score'], reverse=True)

    print(f"[*] Found {len(results)} potential candidates.\n")
    
    for top in results[:5]: # 输出前5个最像的
        k1, k2 = top['key']
        print(f"================ Key: 0x{k1:02X} 0x{k2:02X} (Score: {top['score']}) ================")
        print("\n".join(top['asm']))
        print("-" * 50)

if __name__ == "__main__":
    brute_force()

结果如下：

最终的加密逻辑为

1	f(b) = ( nibble_swap(b-3) ^ 0x13 ) + 6

解密

最后写出解密代码如下：

import hashlib

xor_key = b"e6911c24"

with open('info_81bedab.ori.en', 'rb') as infile:
    cipher_data = infile.read()

buffer = bytearray(cipher_data)

for idx in range(len(buffer)):
    # 第一阶段：XOR
    buffer[idx] ^= xor_key[idx % 8]

    # 第二阶段：减6 -> XOR 0x13 -> 交换高低4位 -> 加3
    buffer[idx] = (buffer[idx] - 6) & 0xFF
    buffer[idx] ^= 0x13
    buffer[idx] = ((buffer[idx] & 0x0F) << 4) | ((buffer[idx] & 0xF0) >> 4)
    buffer[idx] = (buffer[idx] + 3) & 0xFF

    # 第三阶段：循环右移1位
    current = buffer[idx]
    buffer[idx] = ((current >> 1) | (current << 7)) & 0xFF

plain_data = bytes(buffer)

with open('info_81bedab.ori', 'wb') as outfile:
    outfile.write(plain_data)
    print("done")

解密结果如图：

参考链接：

https://www.cnblogs.com/lantern-lab/p/19430548/2025-the-3rd-shuxin-cup-qxcuc#%E6%95%B0%E6%8D%AE%E5%AD%98%E5%82%A82%E6%B2%A1%E5%81%9A%E5%87%BA%E6%9D%A5

DASCTF2025下半年赛 reverse Writeup

2025-12-08T07:28:00.000Z

ezmac

总共就没几个函数，定位到 sub_10000045C 函数，调用 sub_100000634 ，传入 a6 参数为 57

sub_100000634 只做了异或操作

找到密文 byte_100004022 即可解密

exp

enc = "7D7B687F69784478722174767522267B7C7E787A2E2D7F2D"
a = 57
for i in range(len(enc)//2):
    byte = int(enc[2*i:2*i+2], 16)
    decoded_byte = byte ^ a
    a = a + 1
    print(chr(decoded_byte), end='')
    
# DASCTF{83c720da35436cc0}

androidfff

解压在 /lib 里就看到 flutter 特征，Blutter 直接解就好了，app 名字叫 untitled3 ，那就去 asm/untitled3/main.dart 里找，根据 ui 里的 incorrect 去定位关键逻辑

上下翻翻得到关键信息

现在去恢复 libapp.so 里的符号表，搜索 flagcheck 出来也没几个函数

在 untitled3_main__FlagCheckerState::ctor_2f7c1c 里找到密文，记得要除2，原因在第一篇博客里解释过了

在 untitled3_main__FlagCheckerState::_xorEncrypt_29cb18 里找到异或操作

得到 flag：DASCTF{flutter_is_so_easy}

androidfile

jeb 打开，在 MainActivity 找到逻辑，注意到 AES 加密标志

仔细看这里的字符串和题目txt中给的公钥私钥是一样的

直接进 i0.a 函数看

看来原来的数据应该是有 enkey 和 eniv 字段的，那看来 AES 是最后一重加密，继续跟进 B

回到了 MainActivity ，发现是调用了个 native 函数，继续跟进看看，在 libandroidfile.so 里定位到 Java_com_dasctf_androidfile_MainActivity_a_1p

可以看出是个 rc4 加密，密钥是 REVERSE ，最后进行 base64 编码

接下来用 RSA 公私钥解 enkey 和 eniv ，再用他们解 AES 即可

exp

from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import unpad
from base64 import b64decode

# === 输入 ===
enkey_b64 = '''QMz2qirA80LJiOs30Efl00JsrIv+ZdrM9iB74P/nCWOrzEemEOaq2lN1/V5/rOAoTgBanJO/AcpookhVIOVdsA=='''
eniv_b64  = '''hKH/M/v8zwVICeWlc652BZk2eA/c2g0cLpBwvWBVlphiwBBasdn9HPWk7sb/IaRh8eppZrToUwz6f1eomFJkEQ=='''
aes_ct_b64 = '''UBUSWb+1P3Z/aokV67e5xQ7eaHoEj3JAeC0XA1RckTWdWZYCB/+D7qC3Hao74goX'''

private_key_pem = '''-----BEGIN PRIVATE KEY-----
MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAncB8BH4egqfyJBoV
PzGNIuQl/64e5fl1If+CwtICWoiRV4AMfHuiREB+XlTawJ7QD/ZJj2wO6sY4sdNh
yYcC4QIDAQABAkEAh81Gdg+kcFHoD9AsbkRX/atuUtcwXkYL4gK2LMThpdEFHIO7
Scr+SYfwqmm/LMtkbojEGEnNoIfmoLvGfhXaAQIhANDWo8OSMSQFnvh129cFiVfY
KlS4ec24ixvFD8fUD4SRAiEAwWBuZ3kox1n21AsTAxom+E3z5KUUOSUjPXvG6tZB
gVECIDOP2y0tSi6/qIll6BqFxmxG9eSnC4PMfaQkmonXBOHRAiBmJUPsUGmj8/eX
xknCp7vSCYs9SZ3HGcDlp05Jmed8IQIhAJnE1PNe9lC5OazgRYhSG6bGCTbfFHT6
OuwCVIxRSx4P
-----END PRIVATE KEY-----'''

# ==== Step 1: Base64 decode ====
enkey = b64decode(enkey_b64)
eniv  = b64decode(eniv_b64)
aes_ct = b64decode(aes_ct_b64)

# ==== Step 2: RSA Raw Decrypt ====
key = RSA.import_key(private_key_pem)

def rsa_raw_decrypt_raw(data):
    decrypted_int = pow(int.from_bytes(data, "big"), key.d, key.n)
    decrypted = decrypted_int.to_bytes((key.size_in_bits() + 7) // 8, "big")
    return decrypted

# 得到原始解密（包含前导 zeros）
raw_key = rsa_raw_decrypt_raw(enkey)
raw_iv  = rsa_raw_decrypt_raw(eniv)

# ==== Step 3: 真正 AES key / IV 是最后 16 bytes ====
aes_key = raw_key[-16:]
aes_iv  = raw_iv[-16:]

print("[+] AES Key =", aes_key)
print("[+] AES IV  =", aes_iv)

# ==== Step 4: AES-CBC 解密 ====
cipher = AES.new(aes_key, AES.MODE_CBC, aes_iv)
pt_padded = cipher.decrypt(aes_ct)
pt = unpad(pt_padded, 16)

print("\n[+] Plaintext =", pt.decode())

"""
[+] AES Key = b'ElmGJYfKbc2gJh0G'
[+] AES IV  = b'JZ4tQgwSm3ZZIELJ'

[+] Plaintext = DASCTF{android_encrypto_file_and_plains}
"""

先看服务端文件，在 sub_29C0 定位到关键逻辑

服务段先发送 inp u account ，rc4 加密后发送出去

接收到客户端信息，会先解一次 rc4

接着和数组 byte_C1A0 进行比较，错误则提示 back door...

同时还需要验证 key ，逻辑相同，最后比较的数组是 byte_C0A0

这两个数组都是会进行 RSA 解密的，对应的函数都是 sub_73B2

而这里这么多参数，不用去分析程序逻辑，直接计算验证就能分出，谁是n，谁是d

别说d了，甚至p和q都给了

直接解密即可

exp

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import binascii

# 密钥参数（n, e, d）
n = 0x9a49428cadd84b7a81cb80f916e645a6a9dd23c2fe679f93af6a77eff0f0bb1309b77fb7861275f07ab41e98ae5c2ecf933f27d47b9ce0a55a3e06569cacbb4c9183f8ee9a47f2cfbb3a5965c9326f45d2d608cfeabea1a1879eae95b70224d2e7736b9bc4109756f55a3f70f11a9b9c6564fb6456d329c336fbb59859db5fde1f2338294e863c4f05b4a89e6c3b761d52a2081a0af0a320fde831daa741fad77aa7ef2dd30b3e33d1a6e7b44ed44ef40de4557a4fd65b63db63d105386bbd81071739ec3d0fe44b6a0952a2b065bededfecea6e22229fea32adfc9a6e2ccfdf5da437a56ad41d7ef08c2c4635d3a0218aab2a5ed6e9dd42d684bc918efe24d3
d = 0x28c7df24a5798679db2a44979275f5f3179db180d91335702942fb1b70e985de825da90f2eb65d20ddf8be1d9d4e15bc1d84e95795ff8c0c28ce3c33fde054f6e82a4f4cc22597b350c9c62ccc0188bd4152a701a3601558f22aa9fae8b9fdac6c2bc09b1637f71e0511805e04b203c4fdb2b36ad232fe819b06ed4e57c74f39fd9b72623c16ff2100f148f622bf12876260c4859672360dc0da3da6b45c5c8c6215ccda072765840c213fba11a91d6bf598a8a8065797566c8950a34ea0a072a9ed0c38bdc58662f186ec578ca55d5098443fd566cc722ace9c4e89afc4e302c8a4870e11a003b935f4a102695bfd64bb0fa74dcc372682e2b24ff45a1a69
e = 0x10001

# 密文 HEX（c1、c2）
c1 = "373A2A27B38FD778C716728EBB95BE89A0A057109119A08D5CE49261EBB0E0776D254A40C4D21BD2463E61608771DE401EED13AC6660D996BEA8C8B82BDD0EAF56C38466776EBA31F7B2219230B654A77EC0AF395A01C31C139A4F6B7B8BA845192096165DD7ACD0331E79DBE434ED8C9A66581D26F69E5FAA295F66010076B91A6DD61DB7ABD325F8BD25D928DEBCC02E5555FF81F7AE3E548E3E4659A37F5D3D3C39FBCAD1B583E42FB04FA328EBB77E7841F45B711E77EE23E11989DB2C0E06B8191A456D56BD1A7D42C47FDFDF1179228B57C6EFCA9B9B6A7D22682E5B67C7C46A877FB677F5F317B4823FCDC812F0362BE27C0F5453037148ED30127B26"
c2 = "1638E0EB936140B5527033292CBEFCD73B55CFC7FB79DF51AE3768A0DD9C84AE4580E47A5133B425F4C93EAC97E4B1AA0B4CD30589D004F6D0D19FCBC709E86CC2996B433D29F650B69987A466F05BEF7F69945860DCC44742A511F3621385C89FBD4D73153615789634B25CFC3151A4115BC30C96979E5F965290F36A863E3378B5CFC9BA31438C4BAE22B23EF815EDF7CF1771803BD392A5072B468900B75F5A4377D1DAF3D6F7B7B6850D1A4A4134F2F65840EFAA9B83D31083051DF0FC80A786529159484F62BBB9524F68285F48C7AB8E03BDFECA1A6025AAED9F9728B390689C0C963920C728EB5695FCB9413F9F4E06D3B93DB40E26D6275C84E6126A"

# 构造 RSA 私钥
key = RSA.construct((n, e, d))
cipher = PKCS1_OAEP.new(key)

# 解密并输出
try:
    m1 = cipher.decrypt(bytes.fromhex(c1))
    print("[+] m1 解密成功:", m1)
except Exception as err:
    print("[-] 解密 m1 出错:", err)

try:
    m2 = cipher.decrypt(bytes.fromhex(c2))
    print("[+] m2 解密成功:", m2)
except Exception as err:
    print("[-] 解密 m2 出错:", err)

"""
[+] m1 解密成功: b'qqwweerrttyyuuii'
[+] m2 解密成功: b'aassddffgghhjjll'
"""

得到两个字符串，不知道怎么使用，该去客户端看看了，在关键词 passwd 找到函数 sub_49DD ，各种特征都显示是标准 AES 加密

那两个字符串看来一个是 iv ，一个是 key 了，密文就是 server 里的数组 byte_C2A0

flag ：DASCTF{dqmaxfwkm921kr21m;df1m1dqmlk1d12d1}

总结

题目难度还算不大，不过用来给我爽玩一个月之后的复健还是够用了(●’◡’●)

WMCTF2025-Want2BecomeMagicalGirl 复现

2025-10-15T08:57:59.000Z

作者彩蛋

将 apk 拖入模拟器，没想到是流氓软件，这就是魔法少女吗/(ㄒoㄒ)/~~

作者好中二😄

魔改 AES 加密

Jadx 打开找到 MainActivity ，很明显的 flutter 特征，同时还有一个 Magic 类，里面是标准的 xxtea ，最后定位是在 encryptToBase64()，这个加密函数无人调用，说明是在 native 层进行调用的

先不管 Java 层的加密，去恢复 libapp.so 的符号和 dart 源码等

在 /asm/magical_girl 里看到这些文件，看到这里就已经确定是 aes 加密了。

S 盒

据 GPT 所说 main.dart 里只有 Flutter 应用的启动过程，而在 aes_crypt_null_safe.dart 中，可以看到 aes 加密代码，但是这些汇编代码太难看了，GPT 也分析不出什么，所以应该到 ida 里去看这些代码。

而在这里的汇编中，已经标准好了这段代码对应的地址，我们在 libapp.so 可以找到

对应到函数 magical_girl_aes_crypt_null_safe__Aes::_subBytes_2901b8()

数一下这里的赋值操作，正好有 256 个，那是 S 盒无疑了。

Dart 在ida中的数值问题

但是为什么会有超过 255(0xFF) 的呢。

这是因为虽然 Dart 中一切皆为 Object，但是实际 Dart 在也是有底层优化的。

在 Dart 中最最常见的就是 int 类型。

int 分两种类型：

1.smi: 对于小数值的数字，Dart直接将原数值左移一位。

2.bigint: 对于大数值，Dart构建对象，其数值在对象偏移+7处。

这里一个字节的值显然是小数值，所以在底层硬编码时被左移了一位，现在需要右移回来。

顺便随便搜一些和 aes 有关的东西，搜到了如下，大致确定他是 ecb 模式的 aes 。

加密逻辑

既然改了 S 盒，那肯定要检查一下是不是在加密逻辑上也进行了更改，同样定位到对应的代码逻辑，发现果然

在 magical_girl_aes_crypt_null_safe__Aes::aesEncryptBlock_28d5bc() 中，注意到

他先做了轮密钥加，再做列混淆，颠倒了加密顺序。其他加密代码中倒是没有发现别的更改。

在 EditView.dart 文件中，找到了 check 逻辑，同时还有找到了密文。

You have become a magical girl ! !

这里注意到最后的密文是 Base64 格式的，而我们在 Java 看到的最后一层编码也是 Base64 ，可以猜测先是 native 层做 aes 加密，然后在 Java 层做 xxtea 加密。

根据 ai 的提示，现在去 libnative_add.so 找密钥，惊喜发现 libnative_add.so 没有抹符号表。

在 genkey() 中，使用标准 rc4 加密生成的 key ，成功得到密钥

aes 此时就成功的分析完了。

魔改 xxtea 加密

在 init_proc() 中，看到了非常多的 NEON SIMD 指令处理数据的代码，让 ai 写出字符解密代码

import ida_bytes, ida_name

# 固定向量，根据你前面提供的数据
l = [0xF0] * 16
shellcode_end = [0x0D, 0x0E, 0x0F, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
                 0x06, 0x07, 0x05, 0x04, 0x02, 0x00, 0x00, 0x00]

# 所有在 init_proc 里出现的表
tables = [
    "xmmword_10100", "xmmword_10110", "xmmword_10120", "xmmword_10130",
    "xmmword_10140", "xmmword_10150", "xmmword_10160", "xmmword_10170",
    "xmmword_10180", "xmmword_10190", "xmmword_101A0", "xmmword_101B0",
    "xmmword_101C0", "xmmword_101D0", "xmmword_101E0", "xmmword_101F0",
    "xmmword_10200", "xmmword_10210", "xmmword_10230", "xmmword_10240",
    "xmmword_10250", "xmmword_10260", "xmmword_10270"
]

# ---------- 基础函数 ----------
def read_bytes(ea, size=16):
    return [ida_bytes.get_byte(ea + i) for i in range(size)]

def veorq_s8(v1, v2):
    return [(v1[i] ^ v2[i]) & 0xFF for i in range(16)]

def vqtbl1q_s8(table, index):
    return [(table[i] if i < len(table) else 0) for i in index]

def get_vector(label):
    ea = ida_name.get_name_ea(0, label)
    if ea == idaapi.BADADDR:
        print(f"[!] 找不到符号 {label}")
        return None
    return read_bytes(ea, 16)

def to_ascii(bs):
    out = []
    for b in bs:
        if 32 <= b < 127:
            out.append(chr(b))
        elif b == 0:
            out.append('\0')
    return ''.join(out)

# ---------- 主逻辑 ----------
decoded_total = []

for lbl in tables:
    tbl = get_vector(lbl)
    if not tbl:
        continue
    step1 = veorq_s8(l, shellcode_end)
    step2 = vqtbl1q_s8(tbl, shellcode_end)
    final = veorq_s8(step1, step2)
    s = to_ascii(final)
    print(f"{lbl:15s}: {s}")
    decoded_total.extend(final)

# ---------- 输出 ----------
joined = to_ascii(decoded_total)
print("\n======== 合并结果 ========\n")
print(joined)

得到解密结果如下

xmmword_10100  : EEbPNS_9ArtMeooo
xmmword_10110  : _ZN3art9ArtMeooo
xmmword_10120  : Lb0EEEbPNS_9AMMM
xmmword_10130  : PKNS_11Instruiii
xmmword_10140  : er12IsDebuggaeee
xmmword_10150  : _ZN3art11interrr
xmmword_10160  : b
xmmword_10170  : Ev
xmmword_10180  : dEPNS_6ThreadNNN
xmmword_10190  : onEtbPNS_6JVaeee
xmmword_101A0  : dERNS_11Shadorrr
xmmword_101B0  : lueE
xmmword_101C0  : _ZNK3art9OatHddd
xmmword_101D0  : S_11ShadowFraEEE
xmmword_101E0  : ethodEPNS_6Thaaa
xmmword_101F0  : gic.fi
xmmword_10200  : uctionEtPNS_6aaa
xmmword_10210  : d12PrettyMethEEE
xmmword_10230  : ameEPKNS_11Inrrr
xmmword_10240  : gic.toB
xmmword_10250  : libart.so
xmmword_10260  : E
xmmword_10270  : eter6DoCallILEEE

注意到解密之后有两个特殊的字符串，gic.fi 和 gic.toB ，查他们交叉引用，看到是在 sub_1A51C() 函数里被用到

而 sub_1A51C() 在函数 init_proc() 函数里有如下操作

我一开始做复现的时候就做到这里了，我到处翻找一直卡在这里，我认为是AES已经完全逆完了，这一段 init_proc() 的内容，大概是跟 Java 层那个没人调用的 encryptToBase64() 有关，那两个特殊字符串应该是提示，但是完全没领会到意思。官方 wp 里作者也没有给详细的解题思路（其实是没认真看官方 wp 里也写了 hook 了 DoCall函数😭），只好搁置。

后来题目作者在自己博客重新发了一篇详解

看到这里真是恍然大悟，(之前一直想找 ArtMethod::Invoke 函数，因为作者说像抽取壳，难怪卡住了)，现在赶紧去学一学安卓字节码执行的解释模式和 DoCall 函数。

学习后，按照我的理解如下

在 Android 的解释执行模式（Interpreter Mode）下，Java 字节码中的 invoke-* 指令最终就是通过 DoCall 函数（及其相关函数）来完成方法调用的执行的。

// Docall函数定义
template<bool is_range>
NO_STACK_PROTECTOR
bool DoCall(ArtMethod* called_method, //要被调用的方法（目标方法）
            Thread* self, // 当前线程对象
            ShadowFrame& shadow_frame, //当前解释器的 shadow frame（栈帧）
            const Instruction* inst, //当前字节码指令
            uint16_t inst_data, //解析指令所需的数据
            bool is_string_init, //是否是特殊处理的 String. 构造函数
            JValue* result)// 调用结果

而本题通过 hook DoCall 函数去得到内存中的 dex 文件，如作者所说

把内存中函数的字节码转为 Instruction* ，就可以利用其中函数读取操作码和操作数。那么通过 inst 拿到的指针就是 dex 的指针，只要把指针向前回溯到 dex 头就可以操作正在运行的整个 dex 文件。

而我们在ida里看到的sub_1A51C() ，正是 DoCall 的 onEnter 处理函数

知道了原理，我们很容易就可以看出来，，第一个 gic.fi 分支里的操作是对 dex 文件进行修改，而 gic.toB 分支里的操作是恢复 dex 文件，而 xmmword_41F60 显然是原始字节码的储存处。

既然这样，我们作者到题的思路就非常明显且简单了，要么在进入 gic.toB 分支前将 dex dump下来，要么去 trace Smali，对比看看他改了什么，当然最简单的思路是作者给出的。

第二次 strstr 后的还原逻辑 NOP 掉

这样，dex 文件就不会被改回去了。

我的做法相当暴力，我给里面的逻辑全 nop 了，如图

重新打包签名后，安装到手机上，随便输入一次按回车之后，我们直接使用 frida-dexdump 就能得到被修改之后的 dex 文件了

在这里我使用的是 hluda ，并且改了端口，因为不改会闪退，应该有端口检测，我做 Android 已经习惯用 hluda server 了，不知是不是绕过了其他检测

得到的 dex 如图

最后 xxtea 的 key 就很容易获得了，frida 脚本如下

// 使弹窗可关闭
Java.perform(function () {
    let a = Java.use("android.widget.Button");
    a["setEnabled"].implementation = function (enable) {
        console.log("Button set enable")
        this["setEnabled"](true);
    };
});
// 以上代码来自作者
Java.perform(function () {
    var Magic = Java.use("work.pangbai.magic.magical_girl.Magic");

    Magic.encrypt.overload('[B', '[B').implementation = function (bArr, bArr2) {
        // 打印第二个参数（bArr2）
        var keyBytes = Java.array('byte', bArr2);
        var keyStr = "";
        for (var i = 0; i < keyBytes.length; i++) {
            keyStr += String.fromCharCode(keyBytes[i] & 0xff);
        }

        console.log("[*] Hooked Magic.encrypt");
        console.log("    [+] 密钥 (bArr2) 原始字节: " + keyBytes);
        console.log("    [+] 密钥 (bArr2) 字符串形式: " + keyStr);

        // 调用原函数
        var result = this.encrypt(bArr, bArr2);
        return result;
    };
});

如图

最后我们的 exp 如下

import base64
import struct

def to_uint32_list(data, include_length):
    n = len(data) // 4
    v = list(struct.unpack('<' + 'I' * n, data[:n*4]))  # 保持你原先的小端
    if include_length:
        v.append(len(data))
    return v

def to_bytes(v, include_length):
    n = len(v)
    if include_length:
        m = v[-1]
        n = n - 1
    else:
        m = n << 2
    return struct.pack('<' + 'I' * n, *v)[:m]

def xxtea_decrypt(v, key):
    n = len(v)
    if n < 2:
        return v
    delta = 0x9e3779b9
    rounds = 6 + 52 * n
    s = (rounds * delta) & 0xffffffff
    y = v[0]
    while s:
        e = (s >> 2) & 3
        for p in range(n - 1, 0, -1):
            z = v[p - 1]
            mx = (((z >> 5) ^ (y >> 2)) + ((y >> 3) ^ (z >> 4))) ^ ((s ^ y) + (key[(p & 3) ^ e] ^ z))
            v[p] = (v[p] - mx) & 0xffffffff
            y = v[p]
        z = v[-1]
        mx = (((z >> 5) ^ (y >> 2)) + ((y >> 3) ^ (z >> 4))) ^ ((s ^ y) + (key[(0 & 3) ^ e] ^ z))
        v[0] = (v[0] - mx) & 0xffffffff
        y = v[0]
        s = (s - delta) & 0xffffffff
    return v

sbox = [ 
    0x20,0x7b,0x18,0xa7,0x42,0x44,0xd7,0x4a,0xcd,0x32,0xd1,0xec,0xf3,0x81,0xa5,0x89,
    0x0e,0x91,0x4b,0xf0,0xe9,0x5d,0x8d,0xf5,0x46,0xfc,0x31,0x36,0xb6,0xac,0x9b,0xb9,
    0x26,0x09,0xe6,0x40,0xd4,0xb0,0x51,0x4f,0x9c,0x3e,0xe7,0x79,0x30,0x88,0xb1,0x3c,
    0x7a,0x5c,0xd3,0x14,0x5a,0xab,0x56,0xc0,0x04,0x29,0xd0,0x3b,0x1f,0xf9,0xa3,0x57,
    0x00,0x8a,0x84,0x16,0xf4,0x1a,0xea,0x64,0xa6,0xd6,0x2e,0xbe,0x2f,0x17,0xc4,0xe0,
    0x1e,0x02,0x3a,0x22,0x8f,0x9f,0xcb,0xa8,0x2c,0x67,0x34,0x25,0xd5,0xff,0xef,0xf6,
    0xe2,0xaa,0xd9,0x72,0xfe,0xce,0xa1,0x78,0x85,0x96,0x2a,0x77,0xca,0xc1,0x37,0x74,
    0xa2,0x5e,0x6c,0xfd,0xb8,0x4d,0x7d,0x70,0xb3,0xdd,0xcf,0x71,0x73,0x61,0xf8,0x19,
    0x48,0xe3,0x63,0x33,0x3d,0x15,0xae,0x98,0xe5,0x80,0xbd,0xbc,0x82,0xc6,0x94,0x01,
    0xe4,0xde,0x06,0x50,0x95,0xdf,0x47,0xf7,0x90,0x8b,0x45,0x9a,0x6e,0x07,0xad,0x1c,
    0x35,0x83,0x68,0x03,0x6f,0x5b,0xb7,0xfb,0x1d,0xc5,0x10,0x7c,0xd8,0x6a,0xcc,0x69,
    0x8e,0x24,0x4c,0x39,0xb4,0xa0,0x0b,0x52,0xe8,0xa9,0xb2,0x8c,0x0a,0xbf,0x28,0x86,
    0x6d,0xaf,0xda,0x41,0xfa,0x75,0xb5,0x43,0xc3,0x60,0x62,0x2b,0x55,0xf2,0x9e,0x2d,
    0x12,0x23,0x0d,0xdb,0x6b,0xc7,0x38,0x7f,0x5f,0x97,0x08,0xed,0xe1,0xbb,0xee,0x9d,
    0xd2,0x92,0x49,0x3f,0xdc,0x58,0x87,0xc2,0xba,0x99,0xc9,0x4e,0xf1,0x21,0xeb,0x13,
    0x65,0x59,0x76,0x0c,0xc8,0x05,0xa4,0x54,0x93,0x1b,0x66,0x11,0x27,0x53,0x7e,0x0f
]
inv_sbox = [ 
    0x40,0x8f,0x51,0xa3,0x38,0xf5,0x92,0x9d,0xda,0x21,0xbc,0xb6,0xf3,0xd2,0x10,0xff,
    0xaa,0xfb,0xd0,0xef,0x33,0x85,0x43,0x4d,0x02,0x7f,0x45,0xf9,0x9f,0xa8,0x50,0x3c,
    0x00,0xed,0x53,0xd1,0xb1,0x5b,0x20,0xfc,0xbe,0x39,0x6a,0xcb,0x58,0xcf,0x4a,0x4c,
    0x2c,0x1a,0x09,0x83,0x5a,0xa0,0x1b,0x6e,0xd6,0xb3,0x52,0x3b,0x2f,0x84,0x29,0xe3,
    0x23,0xc3,0x04,0xc7,0x05,0x9a,0x18,0x96,0x80,0xe2,0x07,0x12,0xb2,0x75,0xeb,0x27,
    0x93,0x26,0xb7,0xfd,0xf7,0xcc,0x36,0x3f,0xe5,0xf1,0x34,0xa5,0x31,0x15,0x71,0xd8,
    0xc9,0x7d,0xca,0x82,0x47,0xf0,0xfa,0x59,0xa2,0xaf,0xad,0xd4,0x72,0xc0,0x9c,0xa4,
    0x77,0x7b,0x63,0x7c,0x6f,0xc5,0xf2,0x6b,0x67,0x2b,0x30,0x01,0xab,0x76,0xfe,0xd7,
    0x89,0x0d,0x8c,0xa1,0x42,0x68,0xbf,0xe6,0x2d,0x0f,0x41,0x99,0xbb,0x16,0xb0,0x54,
    0x98,0x11,0xe1,0xf8,0x8e,0x94,0x69,0xd9,0x87,0xe9,0x9b,0x1e,0x28,0xdf,0xce,0x55,
    0xb5,0x66,0x70,0x3e,0xf6,0x0e,0x48,0x03,0x57,0xb9,0x61,0x35,0x1d,0x9e,0x86,0xc1,
    0x25,0x2e,0xba,0x78,0xb4,0xc6,0x1c,0xa6,0x74,0x1f,0xe8,0xdd,0x8b,0x8a,0x4b,0xbd,
    0x37,0x6d,0xe7,0xc8,0x4e,0xa9,0x8d,0xd5,0xf4,0xea,0x6c,0x56,0xae,0x08,0x65,0x7a,
    0x3a,0x0a,0xe0,0x32,0x24,0x5c,0x49,0x06,0xac,0x62,0xc2,0xd3,0xe4,0x79,0x91,0x95,
    0x4f,0xdc,0x60,0x81,0x90,0x88,0x22,0x2a,0xb8,0x14,0x46,0xee,0x0b,0xdb,0xde,0x5e,
    0x13,0xec,0xcd,0x0c,0x44,0x17,0x5f,0x97,0x7e,0x3d,0xc4,0xa7,0x19,0x73,0x64,0x5d
]
rcon_words = [0x01000000,0x02000000,0x04000000,0x08000000,0x10000000,
              0x20000000,0x40000000,0x80000000,0x1B000000,0x36000000]

def LOAD32H(b, off):
    return ((b[off] << 24) | (b[off+1] << 16) | (b[off+2] << 8) | b[off+3]) & 0xFFFFFFFF

def BYTE(x, n):  # 低字节序提取第 n 个字节
    return (x >> (8 * n)) & 0xFF

def MIX(x):
    return ((sbox[BYTE(x,2)] << 24) ^ (sbox[BYTE(x,1)] << 16) ^
            (sbox[BYTE(x,0)] << 8) ^ (sbox[BYTE(x,3)])) & 0xFFFFFFFF

def key_expansion_words(key16):
    w = [0]*44
    for i in range(4):
        w[i] = LOAD32H(key16, 4*i)
    for round_idx in range(10):
        b = round_idx*4
        w[b+4] = (w[b] ^ MIX(w[b+3]) ^ rcon_words[round_idx]) & 0xFFFFFFFF
        w[b+5] = (w[b+1] ^ w[b+4]) & 0xFFFFFFFF
        w[b+6] = (w[b+2] ^ w[b+5]) & 0xFFFFFFFF
        w[b+7] = (w[b+3] ^ w[b+6]) & 0xFFFFFFFF
    return w  

def make_dec_key_words(eK):
    dK = [0]*44
    for j in range(11):
        src = (10 - j) * 4
        dst = j * 4
        dK[dst:dst+4] = eK[src:src+4]
    return dK

def load_state_array(block16):
    state = [[0]*4 for _ in range(4)]  
    idx = 0
    for col in range(4):
        for row in range(4):
            state[row][col] = block16[idx]
            idx += 1
    return state

def store_state_array(state):
    out = bytearray(16)
    idx = 0
    for col in range(4):
        for row in range(4):
            out[idx] = state[row][col]
            idx += 1
    return bytes(out)

def add_round_key(state, key_words4):
    for col in range(4):
        w = key_words4[col]
        for row in range(4):
            state[row][col] ^= BYTE(w, 3 - row)

def ROR32(x, n):
    n %= 32
    return ((x >> n) | ((x << (32 - n)) & 0xFFFFFFFF)) & 0xFFFFFFFF

def inv_shift_rows(state):
    for row in range(4):
        x = ((state[row][0] << 24) | (state[row][1] << 16) | (state[row][2] << 8) | state[row][3]) & 0xFFFFFFFF
        x = ROR32(x, 8 * row)
        state[row][0] = (x >> 24) & 0xFF
        state[row][1] = (x >> 16) & 0xFF
        state[row][2] = (x >> 8) & 0xFF
        state[row][3] = x & 0xFF

def inv_sub_bytes(state):
    for i in range(4):
        for j in range(4):
            state[i][j] = inv_sbox[state[i][j]]

def GMul(u, v):
    p = 0
    for _ in range(8):
        if u & 1:
            p ^= v
        flag = v & 0x80
        v = (v << 1) & 0xFF
        if flag:
            v ^= 0x1B
        u >>= 1
    return p

def inv_mix_columns(state):
    M = [
        [0x0E, 0x0B, 0x0D, 0x09],
        [0x09, 0x0E, 0x0B, 0x0D],
        [0x0D, 0x09, 0x0E, 0x0B],
        [0x0B, 0x0D, 0x09, 0x0E],
    ]
    tmp = [[state[i][j] for j in range(4)] for i in range(4)]
    for i in range(4):
        for j in range(4):
            state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j]) ^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j])

def aes_ecb_decrypt_all(ciphertext: bytes, key16: bytes) -> bytes:
    assert len(key16) == 16
    eK = key_expansion_words(key16)
    dK = make_dec_key_words(eK)

    out = bytearray()
    for off in range(0, len(ciphertext), 16):
        block = ciphertext[off:off+16]
        state = load_state_array(block)

        rk_idx = 0
        add_round_key(state, dK[rk_idx:rk_idx+4])
        for _round in range(1, 10):
            rk_idx += 4
            inv_shift_rows(state)
            inv_sub_bytes(state)
            inv_mix_columns(state)
            add_round_key(state, dK[rk_idx:rk_idx+4])

        inv_shift_rows(state)
        inv_sub_bytes(state)
        add_round_key(state, dK[rk_idx+4:rk_idx+8])

        out += store_state_array(state)
    return bytes(out)


def main():
    ciphertext_b64 = "8sAFX45zT7uc0vSUyFNNly1h/d5zTt89tV3kcVr5P5n7lRKPyYtxg31zYNB2lPV0c5nf/x2/IK94XV9Ufs9XfaDG5IXxMlZy+Z2nE+ZZRFBSpMoKzQXfUq2TSjJJfQxV"
    ciphertext = base64.b64decode(ciphertext_b64)
    key_bytes = b"16929"
    key_bytes = (key_bytes + b"\0"*16)[:16]
    key = list(struct.unpack('<4I', key_bytes))  
    v = to_uint32_list(ciphertext, False)
    v = xxtea_decrypt(v, key)
    ciphertext2 = to_bytes(v, False)
    ciphertext2 = bytes.fromhex(ciphertext2.decode())
    # print("XXTEA 解密结果：", ciphertext2.hex())
    aes_key = bytes.fromhex("7a25c524c6334c30f362afac3f2303d5")
    plaintext = aes_ecb_decrypt_all(ciphertext2, aes_key)
    print("AES 解密后:", plaintext)

if __name__ == "__main__":
    main()
# WMCTF{I_R4@11y_w@n7_70 _84c0m4_@_m@gic@1_Gir1}

参考文章

https://blog.wm-team.cn/index.php/archives/86/#Want2BecomeMagicalGirl

https://pangbai.work/CTF/Reverse/Want2BecomeMagicalGirl/

https://www.ctfiot.com/261979.html

Hello World

2025-10-06T13:42:23.898Z

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1	$ hexo new "My New Post"

More info: Writing

Run server

1	$ hexo server

More info: Server

Generate static files

1	$ hexo generate

More info: Generating

Deploy to remote sites

1	$ hexo deploy

More info: Deployment