反序列化炸彈

序列化（構造炸彈）

public void serializable() throws IOException {
       Set<Object> root = new HashSet<>();
       Set<Object> s1 = root;
       Set<Object> s2 = new HashSet<>();
       for (int i = 0; i < 100; i++) {
           Set<Object> t1 = new HashSet<>();
           Set<Object> t2 = new HashSet<>();
           t1.add("foo"); // Make t1 unequal to t2
           s1.add(t1);  s1.add(t2);
           s2.add(t1);  s2.add(t2);
           s1 = t1;
           s2 = t2;
		}

        String filePath="/Users/apple/Desktop/object";
        try(ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(filePath));){
            objectOutputStream.writeObject(root);
        }
    }

先構建一個根節點root，裏面存放兩個set引用，每個set再存放兩個新的set的引用，以此類推，循環100次。
每個節點包含至多3個元素，層次結構大致是一棵樹，樹的深度爲101。共創建201個對象。

反序列化（引爆）

public void deserializable() throws IOException, ClassNotFoundException {
	String filePath="/Users/apple/Desktop/object";
    try(ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream(filePath))) {
        Set<Object> set=(Set<Object>) inputStream.readObject();
    }
}

執行這段代碼的後果是什麼呢？它會一直運行，不會報錯。執行次數與樹的深度成指數關係，
所以深度爲100，大概有$2^{100}$次執行。

原理解釋

201個對象，序列化以後就5744個字節，爲啥反序列化會執行那麼多次？

HashSet 重寫了readObject()方法

關鍵是這段邏輯，衆所周知，HashSet 底層使用HashMap實現的

// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
    @SuppressWarnings("unchecked")
        E e = (E) s.readObject();
    map.put(e, PRESENT);
}

所以調用鏈爲

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

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

hash()裏的key是HashSet,繼承了AbstractSet的hashCode()方法。
可以看出計算當前對象的hashCode 需要對其所有元素進行累加，
而其元素又是set集合，遞歸調用。

public int hashCode() {
    int h = 0;
    Iterator<E> i = iterator();
    while (i.hasNext()) {
        E obj = i.next();
        if (obj != null)
            h += obj.hashCode();
    }
    return h;
}

使用建議

上述例子源自於《effective java》(google 首席架構師所著，必看)。
正如書裏建議的那樣。

儘可能的不用java序列化，優先考慮json和protocal buffers
如果不得不用

永遠不要反序列化不被信任的數據
如果不得不反序列化

就要使用反序列化過濾，java9新增的 object deserilization filtering,這一功能已
移植到ObjectInputFilter