AIS3 pre-exam 2025 Writeup#

Tomorin db 🐧#

瀏覽題目之後長這樣，然後直接點 flag 會跳轉到 YouTube，看了一下題目裡面的 main.go 原來是這樣啊

那就試試看 ./ 之類的路徑繞過吧，再來試試蠻常用的 URL Encode

成功拿到 flag！

題目大概就是一個登入介面，然後要輸入 2FA Code，照往常慣例先翻題目資料夾，恩？ docker-compose.yml 裡面怎麼有一個 .db 的檔案跟網站目錄掛一起，直接從網站戳戳看好了

直接連過去 http://login-screen.ctftime.uk:36368/users.db 竟然能下載下來！

接下來讓我來翻翻裡面有什麼欸怎麼有 admin 的 2FA Code，接下來塞進題目之後拿到 flag！

AIS3 Tiny Server - Web / Misc#

題目就是一個 Web Server 然後他說 flag 放在根目錄，反正就是目錄穿越或路徑逃脫，這裡是用 curl http://chals1.ais3.org:20580/%2e%2e/%2e%2e/%2e%2e/ 就是 ../../.. 加 URL Encoding 去試試看然後目錄底下有兩個跟 flag 相關的，一個是檔案，另一個可以直接 curl 出來，就拿到 flag 了

Ramen CTF#

題目有一張發票，那肯定是要找電子發票可以查資料的地方，先把他塞進一般性發票查詢 - 電子發票整合服務平台從左邊的發票 QRCode 可以得知發票號碼等必要查詢的資訊查詢之後結果就出來了 AIS3{樂山溫泉拉麵:蝦拉麵}

Welcome#

直接複製貼上的話就會被騙 AIS3{This_Is_Just_A_Fake_Flag_~~} 我的解法就是照著圖片手打然後就對了！

Flag: AIS3{Welcome_And_Enjoy_The_CTF_!}

SlowECDSA#

這題考的是 ECDSA 簽章系統的弱點，特別是當 nonce k 使用線性同餘生成器（LCG）時的攻擊。

題目使用 LCG 來產生簽章的 nonce：

LCG 參數：a = 1103515245, c = 12345
使用 NIST P-192 橢圓曲線
可以取得同一訊息的兩筆連續簽章

當我們有兩個使用連續 LCG 狀態簽署的訊息時：

s₁ = k₁⁻¹(H + r₁d) mod n
s₂ = k₂⁻¹(H + r₂d) mod n
其中 k₂ = ak₁ + c mod n (LCG 關係)

透過代數運算可得私鑰：

1
d = [H·(K−1) + c·s₂] · (r₂ − K·r₁)⁻¹ mod n
2
其中 K = a·s₂·s₁⁻¹ mod n

解題程式：

1
from hashlib import sha1
2
from Crypto.PublicKey.ECC import _curves
3
from Crypto.Util.number import inverse
4
import socket
5
import os
6

7
def solve_slowecdsa():
8
    # 連接伺服器
9
    s = socket.socket()
10
    s.connect(('chals1.ais3.org', 19000))
11

12
    # LCG 參數
13
    a = 1103515245
14
    c = 12345
15
    n = _curves['NIST P-192'].order
16

17
    # 取得兩組簽章
18
    def get_signature():
19
        s.recv(1024)  # 清除 buffer
20
        s.send(b"get_example\n")
21
        data = s.recv(1024).decode()
22
        r = int(data.split('r: ')[1].split('\n')[0], 16)
23
        sig_s = int(data.split('s: ')[1].split('\n')[0], 16)
24
        return r, sig_s
25

26
    r1, s1 = get_signature()
27
    r2, s2 = get_signature()
28

29
    # 計算訊息 hash
30
    H = int.from_bytes(sha1(b"example_msg").digest(), 'big') % n
31

32
    # 使用 LCG 關係推導私鑰
33
    s1_inv = inverse(s1, n)
