From 2465da8fad117a632f60836bcc2171f3ea96bbdb Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 28 Jul 2025 18:12:25 +0000 Subject: [PATCH] Translated ['src/pentesting-web/deserialization/basic-java-deserializati --- ...ialization-objectinputstream-readobject.md | 83 +++++++++++++++++-- 1 file changed, 75 insertions(+), 8 deletions(-) diff --git a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md index 2112aae60..527aa29b2 100644 --- a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md +++ b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md @@ -1,15 +1,27 @@ +# Basiese Java Deserialisering met ObjectInputStream readObject + {{#include ../../banners/hacktricks-training.md}} -In hierdie POST gaan 'n voorbeeld verduidelik word wat `java.io.Serializable` gebruik. +In hierdie POST gaan 'n voorbeeld verduidelik word wat `java.io.Serializable` gebruik **en waarom die oorskrywing van `readObject()` uiters gevaarlik kan wees as die inkomende stroom deur 'n aanvaller beheer word**. -# Serializable +## Serializable -Die Java `Serializable`-koppelvlak (`java.io.Serializable` is 'n merk-koppelvlak wat jou klasse moet implementeer as hulle **geserialiseer** en **gedeserializeer** moet word. Java objekserialisering (skryf) word gedoen met die [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) en deserialisering (lees) word gedoen met die [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html). +Die Java `Serializable`-koppelvlak (`java.io.Serializable`) is 'n merk-koppelvlak wat jou klasse moet implementeer as hulle **geserialiseer** en **gedeserialiseer** moet word. Java objekserialisering (skryf) word gedoen met die [`ObjectOutputStream`](http://tutorials.jenkov.com/java-io/objectoutputstream.html) en deserialisering (lees) word gedoen met die [`ObjectInputStream`](http://tutorials.jenkov.com/java-io/objectinputstream.html). -Kom ons kyk na 'n voorbeeld met 'n **klas Persoon** wat **geserialiseer** kan word. Hierdie klas **oorskryf die readObject** funksie, so wanneer **enige objek** van hierdie **klas** **gedeserializeer** word, gaan hierdie **funksie** **uitgevoer** word.\ -In die voorbeeld roep die **readObject-funksie** van die klas Persoon die funksie `eat()` van sy troeteldier aan en die funksie `eat()` van 'n Hond (om een of ander rede) roep 'n **calc.exe** aan. **Ons gaan kyk hoe om 'n Persoon objek te serialiseer en te deserialiseer om hierdie sakrekenaar uit te voer:** +### Herinnering: Watter metodes word implisiet tydens deserialisering aangeroep? -**Die volgende voorbeeld is van [https://medium.com/@knownsec404team/java-deserialization-tool-gadgetinspector-first-glimpse-74e99e493649](https://medium.com/@knownsec404team/java-deserialization-tool-gadgetinspector-first-glimpse-74e99e493649)** +1. `readObject()` – klas-spesifieke leeslogika (as geïmplementeer en *privaat*). +2. `readResolve()` – kan die gedeserialiseerde objek met 'n ander een vervang. +3. `validateObject()` – via `ObjectInputValidation` terugroepe. +4. `readExternal()` – vir klasse wat `Externalizable` implementeer. +5. Konstruktors word **nie** uitgevoer nie – daarom staat gadgetkettings uitsluitlik op die vorige terugroepe. + +Enige metode in daardie ketting wat uiteindelik aanvaller-beheerde data aanroep (opdraguitvoering, JNDI soektogte, refleksie, ens.) verander die deserialisering roetine in 'n RCE gadget. + +Kom ons kyk na 'n voorbeeld met 'n **klas Persoon** wat **geserialiseer** is. Hierdie klas **oorskry die readObject** funksie, so wanneer **enige objek** van hierdie **klas** **gedeserialiseer** word, gaan hierdie **funksie** **uitgevoer** word.\ +In die voorbeeld roep die **readObject** funksie van die klas Persoon die funksie `eat()` van sy troeteldier aan en die funksie `eat()` van 'n Hond (om een of ander rede) roep 'n **calc.exe** aan. **Ons gaan kyk hoe om 'n Persoon objek te serialiseer en te deserialiseer om hierdie sakrekenaar uit te voer:** + +**Die volgende voorbeeld is van ** ```java import java.io.Serializable; import java.io.*; @@ -80,8 +92,63 @@ payloadTest("test.ser"); } } ``` -## Gevolgtrekking +### Gevolgtrekking (klassieke scenario) -Soos jy in hierdie baie basiese voorbeeld kan sien, verskyn die "kwesbaarheid" hier omdat die **readObject** funksie **ander kwesbare funksies aanroep**. +Soos jy in hierdie baie basiese voorbeeld kan sien, verskyn die “kwesbaarheid” hier omdat die **readObject()** metode **ander aanvaller-beheerde kode aanroep**. In werklike wêreld gadget kettings kan duisende klasse wat in eksterne biblioteke (Commons-Collections, Spring, Groovy, Rome, SnakeYAML, ens.) bevat is, misbruik word – die aanvaller het net *een* bereikbare gadget nodig om kode-uitvoering te verkry. + +--- + +## 2023-2025: Wat is nuut in Java deserialisering aanvalle? + +* 2023 – CVE-2023-34040: Spring-Kafka deserialisering van fout-record koppe wanneer `checkDeserExWhen*` vlae geaktiveer is, het arbitrêre gadgetkonstruksie vanuit aanvaller-gepubliseerde onderwerpe toegelaat. Reggestel in 3.0.10 / 2.9.11. ¹ +* 2023 – CVE-2023-36480: Aerospike Java kliënt vertroude-bediener aanname gebroke – kwaadwillige bediener antwoorde het serialiseerde payloads bevat wat deur die kliënt gedeserialiseer is → RCE. ² +* 2023 – CVE-2023-25581: `pac4j-core` gebruikersprofiel attribuut parsing het `{#sb64}`-geprefikseerde Base64 blobs aanvaar en hulle gedeserialiseer ten spyte van 'n `RestrictedObjectInputStream`. Opgradeer ≥ 4.0.0. +* 2023 – CVE-2023-4528: JSCAPE MFT Bestuurderdiens (poort 10880) het XML-gecodeerde Java-objekte aanvaar wat tot RCE as root/SYSTEM gelei het. +* 2024 – Meerdere nuwe gadget kettings is by ysoserial-plus(mod) gevoeg, insluitend Hibernate5, TomcatEmbed, en SnakeYAML 2.x klasse wat sommige ou filters omseil. + +## Moderne verskansings wat jy moet implementeer + +1. **JEP 290 / Serialisering Filtrering (Java 9+)** +*Voeg 'n toelaat-lis of ontken-lis van klasse by:* +```bash +# Aanvaar slegs jou DTO's en java.base, verwerp alles anders +-Djdk.serialFilter="com.example.dto.*;java.base/*;!*" +``` +Programmatiese voorbeeld: +```java +var filter = ObjectInputFilter.Config.createFilter("com.example.dto.*;java.base/*;!*" ); +ObjectInputFilter.Config.setSerialFilter(filter); +``` +2. **JEP 415 (Java 17+) Konteks-Spesifieke Filter Fabrieke** – gebruik 'n `BinaryOperator` om verskillende filters per uitvoeringskonteks toe te pas (bv. per RMI oproep, per boodskapqueue verbruiker). +3. **Moet nie rou `ObjectInputStream` oor die draad blootstel nie** – verkies JSON/Binary kodering sonder kode-uitvoering semantiek (Jackson na deaktivering van `DefaultTyping`, Protobuf, Avro, ens.). +4. **Verdediging-in-diepte beperkings** – Stel maksimum array lengte, diepte, verwysings in: +```bash +-Djdk.serialFilter="maxbytes=16384;maxdepth=5;maxrefs=1000" +``` +5. **Deurlopende gadget skandering** – hardloop gereedskap soos `gadget-inspector` of `serialpwn-cli` in jou CI om die bou te laat misluk as 'n gevaarlike gadget bereikbaar word. + +## Opgedateerde gereedskap spiekbrief (2024) + +* `ysoserial-plus.jar` – gemeenskapsvork met > 130 gadget kettings: +```bash +java -jar ysoserial-plus.jar CommonsCollections6 'calc' | base64 -w0 +``` +* `marshalsec` – steeds die verwysing vir JNDI gadget generasie (LDAP/RMI). +* `gadget-probe` – vinnige swart-doos gadget ontdekking teen netwerk dienste. +* `SerialSniffer` – JVMTI agent wat elke klas druk wat deur `ObjectInputStream` gelees word (nuttig om filters te skep). +* **Ontdekking wenk** – aktiveer `-Djdk.serialDebug=true` (JDK 22+) om filterbesluite en verwerpte klasse te log. + +## Vinning checklist vir veilige `readObject()` implementasies + +1. Maak die metode `privaat` en voeg die `@Serial` annotasie by (help statiese analise). +2. Nooit gebruikers-geleverde metodes aanroep of I/O in die metode uitvoer nie – lees slegs velde. +3. As validasie nodig is, voer dit **na** deserialisering uit, buite `readObject()`. +4. Verkies om `Externalizable` te implementeer en doen eksplisiete veldlesings in plaas van standaard serialisering. +5. Registreer 'n geharde `ObjectInputFilter` selfs vir interne dienste (kompromie-resiliente ontwerp). + +## Verwysings + +1. Spring Security Advisory – CVE-2023-34040 Java Deserialisering in Spring-Kafka (Aug 2023) +2. GitHub Security Lab – GHSL-2023-044: Onveilige Deserialisering in Aerospike Java Kliënt (Jul 2023) {{#include ../../banners/hacktricks-training.md}}