spring-RCE-CVE-2022-22965

Resumen de la vulnerabilidad

Recientemente Spring ha publicado una vulnerabilidad CVE de gran repercusión. La información del CVE indica: "A Spring MVC or Spring WebFlux application running on JDK 9+ may be vulnerable to remote code execution (RCE) via data binding. The specific exploit requires the application to run on Tomcat as a WAR deployment. If the application is deployed as a Spring Boot executable jar, i.e. the default, it is not vulnerable to the exploit. However, the nature of the vulnerability is more general, and there may be other ways to exploit it.(una aplicación Spring MVC o Spring WebFlux que se ejecute en JDK 9+ puede ser vulnerable a la ejecución remota de código (RCE) mediante el enlace de datos. La explotación específica requiere que la aplicación se ejecute en Tomcat como un despliegue WAR. Si la aplicación se despliega como un jar ejecutable de Spring Boot, es decir, el valor predeterminado, no es vulnerable a esta explotación. Sin embargo, la naturaleza de la vulnerabilidad es más general y puede haber otras formas de explotarla)". Este análisis estudia el principio de la vulnerabilidad reproduciendo este CVE.

API de Java Bean

Antes de ver el principio del enlace de parámetros de Spring MVC, echemos un vistazo a algunas API relacionadas con Java Bean.

• Java Bean: en realidad es una especificación. Cuando una clase cumple esta especificación, puede ser invocada por otras clases específicas. Cuando una clase se utiliza como Java Bean, contiene un conjunto de propiedades privadas, y las propiedades se leen y escriben mediante los métodos públicos get/is() o set().
• Introspector (introspección): 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.(Es el manejo predeterminado que Java proporciona para las propiedades, eventos y métodos de las clases Java Bean. Por ejemplo, al buscar una propiedad/método de una clase bean, si esta propiedad no se encuentra en la clase bean actual, se busca en la clase padre, 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.(Realiza una introspección de un Java Bean y obtiene todas sus propiedades, métodos expuestos y eventos. Si la clase BeanInfo de un Java Bean ya ha sido inspeccionada previamente, la clase BeanInfo se recupera de la caché de BeanInfo.)
• PropertyDescriptor: se utiliza para describir las propiedades que un Java Bean expone mediante un conjunto de métodos de acceso (accessor methods).

Declare la siguiente clase Java Bean:```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;
}

}

Usemos el siguiente código de prueba para ver la información obtenida por 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());
//        }
    }

salida:```text Property: age,Class:int Property: class,Class:class java.lang.Class Property: name,Class:class java.lang.String

Además de age y name, que son de esperar, también hay una propiedad class cuyo nombre de clase es Class. Si se continúa llamando a Introspector.getBeanInfo(Class.class), se puede obtener más información, como classLoader:```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

Además, comparemos las diferencias en la información obtenida por Introspector.getBeanInfo(Class.class) bajo diferentes versiones de JDK; arriba está la salida de jdk-11 y abajo la de 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

I don't see any source text to translate. The INPUT section is empty. Please provide the Chinese (zh) Markdown content for chunk 11 so I can translate it into Spanish (es).```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

En comparación con JDK8, jdk9 tiene dos atributos adicionales: module y packageName, mientras que JDK11, además de los atributos module y packageName, tiene otros dos: nestHost y nestMembers.