34
    K = (a * s2 * s1_inv) % n
35

36
    numerator = (H * (K - 1) + c * s2) % n
37
    denominator = (r2 - K * r1) % n
38
    d = (numerator * inverse(denominator, n)) % n
39

40
    print(f"[+] 找到私鑰 d = {hex(d)}")
41

42
    # 使用私鑰簽署 "give me flag"
43
    msg = b"give me flag"
44
    H_flag = int.from_bytes(sha1(msg).digest(), 'big') % n
45

46
    # 產生新的 k（隨機）
47
    k = int.from_bytes(os.urandom(24), 'big') % n
48
    if k == 0:
49
        k = 1
50

51
    # ECDSA 簽章
52
    G = _curves['NIST P-192'].generator
53
    R = k * G
54
    r = R.x % n
55
    s = (inverse(k, n) * (H_flag + r * d)) % n
56

57
    # 送出驗證
58
    s.recv(1024)
59
    s.send(b"verify\n")
60
    s.recv(1024)
61
    s.send(msg + b"\n")
62
    s.recv(1024)
63
    s.send(hex(r).encode() + b"\n")
64
    s.recv(1024)
65
    s.send(hex(s).encode() + b"\n")
66

67
    # 接收 flag
68
    result = s.recv(1024).decode()
69
    print(result)
70
    s.close()
71

72
if __name__ == "__main__":
73
    solve_slowecdsa()

Random_RSA#

使用 LCG 產生隨機數，然後找下一個質數作為 p 和 q LCG 參數：a = 48271, c = 0, m = 2³¹ - 1 給了三個連續的 LCG 輸出 h0, h1, h2

從 h0, h1, h2 驗證 LCG 參數
模擬 LCG 序列，暴力搜尋能整除 n 的質數 p
標準 RSA 解密

解題程式：

1
from sympy import nextprime, isprime
2
from Crypto.Util.number import inverse, long_to_bytes
3
import re
4

5
def solve_random_rsa():
6
    # 解析輸出檔案
7
    with open('output.txt', 'r') as f:
8
        content = f.read()
9

10
    # 提取參數
11
    params = {}
12
    for match in re.findall(r'(\w+)=(\d+)', content):
13
        params[match[0]] = int(match[1])
14

15
    n = params['n']
16
    e = params['e']
17
    c = params['c']
18
    h0 = params['h0']
19

20
    # LCG 參數
21
    a = 48271
22
    m = (1 << 31) - 1
23

24
    # 從 seed 開始搜尋
25
    state = h0
26
    found = False
27

28
    print("[*] 開始搜尋質數 p...")
29
    for i in range(10000):
30
        # 生成下一個 LCG 狀態
31
        state = (a * state) % m
32

33
        # 找下一個質數
34
        p_candidate = nextprime(state)
35

36
        # 檢查是否能整除 n
37
        if n % p_candidate == 0:
38
            p = p_candidate
39
            q = n // p
40

41
            # 驗證 q 也是質數
42
            if isprime(q):
43
                print(f"[+] 找到 p = {p}")
44
                print(f"[+] 找到 q = {q}")
45
                found = True
46
                break
47

48
    if not found:
49
        print("[-] 搜尋失敗")
50
        return
51

52
    # RSA 解密
53
    phi = (p - 1) * (q - 1)
54
    d = inverse(e, phi)
55
    plaintext = pow(c, d, n)
56

57
    flag = long_to_bytes(plaintext).decode()
58
    print(f"[+] Flag: {flag}")
59

60
if __name__ == "__main__":
61
    solve_random_rsa()

Stream#

解法

1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3
"""
4
1. 讀取 81 行十六進位字串。
5
2. 對前 80 行逐 byte (0~255) 嘗試碰撞 SHA-512，找出唯一會讓 (cipher ^ digest) 成為完整 256-bit 平方數的 byte，
6
   進而推算出每行的 rand256。
7
3. 將 80 個 rand256 拆成 640 個 32-bit little-endian 輸出，餵進 RandCrack (逆向 MT19937)。
8
4. 取得下一個 rand256 (第 81 個)，再 XOR 平方即可還原 flag。
9
"""
10

