PHP-FPM与Nginx的FastCGI协议：Header、Params与Body的分段处理与缓冲区溢出

好的，我们开始今天的讲座，主题是PHP-FPM与Nginx的FastCGI协议：Header、Params与Body的分段处理与缓冲区溢出。

FastCGI协议概览

FastCGI是一种用于Web服务器（如Nginx）和应用程序（如PHP-FPM）之间通信的协议。它旨在解决CGI的性能瓶颈，通过保持应用程序进程的持久性，避免了每次请求都启动和关闭进程的开销。FastCGI协议基于二进制数据包进行通信，数据包包含头部（Header）、参数（Params）和主体（Body）三个部分。

FastCGI数据包结构

每个FastCGI数据包都遵循一个固定的结构。以下是一个FastCGI数据包头部结构的表格：

Field	Size (bytes)	Description
version	1	FastCGI协议版本 (通常为1)
type	1	数据包类型 (例如：FCGI_BEGIN_REQUEST, FCGI_PARAMS)
requestId	2	请求ID，用于区分不同的请求
contentLength	2	内容长度，即Params或Body的长度
paddingLength	1	填充长度，用于对齐数据
reserved	1	保留字段，通常为0
contentData	N	内容数据 (Params或Body)
paddingData	M	填充数据 (用于对齐)，长度由paddingLength指定

其中，version指定FastCGI协议的版本，通常为1。type指定数据包的类型，常见的类型包括：

• FCGI_BEGIN_REQUEST: 开始一个请求。
• FCGI_PARAMS: 包含请求的参数（例如，HTTP头部和查询字符串）。
• FCGI_STDIN: 包含请求的主体（例如，POST数据）。
• FCGI_STDOUT: 包含应用程序的标准输出。
• FCGI_STDERR: 包含应用程序的标准错误输出。
• FCGI_END_REQUEST: 结束一个请求。

requestId用于区分不同的并发请求。contentLength指定了Params或Body数据的长度，paddingLength指定了填充数据的长度。

Header的处理

Nginx作为FastCGI客户端，负责创建和发送FastCGI数据包给PHP-FPM。PHP-FPM作为FastCGI服务器，负责接收和解析这些数据包。

在Nginx中，处理FastCGI头部通常涉及到构建ngx_buf_t结构体，并将头部数据写入该结构体。例如：

// 假设已经获取了requestId, contentLength, paddingLength等值
ngx_buf_t *buf = ngx_create_temp_buf(pool, header_size); // pool是内存池
if (buf == NULL) {
    // 处理内存分配失败的情况
    return NGX_ERROR;
}

u_char *p = buf->pos;

*p++ = FCGI_VERSION_1;
*p++ = FCGI_PARAMS; // 或者 FCGI_STDIN, FCGI_STDOUT等
*p++ = (requestId >> 8) & 0xFF;
*p++ = requestId & 0xFF;
*p++ = (contentLength >> 8) & 0xFF;
*p++ = contentLength & 0xFF;
*p++ = paddingLength;
*p++ = 0; // reserved

buf->last = p; // 更新buf->last指针，指向已写入数据的末尾
buf->memory = 1; // 标记buf为内存缓冲区
buf->last_buf = 0; // 最后一个缓冲区

在PHP-FPM中，处理FastCGI头部涉及到读取固定长度的字节，并解析这些字节的值。例如：

// 假设已经接收到了头部数据，存储在buffer中
unsigned char version = buffer[0];
unsigned char type = buffer[1];
unsigned short requestId = (buffer[2] << 8) | buffer[3];
unsigned short contentLength = (buffer[4] << 8) | buffer[5];
unsigned char paddingLength = buffer[6];
unsigned char reserved = buffer[7];

// 根据解析出的值进行后续处理

Params的处理

Params包含请求的参数，例如HTTP头部和查询字符串。这些参数以键值对的形式编码，并以特定的格式进行传输。FastCGI协议使用name长度、value长度、name数据、value数据的方式来表示一个参数。name长度和value长度使用可变长度的编码方式，如果长度小于128，则直接使用一个字节表示；如果长度大于等于128，则使用4个字节表示，其中最高位设置为1，其余31位表示实际长度。

