spring-RCE-CVE-2022-22965

Présentation de la vulnérabilité

Récemment, Spring a révélé une vulnérabilité CVE majeure. Les informations CVE indiquent : "Une application Spring MVC ou Spring WebFlux fonctionnant sur JDK 9+ peut être vulnérable à une exécution de code à distance (RCE) via la liaison de données. L'exploitation spécifique nécessite que l'application s'exécute sur Tomcat en tant que déploiement WAR. Si l'application est déployée en tant que jar exécutable Spring Boot (c'est-à-dire par défaut), elle n'est pas vulnérable à l'exploit. Cependant, la nature de la vulnérabilité est plus générale, et il peut exister d'autres moyens de l'exploiter." Cette analyse vise à comprendre le principe de la vulnérabilité en reproduisant ce CVE.

API Java Bean

Avant d'examiner le principe de liaison des paramètres Spring MVC, regardons d'abord quelques API liées à Java Bean.

• Java Bean : Il s'agit en fait d'une spécification. Lorsqu'une classe satisfait à cette spécification, elle peut être invoquée par d'autres classes spécifiques. Lorsqu'une classe est utilisée comme Java Bean, elle contient un ensemble de propriétés privées, et les opérations de lecture/écriture sur ces propriétés sont effectuées via les méthodes publiques get/is() ou set().
• Introspector (introspection) : The Introspector class provides a standard way for tools to learn about the properties, events, and methods supported by a target Java Bean. For each of those three kinds of information, the Introspector will separately analyze the bean's class and superclasses looking for either explicit or implicit information and use that information to build a BeanInfo object that comprehensively describes the target bean. (Mécanisme de traitement par défaut fourni par Java pour les propriétés, événements et méthodes d'une classe Java Bean. Par exemple, lors de la recherche d'une propriété/méthode dans une classe bean, si elle n'est pas trouvée dans la classe actuelle, la recherche remonte vers la classe parente, etc.)
• BeanInfo : Introspect on a Java Bean and learn about all its properties, exposed methods, and events. If the BeanInfo class for a Java Bean has been previously Introspected then the BeanInfo class is retrieved from the BeanInfo cache. (Effectue l'introspection d'un Java Bean et découvre toutes ses propriétés, méthodes exposées et événements. Si la classe BeanInfo d'un Java Bean a déjà été introspectée auparavant, la classe BeanInfo est récupérée depuis le cache BeanInfo.)
• PropertyDescriptor : Utilisé pour décrire les propriétés exposées par un Java Bean via un ensemble de méthodes d'accès.

Déclarez la classe Java Bean comme suit :```java public class User { private String name;

public User() {
}
public void setName(String name) {
    this.name = name;
}
public String getName() {
    return this.name;
}
public int getAge() {
    return 18;
}

}

Utilisez le code de test suivant pour voir les informations obtenues par Introspector.getBeanInfo :```java
@Test
    public  void testIntrospector() throws IntrospectionException {
        BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
        for (PropertyDescriptor pdesc:beanInfo.getPropertyDescriptors()){
            System.out.println("Property: " + pdesc.getName() + ",Class:" + pdesc.getPropertyType());
        }
//        for (MethodDescriptor md:beanInfo.getMethodDescriptors()) {
//            System.out.println("Method: " + md.getName());
//        }
    }

[No source content provided to translate.]```text Property: age,Class:int Property: class,Class:class java.lang.Class Property: name,Class:class java.lang.String

Outre le prévisible age et ainsi de suite, il y a un attribut class, dont le nom de classe est Class. Si on continue à appeler Introspector.getBeanInfo(Class.class), on peut obtenir plus d'informations comme classLoader, etc. :```text jdk11:
Property: annotatedInterfaces
Property: annotatedSuperclass
Property: annotation
Property: annotations
Property: anonymousClass
Property: array
Property: canonicalName
Property: class
Property: classLoader
Property: classes
Property: componentType
Property: constructors
Property: declaredAnnotations
Property: declaredClasses
Property: declaredConstructors
Property: declaredFields
Property: declaredMethods
Property: declaringClass
Property: enclosingClass
Property: enclosingConstructor
Property: enclosingMethod
Property: enum
Property: enumConstants
Property: fields
Property: genericInterfaces
Property: genericSuperclass
Property: interface
Property: interfaces
Property: localClass
Property: memberClass
Property: methods
Property: modifiers
Property: module
Property: name
Property: nestHost
Property: nestMembers
Property: package
Property: packageName
Property: primitive
Property: protectionDomain
Property: signers
Property: simpleName
Property: superclass
Property: synthetic
Property: typeName
Property: typeParameters

Comparez également les différences des informations obtenues par Introspector.getBeanInfo(Class.class) sous différentes versions de JDK. Ce qui précède est la sortie sous jdk-11, ce qui suit est la sortie sous JDK8 :```text jdk8: Property: annotatedInterfaces Property: annotatedSuperclass Property: annotation Property: annotations Property: anonymousClass Property: array Property: canonicalName Property: class Property: classLoader Property: classes Property: componentType Property: constructors Property: declaredAnnotations Property: declaredClasses Property: declaredConstructors Property: declaredFields Property: declaredMethods Property: declaringClass Property: enclosingClass Property: enclosingConstructor Property: enclosingMethod Property: enum Property: enumConstants Property: fields Property: genericInterfaces Property: genericSuperclass Property: interface Property: interfaces Property: localClass Property: memberClass Property: methods Property: modifiers Property: name Property: package Property: primitive Property: protectionDomain Property: signers Property: simpleName Property: superclass Property: synthetic Property: typeName Property: typeParameters

` ````text
Property: annotatedInterfaces
Property: annotatedSuperclass
Property: annotation
Property: annotations
Property: anonymousClass
Property: array
Property: canonicalName
Property: class
Property: classLoader
Property: classes
Property: componentType
Property: constructors
Property: declaredAnnotations
Property: declaredClasses
Property: declaredConstructors
Property: declaredFields
Property: declaredMethods
Property: declaringClass
Property: enclosingClass
Property: enclosingConstructor
Property: enclosingMethod
Property: enum
Property: enumConstants
Property: fields
Property: genericInterfaces
Property: genericSuperclass
Property: interface
Property: interfaces
Property: localClass
Property: memberClass
Property: methods
Property: modifiers
Property: module
Property: name
Property: package
Property: packageName
Property: primitive
Property: protectionDomain
Property: signers
Property: simpleName
Property: superclass
Property: synthetic
Property: typeName
Property: typeParameters

jdk9 a deux attributs supplémentaires par rapport à JDK8 : module et packageName, tandis que JDK11, en plus des attributs module et packageName, possède deux autres attributs : nestHost et nestMembers.

liaison de données (data binding)

Le processus de liaison des paramètres dans les frameworks web, en termes simples, consiste pour le framework à convertir les paramètres sous forme de chaînes de caractères dans les requêtes HTTP vers les types réellement nécessaires côté serveur. Prenons Spring MVC comme exemple :