11
import hashlib
12
import math
13
from pathlib import Path
14
from typing import List
15

16
# 可以自行調整的參數 #
17
OUTPUT_FILE = Path("output.txt")   # 題目給的密文檔案
18
DIGEST_CACHE = [hashlib.sha512(bytes([b])).digest() for b in range(256)]
19

20

21
# 一些逆向 MT19937 需要的小工具 #
22
def _undo_right(y: int, shift: int) -> int:
23
    """還原 y = x ^ (x >> shift)"""
24
    result = 0
25
    for i in range(32 // shift + 1):
26
        part = y >> (shift * i)
27
        result ^= part
28
    # 保留 32 bit
29
    return result & 0xFFFFFFFF
30

31

32
def _undo_left(y: int, shift: int, mask: int) -> int:
33
    """還原 y = x ^ ((x << shift) & mask)"""
34
    result = 0
35
    for i in range(32 // shift + 1):
36
        part = y << (shift * i)
37
        result ^= part & mask
38
    return result & 0xFFFFFFFF
39

40

41
def untemper(y: int) -> int:
42
    """逆向 CPython random 模組的 temper 步驟"""
43
    y = _undo_right(y, 18)
44
    y = _undo_left(y, 15, 0xEFC60000)
45
    y = _undo_left(y, 7, 0x9D2C5680)
46
    y = _undo_right(y, 11)
47
    return y
48

49

50
class RandCrack:
51
    """
52
    精簡版 RandCrack：送入 32-bit 輸出即可重建 MT19937 狀態，
53
    之後呼叫 predict_getrandbits(n) 產生任意 n-bit 亂數。
54
    """
55

56
    def __init__(self) -> None:
57
        self.state: List[int] = []
58
        self.index = 624  # 讓 twist() 在填滿 624 後才會動到
59

60
    def submit(self, value: int) -> None:
61
        """提交一個 32-bit 輸出"""
62
        assert 0 <= value < 2**32
63
        self.state.append(untemper(value))
64

65
    def _twist(self) -> None:
66
        """重現 MT 的 twist 步驟"""
67
        for i in range(624):
68
            y = (self.state[i] & 0x80000000) | (self.state[(i + 1) % 624] & 0x7FFFFFFF)
69
            self.state[i] = self.state[(i + 397) % 624] ^ (y >> 1)
70
            if y & 1:
71
                self.state[i] ^= 0x9908B0DF
72
        self.index = 0
73

74
    def _extract(self) -> int:
75
        """取出下一個 32-bit 值（同 random.getrandbits(32) 行為）"""
76
        if self.index >= 624:
77
            self._twist()
78
        y = self.state[self.index]
79
        self.index += 1
80

81
        # temper
82
        y ^= (y >> 11)
83
        y ^= (y << 7) & 0x9D2C5680
84
        y ^= (y << 15) & 0xEFC60000
85
        y ^= (y >> 18)
86
        return y & 0xFFFFFFFF
87

88
    #  對外介面 #
89
    def ready(self) -> bool:
90
        return len(self.state) >= 624
91

92
    def predict_getrandbits(self, k: int) -> int:
93
        """等同 random.getrandbits(k)"""
94
        assert self.ready(), "state incomplete"
95
        bits = 0
96
        for _ in range((k + 31) // 32):  # 每次抓 32 bit
97
            bits = (bits << 32) | self._extract()
98
        # 保留最低 k bit
99
        return bits & ((1 << k) - 1)
100

101

102
# 主要破解邏輯 #
103
def recover_rand256(cipher: int) -> int:
104
    """給定一行 cipher，嘗試所有 256 個 digest，找到唯一平方根 < 2**256"""
105
    for b in range(256):
106
        digest_int = int.from_bytes(DIGEST_CACHE[b], "big")
107
        candidate = cipher ^ digest_int
108
        root = math.isqrt(candidate)
109
        if root * root == candidate and root.bit_length() <= 256:
110
            return root
111
    raise ValueError("No square root found – 這不應該發生")
112

113

114
def split_le32(x: int) -> List[int]:
115
    """將 256-bit 整數拆成 8 個 32-bit little-endian 區段（與 random 實作對齊）"""
116
    return [(x >> (32 * i)) & 0xFFFFFFFF for i in range(8)]  # i=0 為最低位
117

118

119
def main() -> None:
120
    # 1. 讀檔 -> int list
121
    ciphers = [int(line.strip(), 16) for line in OUTPUT_FILE.read_text().strip().splitlines()]
122
    assert len(ciphers) == 81, "檔案行數錯誤，應該是 81 行"
123

124
    # 2. 還原前 80 個 rand256
125
    rand256_list = [recover_rand256(c) for c in ciphers[:80]]
126
    print(f"[+] 復原 rand256 數量：{len(rand256_list)}")
127

128
    # 3. 拆成 32-bit，餵給 RandCrack
129
    rc = RandCrack()
130
    for r in rand256_list:
131
        for chunk in split_le32(r):
132
            rc.submit(chunk)
133
    assert rc.ready(), "RandCrack 狀態尚未填滿 (理論上 624 個 chunk 就夠)"
134

135
    # 4. 產生第 81 個 rand256
136
    next_rand = rc.predict_getrandbits(256)
137
    print("[+] 預測下一個 rand256 完成")
138

139
    # 5. 解 flag
140
    flag_int = ciphers[80] ^ (next_rand ** 2)
141
    flag_len = (flag_int.bit_length() + 7) // 8
142
    flag = flag_int.to_bytes(flag_len, "big").decode()
143
    print(f"[!] Flag = {flag}")
144

145

146
if __name__ == "__main__":
147
    main()

1
$ python3 solve_flag.py
2
[+] 復原 rand256 數量：80
3
[+] 預測下一個 rand256 完成
4
[!] Flag = AIS3{no_more_junks...plz}

web flag checker#

下載 index.wasm 然後我先用 wasm-decompile 工具反編譯一次，然後分析主要檢查函數 func9

主要檢查函數是 flagchecker(a) 輔助的位旋轉函數是 f_i(a, b)

算法邏輯： Flag必須恰好40個字符分成5組，每組8字節使用常數 -39934163 計算每組的旋轉量對每組執行左旋轉操作與預設的5個64位目標值比較

1
**旋轉量計算**：
2
使用魔數 -39934163 計算每個區塊的旋轉位數：
3
- index 0: 45位
4
- index 1: 28位
5
- index 2: 42位
6
- index 3: 39位
7
- index 4: 61位
8

9
**逆向求解腳本**：
10
```python
11
def solve_wasm():
12
    # 從 WASM 提取的目標值
13
    targets = [
14
        0x6f773357449B13EB,
15
        0x316d6e317672337d,
16
        0x1f2fa8f18bdcbc59,
17
        0x5f1cdbcc3301ef9e,
18
        0x52e88e56c85dc5dc
19
    ]
20

21
    # 計算每個區塊的旋轉量
22
    magic_number = -39934163
23
    rotations = []
24
    for i in range(5):
25
        rotation = (magic_number >> (i * 6)) & 63
26
        rotations.append(rotation)
27

28
    print(f"旋轉量: {rotations}")  # [45, 28, 42, 39, 61]
29

30
    # 對每個目標值執行右旋轉（逆操作）
31
    flag_parts = []
32
    for i, (target, rot) in enumerate(zip(targets, rotations)):
33
        # 64-bit 右旋轉
34
        original = ((target >> rot) | (target << (64 - rot))) & 0xFFFFFFFFFFFFFFFF
35
        # 轉換為小端序 bytes
36
        flag_parts.append(original.to_bytes(8, 'little'))
37

38
    # 組合得到完整 flag
39
    flag = b''.join(flag_parts).decode('ascii')
40
    return flag
41

42
# 執行解題
43
flag = solve_wasm()
44
print(f"Flag: {flag}")

AIS3 Tiny Server - Reverse#

這題需要逆向一個實作了簡單 HTTP 伺服器的二進位檔。

分析步驟：

使用 IDA Pro 開啟 32-bit ELF 執行檔
找到 main function (sub_12B0)
追蹤 HTTP 請求處理邏輯
發現關鍵的 flag 驗證函數 sub_1E20

sub_1E20 反編譯結果：

1
*BOOL4 *_cdecl sub_1E20(int a1)
2
{
3
  unsigned int v1; // ecx
4
  char v2; // si
5
  char v3; // al
6
  int i; // eax
7
  char v5; // dl
8
  _BYTE v7[10]; // [esp+7h] [ebp-49h] BYREF
9
  _DWORD v8[11]; // [esp+12h] [ebp-3Eh]
10
  __int16 v9; // [esp+3Eh] [ebp-12h]
11
  v1 = 0;
12
  v2 = 51;
13
  v9 = 20;
14
  v3 = 114;
15
  v8[0] = 1480073267;
16
  v8[1] = 1197221906;
17
  v8[2] = 254628393;
18
  v8[3] = 920154;
19
  v8[4] = 1343445007;
20
  v8[5] = 874076697;
21
  v8[6] = 1127428440;
22
  v8[7] = 1510228243;
23
  v8[8] = 743978009;
24
  v8[9] = 54940467;
25
  v8[10] = 1246382110;
26
  qmemcpy(v7, "rikki_l0v3", sizeof(v7));
27
  while ( 1 )
28
  {
29
    *((_BYTE *)v8 + v1++) = v2 ^ v3;
30
    if ( v1 == 45 )
31
      break;
32
    v2 = *((_BYTE *)v8 + v1);
33
    v3 = v7[v1 % 0xA];
34
  }
35
  for ( i = 0; i != 45; ++i )
36
  {
37
    v5 = *(_BYTE *)(a1 + i);
38
    if ( !v5 || v5 != *((_BYTE *)v8 + i) )
39
      return 0;
40
  }
41
  return *(_BYTE *)(a1 + 45) == 0;
42
}

分析結果：

sub_1E20() 使用 XOR 來加密驗證 flag
密鑰是 “rikki_l0v3” (10 bytes)
v8 陣列包含加密後的資料

CleanShot 2025-06-05 at 07.41.43@2x

解密腳本：

1
def decrypt_tiny_server():
2
    # 從 IDA 提取的加密資料 (v8 陣列)
3
    encrypted_dwords = [
4
        1480073267, 1197221906, 254628393, 920154,
5
        1343445007, 874076697, 1127428440, 1510228243,
6
        743978009, 54940467, 1246382110
7
    ]
8

9
    # XOR 密鑰
10
    key = b"rikki_l0v3"
11

12
    # 轉換 DWORD 陣列為 bytes (little-endian)
13
    encrypted_bytes = b''
14
    for dword in encrypted_dwords:
15
        encrypted_bytes += dword.to_bytes(4, 'little')
16

17
    # 執行 XOR 解密
18
    decrypted = bytearray()
19
    for i in range(45):  # flag 長度為 45
20
        decrypted.append(encrypted_bytes[i] ^ key[i % 10])
21

22
    return decrypted.decode('ascii')
23

24
# 解密 flag
25
flag = decrypt_tiny_server()
26
print(f"Flag: {flag}")

Flag: AIS3{w0w_a_f1ag_check3r_1n_serv3r_1s_c00l!!!}