在Nginx中，构建Params数据包通常涉及到遍历HTTP头部和查询字符串，并将它们编码成FastCGI格式。

// 假设ngx_http_request_t *r 包含HTTP请求信息
ngx_list_part_t *part = &r->headers_in.headers.part;
ngx_http_header_t *header = part->elts;

for (i = 0; /* void */; i++) {
    if (i >= part->nelts) {
        if (part->next == NULL) {
            break;
        }
        part = part->next;
        header = part->elts;
        i = 0;
    }

    ngx_str_t name = header[i].key;
    ngx_str_t value = header[i].value;

    // 将name和value编码成FastCGI格式，写入到ngx_buf_t中
    // 需要处理长度编码，小于128直接写入长度，大于等于128写入4字节长度
    // 示例：
    // u_char *p = buf->last;
    // if (name.len < 128) {
    //     *p++ = name.len;
    // } else {
    //     *p++ = 0x80 | ((name.len >> 24) & 0xFF);
    //     *p++ = (name.len >> 16) & 0xFF;
    //     *p++ = (name.len >> 8) & 0xFF;
    //     *p++ = name.len & 0xFF;
    // }
    // ngx_memcpy(p, name.data, name.len);
    // p += name.len;
    // ... 类似处理value
    // buf->last = p;
}

在PHP-FPM中，处理Params数据包涉及到读取name长度和value长度，然后读取name数据和value数据，并将它们存储到HashTable中。

// 假设已经接收到了Params数据，存储在buffer中
unsigned char *p = buffer;
unsigned char *end = buffer + contentLength;

while (p < end) {
    unsigned int nameLength = 0;
    unsigned int valueLength = 0;

    // 读取name长度
    if (*p & 0x80) {
        nameLength = ((unsigned int)(*p++ & 0x7F) << 24) |
                     ((unsigned int)*p++ << 16) |
                     ((unsigned int)*p++ << 8) |
                     (unsigned int)*p++;
    } else {
        nameLength = *p++;
    }

    // 读取value长度
    if (*p & 0x80) {
        valueLength = ((unsigned int)(*p++ & 0x7F) << 24) |
                      ((unsigned int)*p++ << 16) |
                      ((unsigned int)*p++ << 8) |
                      (unsigned int)*p++;
    } else {
        valueLength = *p++;
    }

    // 读取name数据
    char *name = (char *)p;
    p += nameLength;

    // 读取value数据
    char *value = (char *)p;
    p += valueLength;

    // 将name和value存储到HashTable中
    zend_string *key = zend_string_init(name, nameLength, 0);
    zend_string *val = zend_string_init(value, valueLength, 0);
    zend_hash_update(EG(symbol_table), key, val); // EG(symbol_table)是全局符号表
    zend_string_release(key);
    zend_string_release(val);
}

Body的处理

Body包含请求的主体数据，例如POST数据。Body数据以流式的方式传输，可以分多次发送。

在Nginx中，发送Body数据通常涉及到读取请求的body数据，并将它们封装成FCGI_STDIN数据包发送给PHP-FPM。

// 假设ngx_http_request_t *r 包含HTTP请求信息
ngx_chain_t *chain = r->request_body->bufs;

while (chain) {
    ngx_buf_t *buf = chain->buf;

    // 将buf->pos到buf->last之间的数据封装成FCGI_STDIN数据包发送给PHP-FPM
    contentLength = buf->last - buf->pos;

    // 创建FastCGI头部
    ngx_buf_t *fcgi_buf = ngx_create_temp_buf(pool, header_size);
    // ... 填充fcgi_buf的头部，type为FCGI_STDIN, contentLength为contentLength

    // 将body数据追加到fcgi_buf后面
    ngx_chain_t out;
    out.buf = fcgi_buf;
    out.next = NULL;

    // 发送数据
    // ngx_http_upstream_send_request(r, &out, 0); // 简化示例
    // 实际发送需要处理错误和阻塞情况

    chain = chain->next;
}

// 发送一个长度为0的FCGI_STDIN数据包，表示body数据发送完毕

