Cryptography

PROCEDURAL LABYRINTH

核心分两步:

  1. 解出从入口到出口的唯一路径
  2. 把这条路径转成 bit 流,再还原成 ASCII

迷宫字符只有:

  • #:墙
  • .:路
  • >:入口
  • <:出口

这种图最自然的做法就是把可走点当成图上的节点,跑 BFS / DFS 找路。

实际把路解出来后,会发现这题的“journey”不是让你看上下移动,而是看整条路径中的左右移动序列:

  • 向右 R 记作 0
  • 向左 L 记作 1
  • 上下移动不参与编码

把这些左右移动抽出来以后,bit 流已经很像可打印文本了。
再注意一下入口处有一个“进入迷宫”的前导水平移动,它不属于正文,因此
跳过第一个水平 bit,后面每 8 位转一个字节即可。

最后直接得到 flag。

文件前面几行是说明文字,真正的迷宫区是 701 行、每行 51 列的 # . > < 字符矩阵。

所以脚本里只要把满足:

  • 字符集合属于 # . > <
  • 行长一致

的部分提取出来即可。

把所有可走字符:

  • .
  • >
  • <

都视为 walkable。

然后从 > 开始 BFS,到 < 停止,并通过 prev 数组回溯整条路径。

拿到路径后,逐步比较相邻两点:

  • dc = +1,说明向右:记 0
  • dc = -1,说明向左:记 1
  • dr = ±1,上下移动:忽略

这样能得到一长串二进制位。

然后:

  • 跳过开头 1 位(入口前导位)
  • 每 8 位转成一个 ASCII 字符
  • 可直接读出 VishwaCTF{...}

exp:

from collections import deque
import sys


def load_grid(path: str):
    with open(path, "r", encoding="utf-8") as f:
        lines = [line.rstrip("\n") for line in f]

    grid = []
    width = None

    for line in lines:
        if not line:
            continue
        if set(line) <= set("#.><"):
            if width is None:
                width = len(line)
            if len(line) == width:
                grid.append(line)

    if not grid:
        raise ValueError("No maze grid found.")

    return grid


def find_points(grid):
    start = end = None
    for r, row in enumerate(grid):
        for c, ch in enumerate(row):
            if ch == ">":
                start = (r, c)
            elif ch == "<":
                end = (r, c)
    if start is None or end is None:
        raise ValueError("Start or end marker not found.")
    return start, end


def bfs_path(grid, start, end):
    R, C = len(grid), len(grid[0])
    walkable = {".", ">", "<"}
    q = deque([start])
    prev = {start: None}

    for_pos = [(1, 0), (-1, 0), (0, 1), (0, -1)]

    while q:
        r, c = q.popleft()
        if (r, c) == end:
            break

        for dr, dc in for_pos:
            nr, nc = r + dr, c + dc
            if 0 <= nr < R and 0 <= nc < C:
                if grid[nr][nc] in walkable and (nr, nc) not in prev:
                    prev[(nr, nc)] = (r, c)
                    q.append((nr, nc))

    if end not in prev:
        raise ValueError("No path found from start to end.")

    path = []
    cur = end
    while cur is not None:
        path.append(cur)
        cur = prev[cur]
    path.reverse()
    return path


def decode_from_path(path):
    bits = []

    for (r1, c1), (r2, c2) in zip(path, path[1:]):
        dc = c2 - c1
        # Only horizontal moves encode data
        if dc == 1:
            bits.append("0")   # move right
        elif dc == -1:
            bits.append("1")   # move left

    bitstream = "".join(bits)

    # Skip the first horizontal bit: it's just the entry step into the maze
    bitstream = bitstream[1:]

    out = []
    for i in range(0, len(bitstream) - 7, 8):
        byte = bitstream[i:i + 8]
        ch = chr(int(byte, 2))
        out.append(ch)

    return "".join(out)


def main():
    if len(sys.argv) != 2:
        print(f"Usage: python {sys.argv[0]} maze.txt")
        sys.exit(1)

    grid = load_grid(sys.argv[1])
    start, end = find_points(grid)
    path = bfs_path(grid, start, end)
    flag = decode_from_path(path)

    print("[+] Path length:", len(path))
    print("[+] Decoded:", flag)


if __name__ == "__main__":
    main()

题目文本保存成 maze.txt:

python solve.py maze.txt

输出:

[+] Path length: 1089
[+] Decoded: VishwaCTF{p4th_1s_th3_m3ss4g3_00_57d006d5}

The Curator

一开始看起来像 RSA 题,因为有 n / c1 / c2,还提到了:

  • p, q 有隐藏关系
  • seed 藏在素数里
  • c2 = pow(session_key ^ MAGIC, e, n)

但真正能直接利用的,其实是 LCG 前 8 个输出公开。

题目已经明说:

  • 前 8 个 LCG 输出是公开的
  • 后续输出拿去做 XOR 流加密

这意味着只要恢复 LCG 参数,就可以直接把 encrypted_flag 解出来,甚至不用先处理 RSA。

exp:

outs = [980887876, 699919547, 2058135724, 3888182547, 3474875028, 107192043, 215891708, 1328661059]
ct = bytes.fromhex("b2723f1b432adff7c2009fe0e7cf4f5c10a9bf6c1a38aa50b6645fa7725823f20ae8fd9787946c5135965f200b1fd2e7fb353c8287b821")

M = 2**32
x1, x2, x3 = outs[:3]

# recover A, C, seed
d1 = (x2 - x1) % M
d2 = (x3 - x2) % M

A = (d2 * pow(d1, -1, M)) % M
C = (x2 - A * x1) % M
seed = ((x1 - C) * pow(A, -1, M)) % M

print(f"A    = {hex(A)}")
print(f"C    = {hex(C)}")
print(f"seed = {hex(seed)}")

# verify first 8 outputs
x = seed
check = []
for _ in range(8):
    x = (A * x + C) % M
    check.append(x)

print("verify:", check == outs)

# generate stream, skip first 8 public outputs
x = seed
stream = []
for _ in range(8 + len(ct)):
    x = (A * x + C) % M
    stream.append(x)

keystream = bytes(v & 0xff for v in stream[8:8 + len(ct)])
pt = bytes(c ^ k for c, k in zip(ct, keystream))

print(pt.decode())

VishwaCTF{s33ds_4r3_n3v3r_s4f3_1ns1d3_pr1m3s_4nd_n01s3}

MISC

Fragmented Evidence

这题给了一份日志文件 server.log,表面上看大部分都是正常系统日志,但其中夹杂了几条比较突兀的异常记录:多次出现 packet anomaly detected id=...,最后还有一条 backup failed code=...。这些字段明显不像普通错误码,更像是被拆碎后埋进日志里的数据。

  1. 观察异常字段

按时间顺序把所有异常值提取出来:

Zmxh
Z3tP
YmZ1
c2Nh
dGVk
VHJ1dGh9

这些字符串只包含 Base64 常见字符,看起来就是被分段保存的 Base64 数据。相关片段都直接出现在日志里的 id= 和 code= 后面。

  1. 拼接并解码

把它们按出现顺序拼接:

ZmxhZ3tPYmZ1c2NhdGVkVHJ1dGh9

对这串做 Base64 解码,得到:

flag{ObfuscatedTruth}

exp:

import base64
import re

data = open("server.log", "r", encoding="utf-8").read()

parts = re.findall(r'id=([A-Za-z0-9+/=]+)', data)
parts += re.findall(r'code=([A-Za-z0-9+/=]+)', data)

b64 = ''.join(parts)
print("[+] joined:", b64)

decoded = base64.b64decode(b64).decode()
print("[+] decoded:", decoded)

inner = decoded.removeprefix("flag{").removesuffix("}")
print("[+] submit:", f"VishwaCTF{{{inner}}}")

VishwaCTF{ObfuscatedTruth}

BOOT

这个 ISO 里真正的系统本体基本是官方 TinyCore 17.0。/boot/core.gz 和 /boot/vmlinuz 的 MD5 分别是 dab5a4578517269f1c5c39b0f4686af9、dbe0adc7f7bba17ef29cbb5280c8ded1,和官方 distribution_files 里的 core.gz、vmlinuz 完全一致;但官方 TinyCore-17.0.iso 的 MD5 是 6f6eec3518c70b394ef3c41711b1fe6d,说明题目作者改的不是系统本体,而是 ISO / boot 层。

继续看 /boot/isolinux/isolinux.bin,在偏移 0x6000 处能看到被塞进去的 3 行同样的字符串:

9d5zYNcj9f1S46vC74aruPgE9b6T3ceX4Qsa2VQAbVnDFfTr