在PHP-FPM中，处理Body数据涉及到接收FCGI_STDIN数据包，并将它们读取到内存中。

// 假设已经接收到了FCGI_STDIN数据包，存储在buffer中
// 将buffer中的数据读取到input stream中
// 通常使用zend_stream API来操作input stream
zend_stream *stream = php_stream_open_wrapper("php://input", "rb", 0, NULL);
if (stream) {
    char buf[8192];
    size_t readlen;

    while ((readlen = php_stream_read(stream, buf, sizeof(buf))) > 0) {
        // 处理读取到的数据
        // 例如，将数据写入到临时文件中
    }
    php_stream_close(stream);
}

缓冲区溢出风险

FastCGI协议在处理Params和Body数据时，存在缓冲区溢出的风险。主要有以下几种情况：

1. 长度字段欺骗： 攻击者可以构造恶意的Params或Body数据，将长度字段设置为一个非常大的值，导致PHP-FPM分配过多的内存，或者在读取数据时超出缓冲区边界。
2. 整数溢出： 攻击者可以构造恶意的长度字段，利用整数溢出漏洞，导致实际分配的内存小于预期，从而造成缓冲区溢出。
3. 递归解析漏洞： 某些FastCGI实现可能存在递归解析漏洞，攻击者可以构造恶意的Params数据，触发递归解析，导致堆栈溢出。

防御措施

为了防御缓冲区溢出攻击，可以采取以下措施：

1. 验证长度字段： 在读取Params和Body数据之前，必须验证长度字段的合法性，确保其不超过合理的范围。
2. 限制内存分配： 限制PHP-FPM可以分配的最大内存，防止攻击者通过构造大量的Params或Body数据耗尽服务器资源。
3. 使用安全的字符串处理函数： 避免使用不安全的字符串处理函数，例如strcpy和sprintf，使用更安全的函数，例如strncpy和snprintf。
4. 代码审计： 定期进行代码审计，检查是否存在潜在的缓冲区溢出漏洞。
5. 更新到最新版本： 及时更新Nginx和PHP-FPM到最新版本，修复已知的安全漏洞。
6. 使用WAF (Web Application Firewall): WAF可以检测和阻止恶意的FastCGI请求，例如包含超长参数或特殊字符的请求。

代码示例（验证长度字段）

// 在PHP-FPM中，处理Params数据包时，验证nameLength和valueLength
#define MAX_PARAM_LENGTH 65535 // 定义一个合理的参数长度上限

while (p < end) {
    unsigned int nameLength = 0;
    unsigned int valueLength = 0;

    // 读取name长度
    if (*p & 0x80) {
        nameLength = ((unsigned int)(*p++ & 0x7F) << 24) |
                     ((unsigned int)*p++ << 16) |
                     ((unsigned int)*p++ << 8) |
                     (unsigned int)*p++;
    } else {
        nameLength = *p++;
    }

    // 验证nameLength
    if (nameLength > MAX_PARAM_LENGTH) {
        // 记录错误日志，并中断请求
        php_error_log("Invalid nameLength in FastCGI params");
        return FAILURE; // 或者其他错误处理方式
    }

    // 读取value长度
    if (*p & 0x80) {
        valueLength = ((unsigned int)(*p++ & 0x7F) << 24) |
                      ((unsigned int)*p++ << 16) |
                      ((unsigned int)*p++ << 8) |
                      (unsigned int)*p++;
    } else {
        valueLength = *p++;
    }

    // 验证valueLength
    if (valueLength > MAX_PARAM_LENGTH) {
        // 记录错误日志，并中断请求
        php_error_log("Invalid valueLength in FastCGI params");
        return FAILURE; // 或者其他错误处理方式
    }

    // ... 后续处理
}

代码示例（限制内存分配）

PHP-FPM通常通过php.ini配置文件来限制内存分配。

; php.ini
memory_limit = 128M ; 设置PHP脚本可以使用的最大内存

总结：理解协议，防范攻击

本次讲座我们深入研究了FastCGI协议，重点分析了Header、Params和Body的分段处理方式。同时我们也讨论了缓冲区溢出的风险，以及一些防御措施。理解这些内容对于构建安全可靠的Web应用程序至关重要。