这串东西看起来像 Base64,但解出来是随机字节;改用 Base58 解码,就直接得到:

VishwaCTF{iM4G35_4Re_n0t_th4T_c00L}

一行 Python 复现:

alphabet='123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
s='9d5zYNcj9f1S46vC74aruPgE9b6T3ceX4Qsa2VQAbVnDFfTr'
n=0
for ch in s:
    n = n*58 + alphabet.index(ch)
print(n.to_bytes((n.bit_length()+7)//8, 'big').decode())

UnderWorld - P1

P1 我没有找到第二个同样“完整拼出 VishwaCTF{...}”的容器,但在龙身上的一个桶里,钻石名字明确拼出的是:

No Emeralds here

所以 P1 最可能 是:
VishwaCTF{No_Emeralds_here}

没有想到真是()这也太像fakeflag了

VishwaCTF{no_emeralds_here}

UnderWorld - P2

这是一个 Minecraft 世界存档,

已确认的:
VishwaCTF{m1n3cr4f7_15_fun}

这个是 P2,因为在龙头附近一个箱子里,27 个钻石的自定义名字按槽位正好拼出整串

The-Lost-Client

这张 PNG 本体是单色图,真正有用的是我从文件里直接抠出来的 XMP 元数据:creator = "Tata and.........",UserComment = "Its a generational business family",title = "V!"。这里后半段刚好是 9 个点,很像在遮一个 9 字母姓氏;结合“generational business family”和 V!,我现在认为它更像是在指 Vijaypat Singhania,而不是前面猜过的 Ajay / Venu。Times of India 也把 Vijaypat Singhania写成来自一个显赫商业家族的著名商界人物。

接着看“ex-chairman of a reputed institute in India”这部分,IIMA 官方档案明确写了两点:一是 “Dr. Vijaypat Singhania” 页面;二是 IIMA 的历任 Board of Governors 主席列表里,Dr. Vijaypat Singhania 的任期是 2007-03-29 到 2012-03-28。也就是说,他对应的机构就是 Indian Institute of Management Ahmedabad。

所以题目要的机构首字母缩写应当是:

IIMA

Jigsaw QR

二维码4*4被打乱,写个脚本拼接一下

4x4 拼法可以按当前图块编号这样排:

2   6  15 13
11 14 12  3
5   4  1  7
0   8 10  9

按“当前图片从左到右、从上到下编号 0~15”来排。

exp:

# exp.py
from PIL import Image
from pyzbar.pyzbar import decode

IMG_PATH = "shuffled_flag1.png"
OUT_PATH = "recovered_qr.png"

# 按“原图从左到右、从上到下编号 0~15”
# 下面这个列表表示:拼好后的第 pos 个位置,应该放原图里的哪一块
ORDER = [
    2,  6, 15, 13,
    11, 14, 12,  3,
    5,  4,  1,  7,
    0,  8, 10,  9
]

def split_4x4(img):
    w, h = img.size
    xs = [round(i * w / 4) for i in range(5)]
    ys = [round(i * h / 4) for i in range(5)]

    tiles = []
    for r in range(4):
        for c in range(4):
            tile = img.crop((xs[c], ys[r], xs[c + 1], ys[r + 1]))
            tiles.append(tile)
    return tiles

def rebuild(tiles, order):
    max_w = max(t.size[0] for t in tiles)
    max_h = max(t.size[1] for t in tiles)

    canvas = Image.new("RGB", (max_w * 4, max_h * 4), "white")

    for pos, src_idx in enumerate(order):
        r, c = divmod(pos, 4)
        tile = tiles[src_idx].resize((max_w, max_h), Image.NEAREST)
        canvas.paste(tile, (c * max_w, r * max_h))

    return canvas

def main():
    img = Image.open(IMG_PATH).convert("RGB")
    tiles = split_4x4(img)
    qr = rebuild(tiles, ORDER)
    qr.save(OUT_PATH)

    print(f"[+] saved: {OUT_PATH}")

    res = decode(qr)
    if res:
        print("[+] flag:", res[0].data.decode())
    else:
        print("[-] decode failed, scan recovered_qr.png manually")

if __name__ == "__main__":
    main()

VishwaCTF{t00_sm4rt_t0_us3_brut3_f0rc3}

Reverse

Messed Up

这题不是正常输入正确 secret 后给你 success 的那种程序。

程序运行后无论你输入什么,最后都会走到:

Your Secret "xxx" is invalid!
Byy!

真正的 flag 被作者“藏”在程序初始化时压到栈上的一组 8 字节常量里,需要静态提取。

附件是一个 64 位 ELF,静态链接,未 strip。

直接运行可见它的行为大致是:

Enter Secret:
Your Secret "输入内容" is invalid!
Byy!

程序会:

  1. 输出 Enter Secret:
  2. read(0, buf, 0x7f) 读入输入
  3. 去掉末尾换行
  4. 打印:
  • Your Secret "
  • 你的输入
  • " is invalid!\n
  • Byy!\n

也就是说,它表面上像是在校验输入,实际上主流程根本没有真正的 success 输出。

程序初始化阶段会往栈上放很多 8 字节常量,比如:

  • [rsp-0x48] = 0x954e20f865db128e
  • [rsp-0x38] = 0x5b70de7570bc89c2
  • [rsp-0x30] = 0x794b3d6bbf3f238f
  • [rsp-0x28] = 0x212aa49b64d7e65d
  • [rsp-0x20] = 0x90bafc29c34b62bd
  • [rsp-0x18] = 0xa0564f32e8a3db99
  • [rsp-0x10] = 0x0000000000b4c144

以及另一组:

  • [rsp-0x08] = 0xf01d008a00af7ccb
  • [rsp+0x08] = 0x0f33bf0218cfe094
  • [rsp+0x10] = 0x26324f198f0a58c9
  • [rsp+0x18] = 0x5375d7af1388d16c
  • [rsp+0x20] = 0xa3d7a350f27a568e
  • [rsp+0x28] = 0x81061a6d8c90eeea
  • [rsp+0x30] = 0x0000000000c9e065

把对应项异或后,可以直接还原出字符串。

  1. 先还原程序提示语
[rsp-0x48] ^ [rsp-0x08] = "Enter Se"
[rsp-0x40] ^ [rsp+0x00] = "cret: "

这正好对应程序的提示:

Enter Secret:
  1. 再还原隐藏 flag
[rsp-0x38] ^ [rsp+0x08] = "VishwaCT"
[rsp-0x30] ^ [rsp+0x10] = "F{50rry_"
[rsp-0x28] ^ [rsp+0x18] = "17_w4s_r"
[rsp-0x20] ^ [rsp+0x20] = "3411y_m3"
[rsp-0x18] ^ [rsp+0x28] = "s53d_UP!"
[rsp-0x10] ^ [rsp+0x30] = "!!}"

拼起来就是:

VishwaCTF{50rry_17_w4s_r3411y_m3s53d_UP!!!}

因为这个程序并不是“把 flag 当作 secret 校验”的逻辑。

它真正执行的主流程,读完输入后走的是:

  • 长度处理
  • 去掉换行
  • 拼接输出
  • 固定打印 invalid

也就是说:

  • flag 是被藏在程序里的
  • 不是拿来给程序验证的

所以你把 flag 输入进去,程序依旧会显示 invalid,这是正常现象。

exp

下面这个脚本可以直接把隐藏 flag 还原出来:

parts = [
    0x5b70de7570bc89c2 ^ 0x0f33bf0218cfe094,  # VishwaCT
    0x794b3d6bbf3f238f ^ 0x26324f198f0a58c9,  # F{50rry_
    0x212aa49b64d7e65d ^ 0x5375d7af1388d16c,  # 17_w4s_r
    0x90bafc29c34b62bd ^ 0xa3d7a350f27a568e,  # 3411y_m3
    0xa0564f32e8a3db99 ^ 0x81061a6d8c90eeea,  # s53d_UP!
    0x0000000000b4c144 ^ 0x0000000000c9e065,  # !!}
]

flag = b"".join(x.to_bytes(8, "little").rstrip(b"\x00") for x in parts)
print(flag.decode())

VishwaCTF{50rry_17_w4s_r3411y_m3s53d_UP!!!}

ArtGallery

解包 APK 后,能看到包名是:

com.ctf.artgallery

Activity 主要有三个:

com.ctf.artgallery.MainActivity
com.ctf.artgallery.GalleryActivity
com.ctf.artgallery.CanvasActivity

正常流程是:

MainActivity -> GalleryActivity

但真正和 flag 相关的是 CanvasActivity。

在 GalleryActivity 里看事件绑定,可以看到有一个长按逻辑。

关键函数大意如下:

lambda$onCreate$3$com-ctf-artgallery-GalleryActivity(View v)

它会先弹一个提示:

Scanning art for hidden data...

然后延迟 800ms 执行一个 runnable。

继续跟这个 runnable:

lambda$onCreate$2$com-ctf-artgallery-GalleryActivity()

核心逻辑就是:

Intent i = new Intent(this, CanvasActivity.class);
startActivity(i);

也就是说:

在 GalleryActivity 里长按图片,就会进入真正的隐藏界面 CanvasActivity。

CanvasActivity 里最关键的是这个函数:

g()

反汇编逻辑大致是:

if (!nativeLoaded) return "ACCESS_DENIED";
if (h()) return "ACCESS_DENIED";

int signal = computeRuntimeSignal();

if (!verifyGateNative(signal)) return "ACCESS_DENIED";

byte[] flag = decryptFlagNative(signal);
return new String(flag, UTF_8);

也就是分 4 步:

  1. 检查 native 是否加载
  2. 反调试检查 h()
  3. 计算 runtimeSignal
  4. 交给 native:
  • verifyGateNative(signal)
  • decryptFlagNative(signal)

h() 的逻辑不复杂:

Debug.isDebuggerConnected()
Debug.waitingForDebugger()

然后再跑一个小循环计时:

  • 如果执行时间过长,怀疑被调试
  • 就直接拒绝

所以它本质就是个普通反调试门槛,不是重点。

computeRuntimeSignal() 会取 APK 的签名信息:

  1. PackageManager.getPackageInfo(...)
  2. 取 signingInfo
  3. 对签名字节做 SHA-256
  4. 取前 4 个字节拼成一个 32-bit 值
  5. 再和包名 hash、几个常数做异或/rotate

最后得到一个 signal。

看起来很像“必须真机运行、必须原签名”的严密校验,但后面分析 native 会发现:

这个 signal 只用于过门,真正 flag 解密并不依赖它。

APK 里带了多个架构的 so:

lib/x86/libartvault.so
lib/x86_64/libartvault.so
lib/armeabi-v7a/libartvault.so
lib/arm64-v8a/libartvault.so

直接分析 x86_64/libartvault.so 最方便。

导出符号可以看到两个 JNI 函数:

Java_com_ctf_artgallery_CanvasActivity_verifyGateNative
Java_com_ctf_artgallery_CanvasActivity_decryptFlagNative

这个函数很短,逻辑如下:

bool verifyGateNative(int x) {
    x ^= 0x6c8e9cf5;
    x = mix32(x);   // 一段类似 murmur/hash 的混合
    return x == 0xd15ea5ed;
}

其中 mix32 是:

x ^= x >> 16;
x *= 0x7feb352d;
x ^= x >> 15;
x *= 0x846ca68b;
x ^= x >> 16;

所以它就是一个本地校验门。

但这还不是关键,因为真正的 flag 在另一个函数里。

分析 decryptFlagNative 会发现:

  • 它接收参数 signal
  • 但函数主体里根本没有真正使用这个 signal 去参与解密
  • 也就是说,只要静态逆出算法,就能直接拿到 flag

so 的 .rodata 里有三段数据,每段 11 字节:

a = bytes.fromhex("c1e81ff4ac02c6080f6135")
b = bytes.fromhex("999f79b553f3dedc237cf9")
c = bytes.fromhex("9a105eee235d979e4b1fb3")

native 先按如下方式交错拼接:

tmp[0] = a[0]
tmp[1] = b[0]
tmp[2] = c[0]
tmp[3] = a[1]
tmp[4] = b[1]
tmp[5] = c[1]
...

得到 33 字节中间数组。

.rodata 里还有一个 33 字节的置换表:

perm = bytes.fromhex(
    "201c1110080713010500040f12150e1d02160d031e061b090b19140c1f1a180a17"
)

含义是:

out[i] = tmp[perm[i]]

初始种子:

state = 0x7f4a7c15

每轮:

state = (state * 0x19660d + 0x3c6ef35f) & 0xffffffff
key = (state >> ((i & 3) * 8)) & 0xff
key ^= ((i * 31) + 0x11) & 0xff
out[i] ^= key

还有一个 16 字节表:

sbox = bytes.fromhex("06040c050007020e010f030d080a090b")

对每个字节高 4 位和低 4 位分别替换:

hi = sbox[(x >> 4) & 0xf]
lo = sbox[x & 0xf]
x = (hi << 4) | lo

最后再按位置做循环右移:

r = (i % 5) + 1
x = ror8(x, r)

做完就是明文。

exp

# solve_art_gallery.py

def ror8(x, r):
    r &= 7
    return ((x >> r) | ((x << (8 - r)) & 0xff)) & 0xff


perm = bytes.fromhex(
    "201c1110080713010500040f12150e1d02160d031e061b090b19140c1f1a180a17"
)

a = bytes.fromhex("c1e81ff4ac02c6080f6135")
b = bytes.fromhex("999f79b553f3dedc237cf9")
c = bytes.fromhex("9a105eee235d979e4b1fb3")

sbox = bytes.fromhex("06040c050007020e010f030d080a090b")

# step1: interleave 3 chunks into 33 bytes
tmp = bytearray(33)
ia = ib = ic = 0
for i in range(33):
    if i % 3 == 0:
        tmp[i] = a[ia]
        ia += 1
    elif i % 3 == 1:
        tmp[i] = b[ib]
        ib += 1
    else:
        tmp[i] = c[ic]
        ic += 1

# step2: permutation
buf = bytearray(33)
for i, p in enumerate(perm):
    buf[i] = tmp[p]

# step3~5: PRNG xor -> nibble substitution -> rotate right
state = 0x7f4a7c15
res = bytearray(33)

for i in range(33):
    state = (state * 0x19660d + 0x3c6ef35f) & 0xffffffff

    key = (state >> ((i & 3) * 8)) & 0xff
    key ^= ((i * 31) + 0x11) & 0xff

    x = buf[i] ^ key

    hi = sbox[(x >> 4) & 0xf]
    lo = sbox[x & 0xf]
    x = ((hi << 4) | lo) & 0xff

    x = ror8(x, (i % 5) + 1)
    res[i] = x

print(res.decode())

VishwaCTF{secret_gallery_exposed}

Web

Heap of Secrets

用 Chrome 打开题目页。

按 F12 → Memory 面板。

选 Heap snapshot → 点 Take snapshot

然后保存下来搜索就行

VishwaCTF{h34p_5n4p5h0t_1s_D3ep_M3m0ry}

Keymaster Secrets

打开题目站点后,首页是一个伪装成 Apache Syncope Console 的登录页面,页面标题和底部都明确给出版本:

Apache Syncope v4.0.3

题目描述也在不断强调:

  • Apache Syncope
  • XML 相关漏洞
  • 外部实体被“修复”
  • Keymaster Parameters

这几个关键词已经非常明显地把方向指向 Syncope 的 Keymaster 参数 XXE。

一开始如果直接打常规登录、默认口令、REST 路径,都会发现站点并不是完整暴露原版 Syncope,而是一个做过裁剪/伪装的题目环境,所以继续硬撞登录并不高效。

  1. 查看 robots.txt

访问:

/robots.txt

得到:

User-agent: *
Disallow: /maintenance
Disallow: /api/docs
Disallow: /rest/

这里的 robots.txt 其实就是明示,告诉我们有几个“平时不想被搜到”的路径值得看:

  • /maintenance
  • /api/docs
  • /rest/
  1. 访问 /maintenance

打开:

/maintenance

会看到一个维护页面。
真正有价值的是查看页面源码,在 HTML 注释中发现了泄露信息:

<!--
TODO (ops-team): remove before go-live
Emergency console access for maintenance window:
  Username : admin
  Password : S3cur3Syncop3!@dm1n
Temp access expires: 2026-06-01

NOTE: BI reporting service coming soon on separate port — token in runtime dir
-->

这说明开发/运维把敏感信息直接留在了源码注释里。

  1. 访问 /api/docs

打开:

/api/docs

这个页面是伪造出来的 REST API 文档,里面列出了几个关键接口:

/rest/users/import
/rest/config/validate
/rest/keymaster/params
/rest/server/info

其中最关键的是:

POST /rest/keymaster/params

文档中明确写着它会:

  • 服务端解析 XML
  • 取出 <value>
  • 存储并返回

同时文档还专门写了一句类似“已阻止包含 SYSTEM entity 的 DOCTYPE”,这其实就是在强行把人往 XXE / CVE 上引。

登录进去继续查看这些页面源码后,可以直接拿到 flag:

VishwaCTF{XXE_1nj3ct10n_4p4ch3_sync0p3_CVE-2026-23795}